精华内容
下载资源
问答
  • C++链表

    2019-09-10 22:32:16
    C++链表 今天的种树是练习一下C++的数据结构的使用。链表没啥好介绍的直接上代码。 c++实现 主要内容写了三个函数:1.利用堆栈倒序打印链表 2.把一个节点添加到链表末尾 3.删除第一个值为value的节点 #include <...

    C++链表

    今天的种树是练习一下C++的数据结构的使用。链表没啥好介绍的直接上代码。

    c++实现

    主要内容写了三个函数:1.利用堆栈倒序打印链表 2.把一个节点添加到链表末尾 3.删除第一个值为value的节点

    #include <iostream>
    #include <stack>
    using namespace std;
    struct List
    {
        int value;
        List* next;
    };
    //利用堆栈倒叙打印链表
    void printListNode(List* head)
    {
        std::stack<List*> nodes;
        List* node = head;
        while(node != nullptr)
        {
            nodes.push(node);
            node = node->next;
        }
        while(!nodes.empty())
        {
            node = nodes.top();
            printf("%d ", node->value);
            nodes.pop();
        }
    }
    //把一个节点添加到链表末尾
    void AddToTail(List** head, int value)
    {
        List* newNode = new List();
        newNode->value = value;
        newNode->next = nullptr;
        if(*head == nullptr)
        {
            *head = newNode;
        }
        else
        {
            List* node = *head;
            while(node->next != nullptr)
                node = node->next;
            node->next = newNode;
        }
    }
    
    //删除第一个值为value的节点
    void DeleteTailNode(List** head, int value)
    {
        if(*head == nullptr)
            return;
        List* ToBeDeleted = nullptr;
        if((*head)->value == value)
        {
            ToBeDeleted = *head;
            *head = (*head)->next;
        }
        else
        {
            List* pNode = *head;
            while(pNode->next != nullptr && pNode->next->value != value)
                pNode = pNode->next;
            if(pNode->next->value == value && pNode->next->next != nullptr)
            {
                ToBeDeleted = pNode->next;
                pNode->next = pNode->next->next;
            }
        }
        if(ToBeDeleted != nullptr)
        {
            delete ToBeDeleted;
            ToBeDeleted = nullptr;
        }
    }
    
    int main()
    {
        List* head = new List();
        head->value = 1000;
        head->next = nullptr;
        for(int i = 1; i <= 10; i++)
            AddToTail(&head, i);
        printListNode(head);
        cout << endl;
        DeleteTailNode(&head, 5);
        printListNode(head);
    }
    
    

    运行结果

    在这里插入图片描述
    写论文真的烦,种树+2

    展开全文
  • c++链表

    2017-03-05 11:20:37
    c++链表入门级代码

    贴两个关于c++链表的代码

    代码一是一个双向链表

    #include <iostream>
    
    using namespace std;
    
    typedef struct PNODE {
        int m;
        struct PNODE *next;
        struct PNODE *previous;
    } node, *Pnode;
    
    int main()
    {
        int n;
        cin >> n;
        Pnode PHead = new(node);
        Pnode PLast = new(node);
        PHead->next = PLast;
        PHead->previous = NULL;
        PLast->next = NULL;
        PLast->previous = PHead;
        Pnode PTail = PHead;
        for (int i = 0; i < n; i++) {
            Pnode PNew = new(node);
            cin >> PNew->m;
            PNew->previous = PTail;
            PNew->next = PTail->next;
            PTail->next = PNew;
            PNew->next->previous = PNew;
            PTail = PTail->next;
        }
    
        PTail = PLast->previous;
        while (PTail->previous != NULL) {
            cout << PTail->m << endl;
            PTail = PTail->previous;
        }
    
        return 0;
    }

    代码二是顺序表元素的比较和删除,题目如下

    已知a、b和c三个递增有序的线性表,现在要求对a做如下操作:删除其中既即在b中出现又在c中出现的元素(注意同一表中的元素有可能重复)。

    #include <iostream>
    
    using namespace std;
    
    typedef struct PNODE {
        int m;
        struct PNODE *next;
    }PNode, *Node;
    
    //这一块函数在写的时候调了好几次,个人认为可以加深对指针的理解
    void Input(Node *P, int n)
    {
        *P = new(PNode);
        Node PHead = *P;
        PHead->next = NULL;
        Node PTail = PHead;
        for (int i = 0; i < n; i++) {
            Node PNew = new(PNode);
            cin >> PNew->m;
            PNew->next = NULL;
            PTail->next = PNew;
            PTail = PNew;
        }
    }
    
    int main()
    {
        int n, m, l;
        cin >> n >> m >> l;
    
        Node PNHead, PMHead, PLHead;
        Input(&PNHead, n);
        Input(&PMHead, m);
        Input(&PLHead, l);
    
        Node PNTail = PNHead;
        Node PMTail = PMHead;
        Node PLTail = PLHead;
        while (PNTail->next != NULL) {
          //这个地方&&前后不能颠倒,因为根据c++(c)语言编译器的特性从左向右判断,颠倒后就会报错
            while (PMTail->next != NULL && PNTail->next->m > PMTail->next->m)
                PMTail = PMTail->next;
            while (PLTail->next != NULL && PNTail->next->m > PLTail->next->m)
                PLTail = PLTail->next;
            if (PMTail->next == NULL || PLTail->next == NULL)
                break;
            if (PNTail->next->m == PMTail->next->m && PNTail->next->m == PLTail->next->m) {
                Node P = PNTail->next;
                PNTail->next = P->next;
              //这个地方建议养成这个习惯,减少写大东西的时候不必要的内存泄露
                delete(P);
            }
            else
                PNTail = PNTail->next;
        }
    
        PNTail = PNHead->next;
        while (PNTail != NULL) {
            cout << PNTail->m << endl;
            PNTail = PNTail->next;
        }
    
        return 0;
    }
    展开全文
  • C++ 链表

    2019-09-24 19:37:15
    C++ 经常使用的数据结构之中的一个的链表,在我们的程序中是经常出现的了。我们学c语言的时候我就知道了 链表。開始它是基于一个机构体的。我们创建链表的时候会返回一个链表头指针,这个头指针我们往往是作为一个...

              C++ 经常使用的数据结构之中的一个的链表,在我们的程序中是经常出现的了。我们学c语言的时候我就知道了 链表。開始它是基于一个机构体的。

    我们创建链表的时候会返回一个链表头指针,这个头指针我们往往是作为一个全局变量来处理的。我们对于链表的操作方法是都是基于这个头指针的。依据头指针去查找,插入。删除,改动。这个请看这篇博文:http://blog.csdn.net/hizxc/article/details/2136643。

    这篇博文全然的讲述了,我们单链表的操作。

          C++是常常去封装的,我们也能够对链表进行封装。这时候我们会封装一个链表类。

    头指针是这个类的一个私有成员。

    我们还要建立一个节点类。

    节点类里有next 指针。

    而链表类中没有。

    链表类中仅仅提供链表头,这样我们通过这个链表头也能够去操作整个链表,我们把操作链表的方法都归纳到这个l类的成员函数中去,这样就是实现链表类的封装。请看博文:http://blog.sina.com.cn/s/blog_538b279a010009b1.html

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

    转载于:https://www.cnblogs.com/ljbguanli/p/6753343.html

    展开全文
  • 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++ 链表

    2014-06-03 16:54:48
    c/c++种的链表 什么是链表链表有什么好处?作用是什么? 链表是一种动态地进行动态存储分配的一种结构。
  • C++链表倒序实现方法

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

    2016-11-26 12:18:25
    c++链表的实现
  • 简单的C++链表问题,欢迎大家下载
  • C++链表通讯录系统

    2018-07-01 10:41:14
    C++链表通讯录系统,适合新手学习,可以实现添加,修改,删除,查询,文件保存文件打开功能,拿来学习还不错
  • /*--------------------------------- 15-02结构体链表-类的封装形式-静态链表 注意对比小节“C++ 链表 1-- 结构体链表”1) 静态链表:所有节点数据在内存中的分布都是在编译时就确定好的,不会在运行时动态的分配...
  • c++链表学习

    2020-11-12 17:02:56
    C++链表学习前言创建简单的链表合并两个有序链表总结 前言 最近在学习C++算法与数据结构,利用csdn写一些笔记帮助自己记忆,同时也希望对你们有用。 创建简单的链表 代码如下(示例): struct ListNode { int ...
  • 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++链表创建模板

    2019-09-22 10:37:36
    c++ 链表 创建模板
  • 主要为大家详细介绍了C++链表实现通讯录管理系统,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • C++链表操作

    2019-03-17 16:47:09
    C++链表操作 转自https://www.cnblogs.com/byonecry/p/4458821.html
  • C++ 链表 容错 计算器

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

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

    2020-05-09 22:57:56
    C++链表类模版 //构造函数 //创建n个元素的列表 //拷贝构造 //释放链表 //析构函数(虚) //输出链表 //用t替换掉当前结点内容 //重载赋值运算符= //获取当前链表的长度或结点数 // 当前结点位置:第 n (从 0 起)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 20,938
精华内容 8,375
关键字:

c++链表

c++ 订阅