精华内容
下载资源
问答
  • c++list链表
    2022-06-09 16:31:03

    C++ 链表遍历

    首先定义链表的结构:

    struct ListNode {
        int val;        //存储数据
        ListNode *next; //next指针
        ListNode() : val(0), next(NULL) {}  //类似构造函数
        ListNode(int x) : val(x), next(NULL) {}
    };
    

    循环创建链表:

    int main()
    {
     	
     	//创建链表
     	ListNode *head = new ListNode(); //头节点
        ListNode *p=head;                //指针
        int i=1;
        while(i<5){
            ListNode *node = new ListNode(i); // 初始化一个节点
            p->next = node;
            p=p->next;
            i++;
        }
        p->next=NULL;//最后一个节点的指针指向空
    
        
        //遍历链表
        p=head;
        while(p){
            cout<<p<<endl;
            p=p->next;
        }
        return 0;
    }
    
    

    输出以下链表中内容:

    0
    1
    2
    3
    4
    
    更多相关内容
  • C/C++ list链表的理解以及使用

    万次阅读 2021-09-01 16:22:40
    今天我们来一起深入学习一下非常重要以及基础的数据结构——链表(list) 链表是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点(...

    哈喽!这里是一只派大鑫,不是派大星。本着基础不牢,地动山摇的学习态度,从基础的C语言语法讲到算法再到更高级的语法及框架的学习。更好地让同样热爱编程(或是应付期末考试 狗头.jpg)的大家能够在学习阶段找到好的方法、路线,让天下没有难学的程序(只有秃头的程序员 2333),学会程序和算法,走遍天下都不怕!

    今天我们来一起深入学习一下非常重要以及基础的数据结构——链表(list)  

    链表是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点(链表中每一个元素称为结点)组成,结点可以在运行时动态生成。 


    1.C++ 中 list 的介绍

    list 是顺序容器的一种。list 是一个双向链表。使用 list 需要包含头文件 list。双向链表的每个元素中都有一个指针指向后一个元素,也有一个指针指向前一个元素,如图1所示。

    在 list 容器中,在已经定位到要增删元素的位置的情况下,增删元素能在常数时间内完成。如图2所示,在 ai 和 ai+1 之间插入一个元素,只需要修改 ai 和 ai+1 中的指针即可。 

                       

     list 容器不支持根据下标随机存取元素。

    2.list的使用

    STL里自带的list是双向链表

    头文件: <list>

    1. list<int> a;:定义一个int类型的链表a。
    2. Int arr[5]={1,2,3}; list<int> a(arr,arr+3);:从数组arr中的前三个元素作为链表a的初始值。
    3. a.size():返回链表的结点数量。
    4. list<int>::iterator it;:链表定义一个名为it的迭代器(指针)。
    5. a.begin();a.edn();:链表开始和末尾的迭代器指针。
    6. it++; it--;:迭代器指向前一个和后一个元素。
    7. a.push_front(x); a.push_back(x);:在链表开头或者末尾插入x。
    8. a.insert(it,x):在迭代器it的前面插入元素x。
    9. a.pop_front(); a.pop)back();:在删除链表开头或者末尾。
    10. a.erase(it):删除迭代器it所在的元素。
    11. for(it=a.begin();it!=a.end();it++):遍历链表

     

    展开全文
  • c++ list链表的简单使用

    千次阅读 2017-10-29 17:12:01
    题目描述:用链表实现以下功能0 显示链表中的内容1 后跟两个数字 i j 表示在第i个位置插入J2 后跟一个数组 k 表示删除第k个位置内的内容 #include #include #include using namespace std; int main() { int a; ...
    题目描述:用链表实现以下功能
    0 显示链表中的内容
    1 后跟两个数字 i j 表示在第i个位置插入J
    2 后跟一个数组 k 表示删除第k个位置内的内容
    
    
    
    
    #include<iostream>
    #include<cstdio>
    #include<list>
    
    using namespace std;
    
    int main()
    {
        int a;
        list<int>listint ;
        list<int>::iterator  pos;  //好像定义了一个指针
        while(~scanf("%d",&a))
        {
            if(a == 0)
            {
                for(pos = listint.begin(); pos != listint.end(); pos++)  //指向首地址,首地址对应的是0
                {
                    cout<<*pos;   //输出相应地址对应的数据
                        printf(" ");
                }
                printf("\n");
            }
            else if(a == 1)
            {
                int dos,num;
                scanf("%d %d",&dos,&num);
                pos = listint.begin();
    //在dos位置插入一个数值为num的数
    //pos对应的下标应该是dos-1
                for(int i = 1; i < dos; i++)
                    pos++;
                listint.insert(pos,num);
            }
            else
                {
                    int dos;
                    scanf("%d",&dos);
                //删除操作  删除位置为dos的数据
                //pos对应的下标应该为dos-1
                    pos = listint.begin();
                    for(int i = 1; i < dos; i++)
                        pos++;
                    listint.erase(pos);
                }
                }
        return 0;
    }


    
    
    
    
    
    
    功能实现
    
    
    链表的一些其他正常操作
    
    

    (一)创建list对象:

    1)创建没有任何元素的list对象:list<int > l;  

    2)创建具有n个元素的list对象:list<int > l(10);  //创建具有10个整形元素的list对象

    (二)插入元素:

    1)使用push_back()方法从尾部插入元素,链表自动扩张;

    2)使用push_front()方法从头部插入元素,链表自动扩张;

    3)使用insert()方法向迭代器位置插入新元素,链表自动扩张。


    #include<iostream>  
    #include<list>  
    #include<algorithm>  
    using namespace std;  
      
    int main()  
    {  
    	int i;
    	list<int> l;
    	list<int>::iterator pos;
    	//使用push_back()方法从尾部插入元素
    	l.push_back(1);
    	l.push_back(2);
    	l.push_back(3);
    	l.push_back(4);
    	for(pos=l.begin();pos!=l.end();pos++)
    		cout<<*pos<<" ";
    	cout<<endl;
    
    	//使用push_front()方法从头部插入元素
    	l.push_front(0);
    	for(pos=l.begin();pos!=l.end();pos++)
    		cout<<*pos<<" ";
    	cout<<endl;
    
    	//使用insert()方法向迭代器位置插入新元素
    	pos=l.begin();
    	pos++;
    	l.insert(pos,9);
    	for(pos=l.begin();pos!=l.end();pos++)
    		cout<<*pos<<" ";
    	cout<<endl;
    
        return 0;  
    } 
    输出结果:
    1 2 3 4
    0 1 2 3 4
    0 9 1 2 3 4

    (三)遍历元素:

    1)前向遍历:以前向迭代器的方式遍历;

    2)反向遍历:使用反向迭代器进行遍历。


    #include<iostream>  
    #include<list>  
    #include<algorithm>  
    using namespace std;  
      
    int main()  
    {  
    	int i;
    	list<int> l;
    	list<int>::iterator pos;
    	list<int>::reverse_iterator pos1;
    	l.push_back(1);
    	l.push_back(2);
    	l.push_back(3);
    	l.push_back(4);
    
    	//前向遍历
    	for(pos=l.begin();pos!=l.end();pos++)
    		cout<<*pos<<" ";
    	cout<<endl;
        
    	//反向遍历
    	for(pos1=l.rbegin();pos1!=l.rend();pos1++)
    		cout<<*pos1<<" ";
    	cout<<endl;
    
        return 0;  
    } 
    输出结果:
    1 2 3 4
    4 3 2 1

    (四)删除元素:

    1remove(元素值),删除链表中的元素,值相同的元素都会被删除;

    2pop_front()删除链表首元素;

    3pop_back()删除链表尾元素;

    4erase()删除迭代器位置的元素;

    5clear()清空链表容器。



    #include<iostream>  
    #include<list>  
    #include<algorithm>  
    using namespace std;  
      
    int main()  
    {  
    	int i;
    	list<int> l;
    	list<int>::iterator pos;
    	l.push_back(1);
    	l.push_back(3);
    	l.push_back(2);
    	l.push_back(4);
    	l.push_back(-1);
    	l.push_back(0);
    	l.push_back(1);
    
    	for(pos=l.begin();pos!=l.end();pos++)
    		cout<<*pos<<" ";
    	cout<<endl;
    	
    	//remove(元素值),值相同的元素都会被删除
    	l.remove(1);
    	for(pos=l.begin();pos!=l.end();pos++)
    		cout<<*pos<<" ";
    	cout<<endl;
    
    	//pop_front() 删除链表首元素
    	l.pop_front();
    	for(pos=l.begin();pos!=l.end();pos++)
    		cout<<*pos<<" ";
    	cout<<endl;
    
    	//pop_back() 删除链表尾元素
    	l.pop_back();
    	for(pos=l.begin();pos!=l.end();pos++)
    		cout<<*pos<<" ";
    	cout<<endl;
    
    	//erase() 删除迭代器位置的元素
    	pos=l.begin();
    	pos++;
    	l.erase(pos);
    	for(pos=l.begin();pos!=l.end();pos++)
    		cout<<*pos<<" ";
    	cout<<endl;
    
    	//clear()清空链表容器
    	l.clear();
    	cout<<"size="<<l.size()<<endl;
        
        return 0;  
    } 
    输出结果:
    1 3 2 4 -1 0 1
    3 2 4 -1 0
    2 4 -1 0
    2 4 -1
    2 -1
    size=0

    list排序:使用list的成员函数sort()实现升序排序


    #include<iostream>  
    #include<list>  
    using namespace std;  
      
    int main()  
    {  
    	int i;
    	list<int> l;
    	list<int>::iterator pos;
    	l.push_back(1);
    	l.push_back(3);
    	l.push_back(2);
    	l.push_back(4);
    	l.push_back(-1);
    	l.push_back(0);
    	l.push_back(1);
        l.sort();
    	for(pos=l.begin();pos!=l.end();pos++)
    		cout<<*pos<<" ";
    	cout<<endl;
        
        return 0;  
    } 
    输出结果:
    -1 0 1 1 2 3 4


    展开全文
  • C++ 循环链表

    千次阅读 2022-03-18 17:42:12
    使用C++ 创建循环链表,约瑟夫环 上代码: #include <iostream> using namespace std; //约瑟夫环问题 typedef int DataType; typedef struct Node{ DataType data; struct Node *next; }Node; Node *...

    使用C++ 创建循环链表,约瑟夫环
    上代码:

    #include <iostream>
    using namespace std;
    
    //约瑟夫环问题
    typedef int DataType;
    
    typedef struct Node{
        DataType data;
        struct Node *next;
    }Node;
    
    Node *CreateList(DataType a[], int n)
    {
        Node *first = new Node();
        first->next = NULL;
        Node *r = NULL;
        Node *p = NULL;
        r = first;
    
        for(int i = 0; i < n; i++){
            p = new Node();
            p->data = a[i];
            p->next = NULL;
            r->next = p;
            r = p;
        }
        p->next = first->next;          //链表末端指向链表头
        return first;
    }
    
    void DeleteData(Node *first, int x)
    {
        Node *p = first->next;
        Node *r;
        int cnt = 1;                //统计节点数
        while(p->next != first->next && cnt < (x -1)){
            p = p->next;
            cnt++;
        }
        r = p->next;
        p->next = r->next;
        delete r;
    }
    
    void PrintList(Node *first)
    {
        int flag = 0;
        Node *p = first->next;
        while(p != first->next || !flag){
            cout << p->data << " ";
            p = p->next;
            flag = 1;
        }
    }
    
    int main()
    {
        Node *first = NULL;
        DataType Data[100];
        for(int i = 1; i <= 100; i++)
            Data[i - 1] = i;
        first = CreateList(Data, 100);
        PrintList(first);
        cout << endl;
        DeleteData(first, 19);
        cout << "删除后:" << endl;
        PrintList(first);
        return 0;
    }
    
    展开全文
  • C++ 链表list)使用简述

    千次阅读 2022-03-28 11:29:08
    C++ STL 库的 list 容器是一个双向链表。包含在头文件 <list> 中 1、有关函数的作用 list 本身: list<type> li; 定义一个参数类型为 type 的链表 li.push_back(val) 在尾节点后插入...
  • //创建一个结构体来表示链表的结点类型 struct node{ int data; struct node *next; }; using namespace std; int main(){ struct node *head, *p, *q, *t; int i, n, a; //输入要存放的数据 cin >> ...
  • C++反转链表

    千次阅读 2022-02-17 13:27:49
    正规解法(反转链表,通过调整链表指针达到反转链表) 时间复杂度:O(n), 遍历一次链表 空间复杂度:O(1) /* struct ListNode { int val; struct ListNode *next; ListNode(int x) : val(x), next(NULL) { } ...
  • C++ 链表

    千次阅读 2022-06-07 17:15:18
    C++链表笔记
  • c++ 移除链表元素

    2022-06-13 21:58:10
    c++ 移除链表元素
  • C++ STL 链表容器

    2022-05-17 10:06:24
    知识点1【list 容器概念】链表容器 list容器的迭代器是 双向迭代器。 #include <iostream> #include <list> using namespace std; /* 3.6.4.1 list 构造函数 list<T> lstT;//list 采用采用...
  • QT代码实现list链表结构,资源中包含单向链表和双向链表
  • C++链表

    千次阅读 2022-04-05 00:05:44
    C++链表
  • 链表是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点(链表中每一个元素称为结点)组成,结点可以在运行时动态生成。每个结点包括两个部分:...
  • Sort ListC++排序链表
  • c++使用数组实现双链表list

    千次阅读 2018-10-25 22:41:20
    List 是标准类库中的一个类,可以简单视之为双向链表,以线性列的方式管理物件集合。list 的特色是在集合的任何位置增加或删除元素都很快,但是不支持随机存取。list 是类库提供的众多容器(container)之一,除此...
  • c++链表

    2021-12-09 13:32:22
    链表是一种物理存储单元上不连续的存储结构,数组元素之间通过链表中的指针进行链接。链表是由一系列的结点(链表中每一个元素称为结点)组成,结点可以在运行时动态生成。
  • }listnode , *list; 实现思路: 1. 若链表为空或只有一个元素,则直接返回; 2. 设置两个前后相邻的指针p,q. 将p所指向的节点作为q指向节点的后继; 3. 重复2,直到q==NULL 4. 调整链表头和链表尾 示例:以...
  • C++实现双链表(Double Linked List) 语言这个东西不用真的会忘, 我记得前前后后C++的基本语法我也看了好几遍了,一直没有动手写过什么东西,所以一遍遍的看,一遍遍的忘… … 正好最近在看数据结构,想着自己用...
  • c++ 链表的创建与链表常见操作

    千次阅读 2022-06-09 16:03:00
    C++链表的常见操作
  • C++——链表用法总结

    2021-05-25 17:56:22
    C++——链表用法总结 简介 链表是物理存储单元上不连续的存储结构,数据元素之间通过指针进行连接,链表由一系列节点组成,节点可以在运行时动态生成。每个节点包含两部分:存储数据的数据域,存储下一个节点地址的...
  • C++学习 链表,数据结构,链表读取,打印,文件输入
  • 链表是一种物理存储单元上非连续的存储结构,数据元素的逻辑顺序是通过链表中的指针链接实现的 链表由一系列结点组成,一个是存储数据元素的数据域,另一个是存储下一个结点地址的指针域。 数组和链表区别: STL中...
  • list 是 STL 中的一个序列容器,实现的是双向链表,每个元素都有两个指针,分别指向元素的前驱和后继。 list 不需要指定内存大小,因为他存储在不连续的内存空间中,并由指针将他们连接在一起。 由于链表的特点...
  • #include<iostream> using namespace std; struct Node{ int val; Node *next, *random; Node(int x): val(x), next(nullptr), random(nullptr){}; void DeleteList(){ Node*p=this;... int val =
  • C++中创建链表

    千次阅读 2022-03-09 22:37:04
    创建链表: **eg:struct ListNode { int val; ListNode *next; ListNode() : val(0), next(nullptr) {} ListNode(int x) : val(x), next(nullptr) {} ListNode(int x, ListNode *next) : val(x), next(next) {}...
  • 1.认识链表 什么是链表链表是一种通过指针串联在一起的线性结构,每一个节点由两部分组成,一个是数据域一个是指针域(存放指向下一个节点的指针),最后一个节点的指针域指向null(空指针的意思)。 链接的入口...
  • 链表c++实现链表的各种操作

    千次阅读 2022-04-11 14:46:51
    C++实现单链表(含完整代码) 使用C++实现单链表的基本操作 1、创建单链表 2、获取单链表的长度 3、获取单链表index位置的元素值 4、单链表index位置插入val 5、删除单链表index位置的元素 6、删除链表中值val的...
  • C++ 实现 链表合并(数据结构)
  • C++实现链表,模板类

    2018-07-06 17:33:12
    C++实现的模板链表类,没有用到STL的list,是用指针实现的。
  • 关于C++双向链表实现删除和插入操作。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 83,360
精华内容 33,344
关键字:

c++list链表

友情链接: WMV.rar