精华内容
下载资源
问答
  • C++抽象链表类设计(类模板)链表类模板设计作为容器中存放元素的Point类型设计测试程序和运行结果 链表类模板设计 此链表类结构和之前的C语言抽象链表数据类型一致,单向链表,有头尾指针: 利用泛型程序设计...


    链表类模板设计

    1. 此链表类结构和之前的C语言抽象链表数据类型一致C语言抽象链表数据类型(抽象链表库),单向链表,有头尾指针:
      在这里插入图片描述
    2. 利用泛型程序设计方法设计类模板,而不是void *
    3. 简单参考了一下STL中list的源码,依葫芦画瓢,实现迭代器,和for_eachfind算法。(我这链表容器比较简陋,没法直接套进STL的算法用,就自己写一个)这样一来遍历和查找都实现为基于迭代器的函数模板,不再实现为类的成员函数,更通用点。
    4. 根据STL的list容器的源码,对迭代器的*间接寻址运算取的是迭代器所指向的节点元素的数据域,挺绕人的,无论是设计类模板还是函数模板,都要仔细想想类型匹配,写的时候错了好多遍。另外为了符合STL的习惯,容器的end()应该返回最后一个元素后面位置的迭代器。另外,STL中好多容器的成员函数和算法都返回迭代器,我这里都没实现,容器的构造、内存管理我也没去学习,能简略的都简略了。

    dynlist_template.h

    #ifndef DYNLIST_H
    #define DYNLIST_H
    #include <cstdlib>
    
    template<typename T>
    struct MyListNode   //节点类
    {
        T data;                   //数据域
        MyListNode<T> * next;     //指针域
    
        MyListNode(const T & _data): data(_data), next(0) {}
    };
    
    template<typename T>
    struct MyIterator    //迭代器设计
    {
        typedef MyListNode<T> * link_type;
    
        link_type ptr;      //关联到链表的节点
    
        MyIterator<T>(link_type p = 0):ptr(p) {}
    
        T & operator*() {return (*ptr).data;} //对迭代器取值,取到的是节点的数据域
        //T * operator->() const {return &(operator*());}
        MyIterator& operator++()
        {
            ptr = ptr->next;
            return *this;
        }
        MyIterator operator++(int)
        {
            MyIterator tmp = *this;
            ++*this;
            return tmp;
        }
        bool operator==(const MyIterator & x) const {return ptr == x.ptr;}
        bool operator!=(const MyIterator & x) const {return ptr != x.ptr;}
    };
    
    template<typename T>
    class MyList     //链表类
    {
    private:
        int count; //结点个数
        MyListNode<T> * head;//头指针
        MyListNode<T> * tail;//链表尾指针
    
    public:
        MyList(): count(0), head(NULL), tail(NULL) {}//构造函数
        ~MyList()
        {
            Clear();//清空链表
            printf("链表类析构函数调用\n");
        }
    
        MyIterator<T> begin() {return head;}//返回第一个元素的迭代器
        MyIterator<T> end() {return tail->next;}//返回最后一个元素后面位置的迭代器
        void Append(const T & object);//尾部添加
        void Insert(const T & object, int pos);//中间插入
        void Delete(int pos);//删除结点
        void Clear();//清空链表
        int GetCount() { return count; }//结点个数
        bool IsEmpty() { return count == 0; } //链表是否为空
    };
    
    template<typename T>
    void MyList<T>::Append(const T & object)//尾部添加
    {
        MyListNode<T> * p = new MyListNode<T>(object);
        p->next = NULL;
        if (!head) {
            head = p;
            tail = p;
        }
        else {
            tail->next = p;
            tail = p;
        }
        count++;
    }
    
    template<typename T>
    void MyList<T>::Insert(const T & object, int pos)//插入某个结点
    {
        if (pos < count) {
            MyListNode<T> * p = new MyListNode<T>(object);
            p->next = NULL;
            if (pos == 0) {
                p->next = head;
                head = p;
            }
            else {
                MyListNode<T> * u = head;
                for (int i = 0; i < pos - 1; ++i)
                    u = u->next;
                p->next = u->next;
                u->next = p;
            }
            count++;
        }
        else
            Append(object);
    }
    
    template<typename T>
    void MyList<T>::Delete(int pos)//删除某个结点
    {
        if (count == 0)
            return;
        if (pos == 0) {
            MyListNode<T> * p = head;
            head = p->next;
            if (!p->next)
                tail = NULL;
            delete p;
            count--;
        }
        else if (pos < count) {
            MyListNode<T> * u = head;
            MyListNode<T> * p;
            for (int i = 0; i < pos - 1; ++i)
                u = u->next;
            p = u->next;
            u->next = p->next;
            if (!p->next)
                tail = u;
            delete p;
            count--;
        }
    }
    
    template<typename T>
    void MyList<T>::Clear()//清空
    {
        while(head) {
            MyListNode<T> * p = head;
            head = p->next;
            delete p;
            count--;
        }
        tail = NULL;
    }
    
    #endif
    

    作为容器中存放元素的Point类型设计

    point_oop.h

    #ifndef POINT_H
    #define POINT_H
    
    #include <iostream>
    #include <cstdio>
    
    using namespace std;
    
    class Point
    {
    private:
        int x, y;
    public:
        Point(int _x, int _y): x(_x), y(_y) {}
        ~Point()
        {
            printf("(%d, %d)析构\n", x, y);//用来观察析构情况
        }
        void GetValue(int *a, int *b) { *a = x, *b = y; }
        void SetValue(int _x, int _y) { x = _x, y = _y; }
        friend bool operator ==(const Point &a, const Point &b);//判断相等
        friend ostream & operator <<(ostream & os, const Point &a);
        char * TransformIntoString(const char *format) const;//转换成字符串
        static char * DuplicateString(const char *s);
    };
    
    #endif
    

    point_oop.cpp

    #include <iostream>
    #include <cstdio>
    #include <cstring>
    #include "point_oop.h"
    
    using namespace std;
    
    bool operator ==(const Point &a, const Point &b)
    {
        return (a.x == b.x) && (a.y == b.y);
    }
    
    ostream & operator <<(ostream & os, const Point &a)
    {
        os << "(" << a.x << " , " << a.y << ")";
        return os;
    }
    
    char * Point::TransformIntoString(const char *format) const
    {
        char buf[BUFSIZ];
        sprintf(buf, format, x, y);
        return DuplicateString(buf);
    }
    
    char* Point::DuplicateString(const char *s)
    {
        int n = strlen(s);
        char *t = new char[n+1];
        for (int i = 0; i < n; ++i)
            t[i] = s[i];
        t[n] = '\0';
        return t;
    }
    

    测试程序和运行结果

    在C语言版本的程序中,输出Point的不同格式(用(x,y)、<x,y>、{x,y}、[x,y])是用给操作函数传递void *类型的回调参数来实现的,在这里,则通过函数对象(仿函数)PrintPoint来实现的。

    #include <iostream>
    #include "dynlist_template.h"
    #include "point_oop.h"
    
    using namespace std;
    
    template<class Iterator, class Function>
    void for_each(Iterator first, Iterator last, Function f)
    {
        for(; first != last; ++first)
            f(*first);
    }//实现自己的for_each算法
    
    template<class Iterator, class T>
    bool find(Iterator first, Iterator last, const T& value)
    {
        while (first != last){
            if (*first == value)
                return true;
            ++first;
        }
        return false;
    }//实现自己的find算法
    
    class PrintPoint //在for_each中要调用的函数对象
    {
    private:
        const char * tag;
    public:
        PrintPoint(const char * x): tag(x) {}
        void operator()(const Point & obj)
        {
            printf(obj.TransformIntoString(tag));
            printf("->");
        }
    };
    
    int main(void)
    {
        MyList<Point> my_list;
    
        if (my_list.IsEmpty())
            printf("抽象链表目前是空的。\n");
    
        Point my_point(1,2);
        my_list.Append(my_point);
        printf("插入一个点(1,2),现在显示目前链表状况:存储的点元素用(a,b)形式显示:");
        for_each(my_list.begin(), my_list.end(), PrintPoint("(%d, %d)"));
        printf("\n");
    
        if (!my_list.IsEmpty())
            printf("经判断,抽象链表已经不是空的了。\n");
    
        printf("再续上一个元素(5,4):\n");
        my_list.Append(*(new Point(5,4)));
        printf("显示目前链表状况:存储的点元素用<a,b>形式显示:");
        for_each(my_list.begin(), my_list.end(), PrintPoint("<%d, %d>"));
        printf("\n");
    
        printf("再续上俩元素(3,6)和(7,8):\n");
        my_list.Append(*(new Point(3,6)));
        my_list.Append(*(new Point(7,8)));
        printf("显示目前链表状况:存储的点元素以[a,b]形式显示:");
        for_each(my_list.begin(), my_list.end(), PrintPoint("[%d, %d]"));
        printf("\n");
    
        printf("在第2个位置(从第0开始)插入一个元素(4,8):\n");
        my_list.Insert(*(new Point(4,8)), 2);
        printf("显示目前链表状况:存储的点元素用{a,b}形式显示:");
        for_each(my_list.begin(), my_list.end(), PrintPoint("{%d, %d}"));
        printf("\n");
    
        printf("现在抽象链表一共有%d个节点(元素)。\n", my_list.GetCount());
    
        printf("现在搜索这个链表里有没有(7,8)这个元素:");
        if (find(my_list.begin(), my_list.end(), Point(7,8)))
            printf("找到了!\n");
    
        printf("现在搜索这个链表里有没有(10, 11)这个元素:");
        if (find(my_list.begin(), my_list.end(), Point(10,11)))
            printf("找到了!\n");
        else
            printf("没找到!\n");
    
        printf("现在把第1个节点删除:\n");
        my_list.Delete(1);
        printf("显示目前链表状况:存储的点元素用{a,b}形式显示:");
        for_each(my_list.begin(), my_list.end(), PrintPoint("{%d, %d}"));
        printf("\n");
    
        printf("现在抽象链表一共有%d个节点(元素)。\n", my_list.GetCount());
    
        return 0;
    }
    

    运行结果:
    在这里插入图片描述

    展开全文
  • c++通用链表类设计

    千次阅读 多人点赞 2018-06-10 01:54:33
    设计一个通用链表类,要求如下:a.数据成员包含头指针、尾指针、链表中节点个数、顺序访问中当前节点指针和当前节点前一个节点的指针;b.主要的成员函数包含:生成节点(在链表头、尾以及任意位置)、插入节点、...

    刚刚才学了函数模板和类模板,可以说这两种写法确实让c++相比其他语言灵活不少,其实也没有怎么熟练掌握它们的用法,然而实验课就碰到了这样一个题目:

    9.2.2 程序设计
    1.设计一个通用链表类,要求如下:
    a.数据成员包含头指针、尾指针、链表中节点个数、顺序访问中当前节点指针和当前节点前一个节点的指针;
    b.主要的成员函数包含:生成节点(在链表头、尾以及任意位置)、插入节点、删除节点、访问/修改节点、遍历链表,以及一些辅助函数等;
    c.能实现两个链表的复制;
    d.能实现两个链表对象的赋值;

    e.在测试程序中定义两个整型链表A和B,本别插入5个元素,然后把B中的元素加入A的尾部。

    突然一想感觉有点蒙,因为链表那是在c语言中学过的东西,现在要把它应用于c++而且还要实现通用.......

    幸好课本上是有相关的例题(虽然并不相似,但至少可以作为参考),加上其他博主发表的简单用法的解释。

    终于在折腾了一天后总算是把它写了出来,除去睡午觉和玩游戏吃饭的时间,写这个程序已经算是费了很长时间了,

    不过熬到了半夜一点半,终究是有收获的,废话不多说,这里我贴出来代码和一些大致的思路,由于已经很晚了,舍友都睡了而且我自己也有点累了,具体的步骤解析我就先不写了,如果后面有需要的我再另外更新

    大致思路:1.c++中的链表和c语言相似,也可以直接使用c语言的结构体写法 但是既然是c++ 那么就用类来实现

    链表的每一个结点都是一个对象,其中只有两个成员变量:<T>类型的数据和指向下一个结点的指针,本程序中是class node

    2.结点类不负责管理,所有的控制操作都由负责管理的那个类来实现,本程序中是class test

    代码和部分注释如下:(由于写的比较匆忙,遇到的问题很多,基本上是一个一个改过来的,用于调试和测试的代码没有删掉,所以代码比较乱,请见谅)

    说明:由于本人认为题目要求的对于当前和前一个访问节点的操作完全没有必要,可以由其他函数代替,所以此处只声明了now和before这两个变量,并没有对其操作,等后期根据需求再做调整。

    #include<stdio.h>
    #include<iostream.h>
    template<class T>
    class node{//结点类
    public:
    	T data;
        node *next;
    };
    template<class T>
    class test{
    private:
    	node<T> *head;//头部
        node<T> *end;//尾部
        int num;//个数
    	node<T> *now;//当前
    	node<T> *before;//之前
    public:
    	test(int a=0);//构造函数
    	~test();
    	void addp1();//在头部生成节点   ok
    	void addp2();//在尾部生成节点    ok
    	void addp3(int i);//在i处生成节点  ok
    	void createp(int i,node<T>   *inset);//在i处插入节点,需要一个node对象或指针作为参数  ok
    	void deletep(int i);//删除节点          ok
    	node<T>* getaddp(int i);//传出地址用于访问和修改节点    ok
        void testall();//遍历链表
    	node<T>* getinter();//获取链表头用于赋值等等。。。ok
    	void showstate();//状态查看
    	int getnum();//获取当前容量
    	void operator=(test<T>  &t);//重载运算符=
    	void insetlink(int i,test<T>  &t);//在当前链表的i处插入一个类链表  
    };
    template<class T>
    void test<T>::operator=(test<T>  &t){
    	if(this->getnum()!=t.getnum()){
    	cout<<"error!"<<endl;
    	}else{
    int j=t.getnum();
    for(int n=1;n<=j;n++){
    (this->getaddp(n))->data=(t.getaddp(n))->data;
    }
    	}
    }
    
    template<class T>
    test<T>::test(int a){
    num=a;
    head=new node<T>;
    end=head;
    for(int i=1;i<=a;i++){
    node<T> *s=new node<T>;
    end->next=s;
    end=s;
    }
    }
    template<class T>
    int test<T>::getnum(){
    return num;
    }
    
    template<class T>
    test<T>::~test(){
    delete[]   head;
    }
    
    template<class T>
    void test<T>::addp1(){
    num=num+1;
    node<T> *s=new node<T>;
    s->next=head;
    head=s;
    }
    
    template<class T>
    void test<T>::addp2(){
    num=num+1;
    node<T> *s=new node<T>;
    end->next=s;
    end=s;
    }
    template<class T>
    void test<T>::addp3(int i){
    	if(i>=1&&i<=num){
    		node<T> *t=head;
    		for(int j=1;j<=i-1;j++){
    			t=t->next;
    		}
    		node<T> *behind=t->next;
    		node<T>  *add=new node<T>;
    		t->next=add;
    		add->next=behind;
    		num=num+1;
    	}else{
    	cout<<"error:  out of rage"<<endl;
    	}
    }
    template<class T>
    node<T>*  test<T>::getinter(){
    return head;
    }
    template<class T>
    void test<T>::showstate(){
    cout<<"recent data:"<<endl;
    cout<<"the length       :"<<num<<endl;
    cout<<"the begin address:"<<(int)head<<endl;
    cout<<"the end address  :"<<(int)end<<endl;
    }
    template<class T>
    void test<T>::createp(int i,node<T>   *inset){
    if(i>=1&&i<=num){
    		node<T> *t=head;
    		for(int j=1;j<=i-1;j++){
    			t=t->next;
    		}
    		node<T> *behind=t->next;
    		node<T>  *add=inset;
    		t->next=add;
    		add->next=behind;
    		num=num+1;
    	}else{
    	cout<<"error:  out of rage"<<endl;
    	}
    }
    
    template<class T>
    void test<T>::deletep(int i){
    	if(i>=1&&i<=num){
    		if(i==1){
    node<T>  *deletedone=head;
    		head=head->next;
    delete[]  deletedone;
    		num=num-1;}else{
         node<T>		*p=head;
    		for(int j=1;j<=i-2;j++){
    		p=p->next;
    		}
    node<T>  *deletedone=p->next;
    		p->next=(p->next)->next;
    delete[]  deletedone;
    		}
    		num=num-1;
    	}else{
    
    	cout<<"node do not exist"<<endl;
    	}
    }
    
    template<class T>
    node<T>* test<T>::getaddp(int i){
    	if(i>=1&&i<=num){
    		node<T> *t=head;
    		for(int j=1;j<=i-1;j++){
    		t=t->next;
    		}
    		return t;
    	}else{
    	cout<<"error:node do not exist"<<endl;
    	return head;
    	}
    }
    
    /*-----------------辅助函数-------------*/
    template<class T>
    void copylinklist(test<T>  &x,test<T>   &y){//复制  把后者的数据复制给前者(若不同长度则尾部数据有遗失)
    int i=x.getnum();
    int j=y.getnum();
    for(int m=1,int n=1;m<=i&&n<=j;m++,n++){
    (x.getaddp(m))->data=(y.getaddp(n))->data;
    }
    }
    
    template<class T>
    void test<T>::insetlink(int i,test<T>   &t){
    this->num=this->num+t.num;//扩充链表大小
    int begin=i;
    int end=t.getnum();
    for(int j=1;j<=end;j++){
    	node<T>  *u=new node<T>;
    	u->data=t.getaddp(j)->data;
    this->createp(begin,u);
    begin=begin+1;
    }
    }
    
    
    int main(){
    	test<int>  my(5);
    	{node<int>  *n=my.getinter();
        for(int i=1;i<=5;i++){
    	n->data=i;
    	n=n->next;
    	}}
    
    	cout<<endl;
    	{node<int> *pp=my.getinter();
    	for(int j=1;j<=5;j++){
    	cout<<pp->data<<endl;
    	pp=pp->next;
    	}}
    	
    	cout<<"create link succeed!"<<endl;
    
      {my.addp1();//头部增一测试
    	node<int> *pp=my.getinter();
    	for(int j=1;j<=6;j++){
    	cout<<pp->data<<endl;
    	pp=pp->next;
    	}}
    	cout<<"head add test succeed!"<<endl;
        
        {my.addp2();//尾部增一测试
    	node<int> *pp=my.getinter();
    	for(int j=1;j<=7;j++){
    	cout<<pp->data<<endl;
    	pp=pp->next;
    	}}
    	cout<<"end add test succeed!"<<endl;
        
    	{my.addp3(3);//任意位置增一测试
    node<int> *pp=my.getinter();
    	for(int j=1;j<=8;j++){
    	cout<<pp->data<<endl;
    	pp=pp->next;
    	}}
    	cout<<"random add test succeed!"<<endl;
    
    	{//删除节点测试
    	my.deletep(1);
    	my.deletep(3);
    	my.deletep(6);
    	node<int> *pp=my.getinter();
    	for(int j=1;j<=5;j++){
    	cout<<pp->data<<endl;
    	pp=pp->next;
    	}
    	cout<<"delete test succeed!"<<endl;
    	}
    
    	cout<<"following is another subject   A"<<endl;
        test<int>  A(5);
    	A=my;
    		{
    node<int> *pp=A.getinter();
    	for(int j=1;j<=5;j++){
    	cout<<pp->data<<endl;
    	pp=pp->next;
    	}
    	cout<<"operator ''=''  function test succeed!"<<endl;}
    
    
    
    
    cout<<"expand my with the function insetlink()"<<endl;//链表间的插入测试
    	my.insetlink(3,A);
    	{
    node<int> *pp=my.getinter();
    	for(int j=1;j<=10;j++){
    	cout<<pp->data<<endl;
    	pp=pp->next;
    	}
    	cout<<"succeed!"<<endl;
    	}
    
    cout<<endl;
    my.insetlink(10,A);//按题目要求 加入尾部的测试
    {
    node<int> *pp=my.getinter();
    	for(int j=1;j<=15;j++){
    	cout<<pp->data<<endl;
    	pp=pp->next;
    }}
    return 0;
    }

    注:这个程序本身还有很多不足之处,很明显对链表的使用和各种操作很不方便,但这次只是为了测试,我在后面会试着优化一下代码,使其操作和使用更简单方便。

                                                                                                                          Rainforest _YuLin 

                                                                                                                            20180610        1:50

                                                                                                        

    转载请注明出处!



    展开全文
  • 链表类设计

    2019-11-01 11:08:24
    /*链表类设计: (1)向链表中插入元素,主要包括向链表头插入元素和向链表尾插入元素 (2)从链表中删除元素,主要看、包括删去链表头的元素和删去链表尾的元素 */ #include<iostream> using namespace std...
    /*链表类的设计:
    (1)向链表中插入元素,主要包括向链表头插入元素和向链表尾插入元素
    (2)从链表中删除元素,主要看、包括删去链表头的元素和删去链表尾的元素
    */
    #include<iostream>
    using namespace std;
    class link
    {
    	friend class list;
    	link *next;
    	int x;
    public:
    	link():x(0)
    	{
    	}
    	link(int a):x(a)
    	{
    	}
    	void disp()
    	{
    		cout<<"x="<<x<<endl;
    	}
    };
    class list
    {
    	link *first;
    	link *last;
    public:
    	list()
    	{
    		first=last=new link;
    	}	
    	~list()
    	{
    		Clear();
    		delete first;
    	}
    	void Insert(link s)
    	{
    		link *p=first;
    		first=new link;
    		*first=s.x;
    		first->next=p;
    	}
    	void Append(link s)
    	{
    		link *p=last;
    		last=new link;
    		*p=s.x;
    		p->next=last;
    	}
    	void Delete()
    	{
    		if(first==last);
    		else
    		{
    			link *p=first->next;
    			delete first;
    			first=p;
    		}
    	}
    	void Remove()
    	{
    		if(first==last);
    		else if(first->next==last) Delete();
    		else
    		{
    			link *p=first,*q;
    			while(p!=last)
    			{
    				q=p;
    				p=p->next;
    			}
    			delete p;
    			q->next=last;
    		}
    	}
    	void Clear()
    	{
    		link *p=first,*q;
    		while(p!=last)
    		{
    			q=p->next;
    			delete p;
    			p=q;
    		}
    		first=last; 
    	}
    	void disp()
    	{
    		link *p=first;
    		while(p!=last)
    		{
    			p->disp();
    			p=p->next;
    		}
    	}
    };
    int main()
    {
    	list x;
    	x.Insert(link(1));
    	x.Insert(link(2));
    	x.Append(link(3));
    	x.Insert(link(4));
    	x.disp();
    }
    

    在这里插入图片描述

    展开全文
  • 链表类设计与实现(智能指针)

    千次阅读 2016-04-14 08:51:01
    最近读《C++primer》的时候发现了智能指针这个东西,简直好用,用习惯后相较于new和delete代码要简洁不少/****链表类设计与实现,默认构造,拷贝构造,插入,删除,获得长度,显示链表数据****/ #include <memory> /...

    最近读《C++primer》的时候发现了智能指针这个东西,简直好用,用习惯后相较于new和delete代码要简洁不少

    /****链表类设计与实现,默认构造,拷贝构造,插入,删除,获得长度,显示链表数据****/
    #include <memory> //for shared_ptr
    using std::tr1::shared_ptr;//一定要引入命名空间,share_ptr定义在这里
    struct linkNode
    {
        shared_ptr <linkNode> next;
        int data;
    };
    
    class linkedList
    {
    private:
        int length;
        shared_ptr <linkNode> head;
    public:
        linkedList();
        linkedList(const linkedList& otherlist);
    
        void insertToList(int ins);
        //从头结点开始删除1个结点或多个节点
        void deleatFromListBeginHead();
        void deleatFromListBeginHead(int num);
    
        void show();
        int getLemgth();
        shared_ptr<linkNode> getHead();
        ~linkedList();
    
    };
    
    

    数据域用的int类型,有空的时候再把这个改成模版类再发上来

    /****链表类设计与实现,默认构造,拷贝构造,插入,删除,获得长度,显示链表数据****/
    
    #include "stdafx.h"
    #include "linkedList.h"
    #include <memory> //for shared_ptr
    #include <iostream>
    using std::tr1::make_shared;
    //construction
    linkedList::linkedList():length(0)
    {
        head = NULL;
    }//default
    linkedList::linkedList(const linkedList& otherlist)
    {
        auto con = otherlist.head;
        while (con)
        {
            insertToList(con->data);
            con = con->next;
        }
    }
    //change
    //Insret date into list
    void linkedList::insertToList(int ins) {
        auto node = make_shared<linkNode>();
        node->data = ins;
        node->next = head;
        head = node;
        ++length;
    }
    //Deleat date from list begin head
    void linkedList::deleatFromListBeginHead() {
        if (head){
            head = head->next;
            --length;
            std::cout << "Successfully deleted" << std::endl;
        }
        else
        {
            std::cout << "This linkedList is empty" << std::endl;
        }
    }
    void linkedList::deleatFromListBeginHead(int num) {
        if (num >= length){
            for (int i = 0; i < num; ++i){
                head = head->next;
                --length;
            }
            std::cout << "Successfully deleted" << std::endl;
        }
        else{
            std::cout << "This data is invalid" << std::endl;
        }
    }
    //shows
    void linkedList::show() {
        shared_ptr<linkNode> node = head;
        while (node)
        {
            std::cout << head->data<<"->";
            node = node->next;
        }
        if (head)std::cout <<"list is end" << std::endl;
    
    }
    int linkedList::getLemgth() {return length;}
    shared_ptr<linkNode> linkedList::getHead() { return this->head; }
    linkedList::~linkedList()
    {
    }
    

    内存申请

    • 使用shared_ptr的时候最好是用make_shared申请空间,make_shared<int>()的返回值就是一个shared_ptr 类型的指针
    • shared_ptr和new结合使用也可以,shared_ptr <int> p(new int(1024))以直接初始化的形式创建智能指针 (注意:不能用shared_ptr <int> p = new int(1024)的形式进行初始化,因为这样是将内置指针隐式转换为智能指针,是错误的)
    • 若我们事先已经创建好了一个shared_ptr<int> p;名为p的指针,可以通过shared_ptr指针自带的reset方法为p赋值,像这样p.reset(new int (1024));就可以了

    虽然内置指针和智能指针可以转换,但不建议混合使用,那样会造成很多不必要的麻烦

    展开全文
  • 设计一个链表类,实现链表的初始化、插入、删除和打印操作。 节点的定义如下: ```cpp typedef int elementType; typedef struct node { elementType data; node* next; } LList, *PList; ``` 链表类的定义及...
  • 设计一个链表类模板,实现链表的初始化、插入、删除和打印操作。 【输入形式】 输入包括3行。 第一行是链表元素个数n。第二行为n个元素的值。第三行为拟删除的数据位置。 【输出形式】 输出格式不固定。具体参见...
  • 链表类的一些功能: (1)向链表中插入元素,主要包括向链表头插入元素和向链表尾插入元素 (2)从链表中删去元素,主要包括删去链表头元素和删去链表尾元素 (3)所有结点的删除 为了实现上述功能,同时为了满足...
  • C++课程设计,我链表类,编完之后感觉对链表有了更深刻的认识 // h9.h [code="java"]#ifndef h9_h_ #define h9_h_ #include using namespace std; typedef struct LNode { ...
  • 题目:基于链表的学生信息管理系统 要求:   (1)插入节点:输入学生信息后,生成节点并插入链表中;   (2)删除节点:根据给定的学生姓名或学号删除该学生节点;   (3)查找节点:根据给定的学生姓名或学号...
  • 体验用面向对象的方法操作数组和动态链表 了解C++标准和标准模板库
  • C++中的链表类设计

    2013-05-21 20:50:00
    mylist.h // 头文件 struct node { int idata_item; struct ...对链表类分析如下. ...链表类的成员变量(private) ...以上是链表类的有关操作,另外加上构造函数和析构函数; 链表的声明如下:  
  • 高分悬赏:Java语言怎么交换两个双向链表,首先请给出链表设计类,然后再交换!
  • 数据结构课程设计-VC版本的双链表类 完整代码
  • 设计链表

    2020-01-17 12:59:48
    设计链表 今天学习了leetcode的链表卡片,其中涉及到了707题 设计链表 题目要求: 设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性:val 和 next。...在链表类中实现这些功...
  • 链表类 class ChainNode { public: //元素 int element; //下一个节点 ChainNode* next; //空构造函数 ChainNode() {} //包含元素的构造 ChainNode(const int& element) { this->element = ...
  • 题目描述 设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性:val 和 next。...在链表类中实现这些功能: get(index):获取链表中第 index 个节点的值。如果索引无效,则...
  • 设计链表 设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性:val和next。 val是当前节点的值,next是指向下一个节点的指针/引用。 public class MyLinkedList { //单链表结点...
  • 链表类中实现这些功能: get(index):获取链表中第 index 个节点的值。如果索引无效,则返回-1。 addAtHead(val):在链表的第一个元素之前添加一个值为 val 的节点。插入后,新节点将成为链表
  • 链表类中实现这些功能: get(index):获取链表中第 index 个节点的值。如果索引无效,则返回-1。 addAtHead(val):在链表的第一个元素之前添加一个值为 val 的节点。插入后,新节点将成为链表

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,072
精华内容 828
关键字:

链表类设计