精华内容
下载资源
问答
  • c++链表(详解版)

    万次阅读 多人点赞 2019-06-13 16:27:57
    在自学C++的时候,看到好多人都在提链表,于是就自学了一下,看了很多别人的文章,加入了一些自己的理解,做了一下总结

    在自学C++的时候,看到好多人都在提链表,于是就自学了一下,看了很多别人的文章,加入了一些自己的理解,做了一下总结,因为是初学可能会有些问题,希望大家能指正

    怎么理解链表
    看有个人写的很好,就是说你现在有一个小纸条,上面写着一个抽屉的地址,那个抽屉里有一些你需要的东西,和一个新的写着地址的小纸条,这个小纸条又指向了一个新的抽屉,大体可以这么理解

    程序所包含的头文件

    #include<iostream>
    #include<cstdlib>
    
    using namespace std;
    

    当然如果要做随机顺序的链表的话
    最好也包含ctime这个库

    第一部分—构建抽屉
    既然把装有东西和写有地址的小纸条比作抽屉那么我们不妨先写出抽屉的结构体`

    typedef struct listpoint
    {
        int data;
        listpoint *next;
    }listpoint;
    
    

    这就是一个最简单的结构体
    int data,是一个数字,是我们存在抽屉里的东西
    而listpoint *next是一个指向和这个抽屉结构一样的新的抽屉的指针;

    我们可以在抽屉里放指向下一个抽屉的指针,自然也就可以在抽屉里放指向上一个抽屉的指针

    typedef struct listpoint
    {
        int data;
        listpoint *next;
        listpoint *last;
    }listpoint;
    
    

    我们在抽屉里不仅仅可以放一个数,我们可以往里面放一个收纳盒,例如,在下面的结构体中包含了另一个结构体

    typedef struct data
    {
        int number;
        string name;
        string sex;
    }data;
    
    typedef struct listpoint
    {
        data *information;
        listpoint *next;
        listpoint *last;
    }listpoint;
    
    

    那个叫做information的小收纳盒里,装着一个人的学号,姓名,性别等信息
    /

    第二部分—创建一个链表

    创建一个基础链表

    listpoint *create_normal_list(int n)     /*链表每一个节点都是指向  listpoint结构的指针,所以返回值是listpoint *,n是指创建的链表的节点数目*/
    {
        listpoint *head,*normal,*end;/*创建头节点,其他节点,和尾节点*/
        head=(listpoint*)malloc(sizeof(listpoint));
        head->information=(data*)malloc(sizeof(data));
        /*分配内存*/
        end=head;/*最开始最后一个节点就是头节点,注意因为通过指针可以直接对地址上的东西进行操作,此时end和head指向同一个地址,对end所指向地址进行操作,等同于对head地址所做的操作*/
        for(int i=0;i<n;i++)
        {
            normal=(listpoint*)malloc(sizeof(listpoint));
            normal->information=(data*)malloc(sizeof(data));
            /*给新节点分配内存*/
            cout<<"input the number :";
            cin>>normal->information->number;
            cout<<"input the name   :";
            cin>>normal->information->name;
            cout<<"input the sex    :";
            cin>>normal->information->sex;
            cout<<"----------------------------------"<<endl;
           /* 往新节点存入数据,注意我们只给后面的节点存入数据,head不存数据*/
            end->next=normal;/*往end后增添新节点*/
            normal->last=end;/*新节点的上一个节点就是end*/
            end=normal;/*最后一个节点变成新节点*/
        }
        end->next=NULL;/*链表的最后指向一个新地址*/
        head->last=NULL;/*链表最开始的节点没有上一个节点*/
        return head;
    }
    
    

    创建环状链表
    操作和之前一样,只不过最后一个节点的下一个指向头节点

    listpoint *create_loop_list(int n)
    {
        listpoint *head,*normal,*end;
        head=(listpoint*)malloc(sizeof(listpoint));
        head->information=(data*)malloc(sizeof(data));
        end=head;
        for(int i=0;i<n;i++)
        {
            normal=(listpoint*)malloc(sizeof(listpoint));
            normal->information=(data*)malloc(sizeof(data));
            cout<<"input the number :";
            cin>>normal->information->number;
            cout<<"input the name   :";
            cin>>normal->information->name;
            cout<<"input the sex    :";
            cin>>normal->information->sex;
            cout<<"----------------------------------"<<endl;
            end->next=normal;
            normal->last=end;
            end=normal;
        }
        end->next=head;
        head->last=end;
        return head;
    }
    
    

    创建随机枝杈链表

    **这一部分可以最后再看 **

    每一个节点都有一个分支指向随机一个节点,这时候我们就要引入ctime库用来使用srand((int)(time(NULL)));以生成随机数,这里还用到了后面的一个函数
    listpoint *search_point(listpoint *list,int n);是用来搜索节点的

    #include<iostream>
    #include<cstdlib>
    #include<ctime>
    
    using namespace std;
    
    typedef struct data
    {
        int number;
        string name;
        string sex;
    }data;
    
    typedef struct listpoint
    {
        data *information;
        listpoint *next;
        listpoint *last;
        listpoint *branch;
     }listpoint;
    
    listpoint *create_random_branch_list(int n)
    {
        listpoint *search_point(listpoint *list,int n);
        listpoint *head;
        head=create_normal_list(n);
        listpoint *p,*bp;
        p=head;
        srand((int)(time(NULL)));
        int randnum;
        while((p=p->next)!=NULL)
        {
            randnum=rand()%n+1;
            bp=search_point(head,randnum);
            p->branch=bp;
        }
        return head;
    }
    
    
    

    生成随机排序链表
    同可以最后再看
    先生成正常顺序链表,再从最后n个节点中随机选择一个,将其剔除并插入到第一个节点的位置,然后再从最后n-1个节点中随机选择一个,剔除后插入第二个节点位置,以此类推

    listpoint *create_random_sort_list(int n)
    {
        listpoint *head;
        head=create_normal_list(n);
        listpoint *p1,*p2;
        int n1=0;
        int n2=n;
        srand((int)(time(NULL)));
        int randnum;
        while(n2!=1)
        { 
            p1=head;
            p2=head;
            randnum=rand()%n2+1+n1;
            for(int i=0;i<randnum;i++)
            {p2=p2->next;}
            for(int i=0;i<n1;i++)
            {p1=p1->next;}
            if(randnum==n)
            {
                p2->last->next=NULL;
            }
            else
            {
                p2->next->last=p2->last;
                p2->last->next=p2->next;
            }
            p1->next->last=p2;
            p2->next=p1->next;
            p1->next=p2;
            p2->last=p1;
            n1+=1;
            n2-=1;
        
        }
        return head;
    }
    
    

    /
    第三部分—修改链表

    修改数据,因为我们通过指针可以直接修改地址储存的信息,所以函数并不需要返回值

    void change_point(listpoint *list,int n,data *ifmation)
    {
        listpoint *p;
        p=list;
        for(int i=0;i<n;i++)
        {
            p=p->next;
        }
        p->information=ifmation;
    }
    
    

    删除节点

    void delete_point(listpoint *list,int n)
    {
        listpoint *p;
        p=list;
        for(int i=0;i<n;i++)
        {
            p=p->next;
        }
        p->last->next=p->next;
        p->next->last=p->last;
        free(p);
    }
    
    

    插入节点

    void insert_point(listpoint *list,int n,data *ifmation)
    {
        listpoint *p;
        p=list;
        for(int i=0;i<n-1;i++)
        {
            p=p->next;
        }
        listpoint *insertpoint;
        insertpoint=(listpoint*)malloc(sizeof(listpoint));
        insertpoint->information=ifmation;
        insertpoint->next=p->next;
        p->next->last=insertpoint;
        p->next=insertpoint;
        insertpoint->last=p;
    }
    
    

    搜寻节点

    listpoint *search_point(listpoint *list,int n)
    {
        listpoint *p;
        p=list;
        for(int i=0;i<n;i++)
        {
            p=p->next;
        }
        return p;
    }
    
    

    /
    第四部分—输出数据
    输出单个节点数据

    void output_point(listpoint *point)
    {
        cout<<"the number is :"<<point->information->number<<endl;
        cout<<"the name   is :"<<point->information->name<<endl;
        cout<<"the sex    is :"<<point->information->sex<<endl;
        cout<<"----------------------------------"<<endl;
    }
    
    

    输出整个链表数据

    void output_list(listpoint *point)
    {
        listpoint *p;
        p=point;
        cout<<endl<<endl<<endl;
        while((p=p->next)!=NULL)
        {
            output_point(p);
        }
    }
    
    

    输出部分链表m点到n点

    void output_list_part(listpoint *list,int m,int n)
    {
        int difference=n-m;
        listpoint *p;
        p=list;
        cout<<endl<<endl<<endl;
        for(int i=0;i<m;i++)
        {
            p=p->next; 
        }
        for(int i=0;i<difference+1;i++)
        {
            output_point(p);
            p=p->next;
        }
    }
    
    

    /
    第五部分—主函数应用
    举个例子,生成7个节点的随机顺序链表
    并输出

    int main()
    {
        listpoint *head;
        head=create_random_sort_list(7);
        output_list(head);
        system("pause");
        return 0;
    }
    
    


    第六部分—完整代码

    #include<iostream>
    #include<cstdlib>
    #include<ctime>
    
    using namespace std;
    
    typedef struct data
    {
        int number;
        string name;
        string sex;
    }data;
    
    typedef struct listpoint
    {
        data *information;
        listpoint *next;
        listpoint *last;
        listpoint *branch;
    }listpoint;
    /********************************************************/
    listpoint *create_normal_list(int n)
    {
        listpoint *head,*normal,*end;
        head=(listpoint*)malloc(sizeof(listpoint));
        head->information=(data*)malloc(sizeof(data));
        end=head;
        for(int i=0;i<n;i++)
        {
            normal=(listpoint*)malloc(sizeof(listpoint));
            normal->information=(data*)malloc(sizeof(data));
            cout<<"input the number :";
            cin>>normal->information->number;
            cout<<"input the name   :";
            cin>>normal->information->name;
            cout<<"input the sex    :";
            cin>>normal->information->sex;
            cout<<"----------------------------------"<<endl;
            end->next=normal;
            normal->last=end;
            end=normal;
        }
        end->next=NULL;
        head->last=NULL;
        return head;
    }
    listpoint *create_loop_list(int n)
    {
        listpoint *head,*normal,*end;
        head=(listpoint*)malloc(sizeof(listpoint));
        head->information=(data*)malloc(sizeof(data));
        end=head;
        for(int i=0;i<n;i++)
        {
            normal=(listpoint*)malloc(sizeof(listpoint));
            normal->information=(data*)malloc(sizeof(data));
            cout<<"input the number :";
            cin>>normal->information->number;
            cout<<"input the name   :";
            cin>>normal->information->name;
            cout<<"input the sex    :";
            cin>>normal->information->sex;
            cout<<"----------------------------------"<<endl;
            end->next=normal;
            normal->last=end;
            end=normal;
        }
        end->next=head;
        head->last=end;
        return head;
    }
    listpoint *create_random_branch_list(int n)
    {
        listpoint *search_point(listpoint *list,int n);
        listpoint *head;
        head=create_normal_list(n);
        listpoint *p,*bp;
        p=head;
        srand((int)(time(NULL)));
        int randnum;
        while((p=p->next)!=NULL)
        {
            randnum=rand()%n+1;
            bp=search_point(head,randnum);
            p->branch=bp;
        }
        return head;
    }
    listpoint *create_random_sort_list(int n)
    {
        listpoint *head;
        head=create_normal_list(n);
        listpoint *p1,*p2;
        int n1=0;
        int n2=n;
        srand((int)(time(NULL)));
        int randnum;
        while(n2!=1)
        { 
            p1=head;
            p2=head;
            randnum=rand()%n2+1+n1;
            for(int i=0;i<randnum;i++)
            {p2=p2->next;}
            for(int i=0;i<n1;i++)
            {p1=p1->next;}
            if(randnum==n)
            {
                p2->last->next=NULL;
            }
            else
            {
                p2->next->last=p2->last;
                p2->last->next=p2->next;
            }
            p1->next->last=p2;
            p2->next=p1->next;
            p1->next=p2;
            p2->last=p1;
            n1+=1;
            n2-=1;
        
        }
        return head;
    }
    /********************************************************/
    void change_point(listpoint *list,int n,data *ifmation)
    {
        listpoint *p;
        p=list;
        for(int i=0;i<n;i++)
        {
            p=p->next;
        }
        p->information=ifmation;
    }
    void delete_point(listpoint *list,int n)
    {
        listpoint *p;
        p=list;
        for(int i=0;i<n;i++)
        {
            p=p->next;
        }
        p->last->next=p->next;
        p->next->last=p->last;
        free(p);
    }
    void insert_point(listpoint *list,int n,data *ifmation)
    {
        listpoint *p;
        p=list;
        for(int i=0;i<n-1;i++)
        {
            p=p->next;
        }
        listpoint *insertpoint;
        insertpoint=(listpoint*)malloc(sizeof(listpoint));
        insertpoint->information=ifmation;
        insertpoint->next=p->next;
        p->next->last=insertpoint;
        p->next=insertpoint;
        insertpoint->last=p;
    }
    listpoint *search_point(listpoint *list,int n)
    {
        listpoint *p;
        p=list;
        for(int i=0;i<n;i++)
        {
            p=p->next;
        }
        return p;
    }
    void output_point(listpoint *point)
    {
        cout<<"the number is :"<<point->information->number<<endl;
        cout<<"the name   is :"<<point->information->name<<endl;
        cout<<"the sex    is :"<<point->information->sex<<endl;
        cout<<"----------------------------------"<<endl;
    }
    void output_list(listpoint *point)
    {
        listpoint *p;
        p=point;
        cout<<endl<<endl<<endl;
        while((p=p->next)!=NULL)
        {
            output_point(p);
        }
    }
    void output_list_part(listpoint *list,int m,int n)
    {
        int difference=n-m;
        listpoint *p;
        p=list;
        cout<<endl<<endl<<endl;
        for(int i=0;i<m;i++)
        {
            p=p->next; 
        }
        for(int i=0;i<difference+1;i++)
        {
            output_point(p);
            p=p->next;
        }
    }
    /***************************************************************/
    int main()
    {
        listpoint *head;
        head=create_random_sort_list(7);
        output_list(head);
        system("pause");
        return 0;
    }
    
    

    有错误的地方望指正

    展开全文
  • c++链表

    千次阅读 2017-10-25 19:29:47
    【c/c++】单链表、头指针、头结点、首元节点 转载地址:http://blog.csdn.net/lzm18064126848/article/details/50819574 链表中第一个结点的存储位置叫做头指针,那么整个链表的存取就必须是从头指针开始...

    【c/c++】单链表、头指针、头结点、首元节点

    转载地址:http://blog.csdn.net/lzm18064126848/article/details/50819574

    链表中第一个结点的存储位置叫做头指针,那么整个链表的存取就必须是从头指针开始进行了。之后的每一个结点,其实就是上一个的后继指针指向的位置。

    这里有个地方要注意,就是对头指针概念的理解,这个很重要。“链表中第一个结点的存储位置叫做头指针”,如果链表有头结点,那么头指针就是指向头结点数据域的指针。画一个图吧。

     

    头指针就是链表的名字。头指针仅仅是个指针而已。

    • 头结点是为了操作的统一与方便而设立的,放在第一个元素结点之前,其数据域一般无意义(当然有些情况下也可存放链表的长度、用做监视哨等等)。
    • 有了头结点后,对在第一个元素结点前插入结点和删除第一个结点,其操作与对其它结点的操作统一了。
    • 首元结点也就是第一个元素的结点,它是头结点后边的第一个结点。
    • 头结点不是链表所必需的。
    • 是的,对于头指针,我们也可以有相应的理解了。
    • 在线性表的链式存储结构中,头指针是指链表指向第一个结点的指针,若链表有头结点,则头指针就是指向链表头结点的指针。
    • 头指针具有标识作用,故常用头指针冠以链表的名字
    • 无论链表是否为空,头指针均不为空。头指针是链表的必要元素。
    •  
      单链表也可以没有头结点。如果没有头结点的话,那么单链表就会变成这样:

    1. //这里插入关于链表中有无头节点进行初始化链表知识  
    2. //首先明白头指针与头结点的关系:http://www.nowamagic.net/librarys/veda/detail/1805  
    3. //定义结点的结构体  
    4. //typedef struct LNode{  
    5. //  int data;  
    6. //  struct LNode *next;  
    7. //}LNode,*LinkList;//则定义LinkList L;时,L为链表的头指针。  
    8. //  
    9. //L=(LinkList) malloc (sizeof(LNode)); //创建一个结点,此处返回给L的是一个指针,并且赋给了头指针。  
    10. //L->next=null; //这里说明我创建了一个头结点,即同时运用了头指针和头结点。  
    11. //这么方便只要加上->next就说明创建了头节点。不过你想想头指针是没有next的,只有头结点才有,所以就不难理解了  
    12.   
    13.   
    14. //带头结点初始化  
    15. //Node *head;  //声明头结点  
    16. //首先第一眼看到(*head)->next=NULL;和我们刚才所说是不是一样,只要头指针一旦运用了next操作就自动创建了头结点  
    17. //但是我们今天的重点不在于这个,更多在于Node **head,对于两个指针的操作理解  
    18. //第一个指针*head,表明了head这个指针变量存储的是另外一个指向结构体NODE的指针,第二个指针,即*head作为一个整体  
    19. //其结果是一个指针,其指向的内容就是结构体NODE。经过这么一理解,对于头指针,头结点,首元节点的关系就非常明朗了  
    20. //  void InitList(Node **head){  
    21. //      *head=(Node *)malloc( sizeof(Node));//这里需要明确的第一点,申请内存返回的都是地址  
    22. //      //第二点就是(Node *)表明了其返回的指针指向最后的结果是NODE的结构体,如果是指向int,那么我们就写(int *)  
    23. //      (*head)->next=NULL;  
    24. //}  
    25.   
    26.   
    27. //带头结点尾方便了首元节点和其他节点一样,统一了操作  
    28.     //方式一:  
    29. //  void CreatList(Node **head){  
    30. //      Node *r=*head,*s;//因为前面已经对头结点,头指针初始化过了,因此可以直接使用*head  
    31. //      int a;  
    32. //      while(scanf("%d",&a)){  
    33. //          if(a!=0){  
    34. //              s=(Node *)malloc(sizeof(Node));  
    35. //              s->value=a;  
    36. //              r->next=s;//这里没有着急设置s->next,原因在于后续还要插入数据。因此将s赋值给r  
    37. //              r=s;      
    38. //          }  
    39. //          else{      
    40. //              r->next=NULL;//如果后续输入的数据为空,则就将其设置为null  
    41. //              break;      
    42. //          }  
    43. //      }  
    44. //}  
    45. //调用CreatList(&head);//这句话表明了形参Node **head,只有第一个*才是起作用了,第个*号是和head联系在一起,作为整体使用的  
    46.   
    47.   
    48. //方式二:  
    49. //  void CreatList(Node *head){  
    50. //      Node *r=head,*s;  
    51. //      ... //下面的都一样  
    52. //}  
    53. //调用CreatList(head);  
    54. //  
    55.   
    56. //不带头结点初始化  
    57. //方式一:  
    58. //void InitList(Node **head){  
    59. //      *head=NULL;//这里直接就是指向的首元节点,还有之前自己一个误解,看到head就觉得它就是头指针了,其实它就是随便一个指针变量  
    60.          //并不是像自己之前想的那样的  
    61.   
    62.   
    63.         //从这里才发现,真正有无头节点的区别。  
    64.         //*head=(Node *)malloc( sizeof(Node));//这里需要明确的第一点,申请内存返回的都是地址  
    65.         //第二点就是(Node *)表明了其返回的指针指向最后的结果是NODE的结构体,如果是指向int,那么我们就写(int *)  
    66.         //(*head)->next=NULL;  
    67. //}  
    68. //调用InitList(&head);  
    69. //  
    70. //方式二:  
    71. //void InitList(Node *head){  
    72. //      head=NULL;  
    73. //}  
    74. //调用InitList(head);  
    75.   
    76. //不带头结点尾插入,第一个节点与其他节点分开操作  
    77. //void CreatList(Node  **head){  
    78. //      Node *p,*t;         /*p工作指针,t临时指针*/  
    79. //      int a,i=1;  
    80. //      while(scanf("%d",&a)){  
    81. //          if(a!=0){  
    82. //              t=(Node *)malloc(sizeof(Node));  
    83. //              t->value=a;  
    84. //              if(i==1){  
    85. //                  *head=t;      
    86. //              }  
    87. //              else{  
    88. //                  p->next=t;  
    89. //              }  
    90. //              p=t;  
    91. //          }  
    92. //          else{      
    93. //              p->next=NULL;  
    94. //              break;      
    95. //          }  
    96. //          i++;  
    97. //      }  
    98. //}  
    99. //调用CreatList(&head);  
    100. //其实从上面就可以知道,其实有头结点对于我们来说是一种更加明智更加方便的操作  

    一、两者区别:
         1、不带头结点的单链表对于第一个节点的操作与其他节点不一样,需要特殊处理,这增加了程序的复杂性和出现bug的机会,因此,通常 在单链表的开始结点之前附设一个头结点。
         2、带头结点的单链表,初始时一定返回的是指向头结点的地址,所以一定要用二维指针,否则将导致内存访问失败或异常。
    这点就是指针方面的知识点了。不懂了就回去好好看一下指针
         3、带头结点与不带头结点初始化、插入、删除、输出操作都不样,在遍历输出链表数据时,带头结点的判断条件是while(head->next!=NULL), 而不带头结点是while(head!=NULL),虽然头指针可以在初始时设定,但是如1所述,对于特殊情况如只有一个节点会出现问题。
             
    二、为什么不带头结点初始化有2种方式,而带头结点只有1种方式呢?
     
         因为不带头结点声明Node *head 时;C编译器将其自动初始化为NULL,于是根本不需要调用InitList(head);也即不带头结点的初始化 是个伪操作。而带头结点的初始化在堆开辟了一段内存,需要修改head指针变量指向的地址(即head的值),所以要修改head的值,必须传保存head变量的地址(即二维指针)。而直接调用CreatList(head);相当于传head变量的值,函数修改的是head的副本,无法真正改变head的值。 
    其实这个就是上面所说的第二点内容
     
    、其实本质上还是传值,传址的问题,只不过指针本身保存的地址,让这个过程变得有点纠结。在函数调用需要修改指针变量的指向(value)时, 应该传递指针变量的地址(address)。
          另外,对于函数的形参是指针时,只要该参数不在左边(即都是右值操作),二维指针(形参)就可以简化为一维指针。如上面带头结点的尾插 简化版本。

    展开全文
  • C++链表基本操作 链表的操作基本都有 找个东西不容易
  • C++ 链表

    千次阅读 2014-11-14 00:19:38
    链表

              C++ 常用的数据结构之一的链表,在我们的程序中是经常出现的了。我们学c语言的时候我就知道了 链表。开始它是基于一个机构体的。我们创建链表的时候会返回一个链表头指针,这个头指针我们往往是作为一个全局变量来处理的。我们对于链表的操作方法是都是基于这个头指针的。根据头指针去查找,插入,删除,修改。这个请看这篇博文:http://blog.csdn.net/hizxc/article/details/2136643。这篇博文完全的讲述了,我们单链表的操作。

          C++是经常去封装的,我们也可以对链表进行封装。这时候我们会封装一个链表类。头指针是这个类的一个私有成员。我们还要建立一个节点类。节点类里有next 指针。而链表类中没有。链表类中只提供链表头,这样我们通过这个链表头也可以去操作整个链表,我们把操作链表的方法都归纳到这个l类的成员函数中去,这样就是实现链表类的封装。请看博文:http://blog.sina.com.cn/s/blog_538b279a010009b1.html

        在写MFC的程序的时候,MFC的程序已经为我封装好了链表,我们完全可以用它提供的链表实现功能,还且很健壮,所以我们不用劳心劳力去自己写一个,当然自己去练手也可以去尝试。

    展开全文
  • c++链表使用教程

    2014-12-17 20:09:10
    c++链表
  • c++链表的反转

    2019-09-04 22:49:33
    c++链表的反转,创建链表,插入链表,链表反转,可下载直接运行。
  • C++链表倒序实现方法

    2020-09-04 06:18:43
    主要介绍了C++链表倒序实现方法,是一个很经典的C++链表操作实例,需要的朋友可以参考下
  • c++ 链表

    2012-12-31 15:44:08
    C++中的一个链表容器 : typedef std::list<FreImage> FreImageList; FreImage的结构已知,可以自己定义. 在PB中无法定义链表的结构体,各位有经验的说下......
  • c++链表模板

    2014-02-06 14:48:11
    c++链表模板
  • c++链表的实现

    2016-11-26 12:18:25
    c++链表的实现
  • 简单的C++链表问题,欢迎大家下载
  • 数据结构 c++链表

    2016-04-07 14:19:14
    数据结构 c++链表 有插入。删除。更新。输入。输出等功能
  • C++链表通讯录系统

    2018-07-01 10:41:14
    C++链表通讯录系统,适合新手学习,可以实现添加,修改,删除,查询,文件保存文件打开功能,拿来学习还不错
  • 清华C++链表

    2012-04-15 22:46:47
    C++链表的学习,希望大家都能很好掌握链表,我觉得还是比较有用的。
  • C++链表创建模板

    2019-09-22 10:37:36
    c++ 链表 创建模板

    链表的基本操作要不经大脑思考直接写出

    #include<bits/stdc++.h>
    using namespace std;
    
    typedef struct Node {
    	int data;
    	Node *next;
    }*LinkList;
    
    void creatList(LinkList l1, int length);
    
    int main() {
    	LinkList l1 = new Node;
    	LinkList n=l1;
    	l1->data = -1;
    	l1->next = NULL;//头节点
    	creatList(l1, 4);//创建链表
    	while (n->next) {
    		n = n->next;
    		cout<<n->data<<endl;
    	
    	}
    	delete l1;
    	return 0;
    }
    //创建链表
    void creatList(LinkList l1, int length) {
    	int i = 0;//记录链表长度
    	LinkList p1, p2;
    	p1 = p2 = l1;
    	while (i < length) {
    		p1 = new Node;//创建一个节点
    		p1->data = i+1;
    		p2->next = p1;//节点的移动
    		p2 = p1;
    		i++;
    	}
    	p2->next = NULL;
    }
    
    展开全文
  • c++链表实现

    2012-05-27 17:46:48
    c++链表实现
  • C++链表

    千次阅读 多人点赞 2019-06-20 00:08:14
    C++链表类 个人写的学生管理系统相关的链表类操作 存放数据的节点node类 class node { public: node(); ~node(); char student[20];//学生姓名 long int ID;//学号 int chinese;//成绩 int math; int ...
  • 主要为大家详细介绍了C++链表实现通讯录管理系统,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • c++链表队列的实现

    2008-09-01 11:02:36
    c++链表队列的实现,c++链表队列的实现,c++链表队列的实现,c++链表队列的实现,c++链表队列的实现,c++链表队列的实现
  • C++链表详细注释版

    2015-06-19 20:58:53
    C++链表详细注释版,非常适合新手,详细,实用
  • C++链表操作

    2019-03-17 16:47:09
    C++链表操作 转自https://www.cnblogs.com/byonecry/p/4458821.html
  • C++ 链表相关信息

    2012-05-25 14:42:35
    c++链表的相关实例,对链表的了解更加深刻~~~
  • visual c++链表运用代码

    2010-06-28 11:24:16
    visual c++链表运用代码visual c++链表运用代码
  • C++ 链表 容错 计算器

    2012-01-04 20:38:04
    C++ 链表 容错 计算器
  • C++链表类模板

    2020-01-28 12:12:41
    C++链表类模板 链表(list),即双向链表容器,它不支持随机访问,访问链表元素要指针从链表的某个断点开始,插入和删除操作所花费的时间是固定的,和该元素在链表中的位置无关。list在任何位置插入和删除动作都很快...
  • C++ 链表操作大全

    2011-03-30 17:35:15
    C++链表操作大全:如何创建链表,删除节点,添加节点等
  • c++链表的基本操作

    2014-03-12 22:14:32
    C++链表的基本操作,实现带头节点创建,插入,显示等功能
  • c++链表的创建,插入和删除简单的综合,适合初学者
  • 基于C++链表程序设计

    2009-12-16 14:21:05
    面向对象程序的基于C++链表程序设计,C++链表课题设计完整程序,经典!

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 152,983
精华内容 61,193
关键字:

c++链表

c++ 订阅