devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C++——list容器_c++ list容器

作者：IT小白 | 2024-05-03 09:35:30

赞

踩

c++ list容器

目录

1 list基本概念

2 list构造函数

3 list赋值和交换

4 list大小操作

5 list的插入和删除

6 list数据存取

7 list反转和排序

1 list基本概念

功能：将数据进行链式存储

链表(list)是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的

链表的组成：链表由一系列结点组成

结点的组成：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域

STL中的链表是一个双向循环链表

由于链表的存储方式并不是连续的内存空间，因此链表中list中的迭代器只支持前移后移，属于双向迭代器

list的优点：

○采用动态存储分配，不会造成内存浪费和溢出

○链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素

list的缺点：

○链表灵活，但是空间（指针域）和时间（遍历）额外耗费较大

list有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的失效，这在vector是不成立的。

总结：STL中list和vector是两个最常被使用的容器，各有优缺点。 

2 list构造函数

功能描述：

○创建list容器

函数原型：

○list<T> lst; //list采用模板类实现，对象的默认构造形式；

○list(beg, end); //构造函数将[beg,end)区间中的元素拷贝给本身

○list(n,elem); //构造函数将n个elem拷贝给本身

○list(const list &lst); //拷贝构造函数

  1. #include<iostream>
  2. using namespace std;
  3. #include<list>
  4.  
  5. void printList(const list<int>&L)
  6. {
  7.     for (list<int>::const_iterator it = L.begin(); it != L.end();it++)
  8.     {
  9.         cout << *it << " ";
  10.  
  11.     }
  12.     cout << endl;
  13. }
  14.  
  15. //list容器构造函数
  16. void test01()
  17. {
  18.     //创建list容器
  19.     list<int> L1;
  20.  
  21.     //添加数据
  22.     L1.push_back(10);
  23.     L1.push_back(20);
  24.     L1.push_back(30);
  25.     L1.push_back(40);
  26.  
  27.     //遍历容器
  28.     printList(L1);
  29.  
  30.     //区间方式构造
  31.     list<int> L2(L1.begin(), L1.end());
  32.     printList(L2);
  33.  
  34.     //拷贝构造
  35.     list<int> L3(L2);
  36.     printList(L3);
  37.  
  38.     //n个elem
  39.     list<int> L4(10, 1000);
  40.     printList(L4);
  41. }
  42. int main(){
  43.     test01();
  44.     system("pause");
  45.     return 0;
  46. }

总结：list构造方式同其他几个STL常用容器，熟练掌握即可

3 list赋值和交换

功能描述：

○给list容器进行赋值，以及交换list容器

函数原型：

○assign(beg,end); //将[beg,end)区间中的数据拷贝赋值给本身

○assign(n,elem); //将n个elem拷贝赋值给本身

○list& operator=(const list &lst); //重载等号操作符

○swap(lst); //将lst与自身的元素互换

  1. #include<iostream>
  2. using namespace std;
  3. #include<list>
  4.  
  5. void printList(const list<int>&L)
  6. {
  7.     for (list<int>::const_iterator it = L.begin(); it != L.end();it++)
  8.     {
  9.         cout << *it << " ";
  10.  
  11.     }
  12.     cout << endl;
  13. }
  14. //list容器赋值和交换
  15.  
  16. //赋值
  17. void test01()
  18. {
  19.     //创建list容器
  20.     list<int> L1;
  21.  
  22.     //添加数据
  23.     L1.push_back(10);
  24.     L1.push_back(20);
  25.     L1.push_back(30);
  26.     L1.push_back(40);
  27.  
  28.     printList(L1);
  29.  
  30.     list<int> L2;
  31.     L2 = L1; //operator= 赋值
  32.     printList(L2);
  33.  
  34.     list<int> L3;
  35.     L3.assign(L2.begin(), L2.end());
  36.     printList(L3);
  37.  
  38.     list<int> L4;
  39.     L4.assign(10, 100);
  40.     printList(L4);
  41.  
  42. }
  43.  
  44. //交换
  45. void test02()
  46. {
  47.     list<int> L1;
  48.  
  49.     L1.push_back(10);
  50.     L1.push_back(20);
  51.     L1.push_back(30);
  52.     L1.push_back(40);
  53.  
  54.     list<int> L2;
  55.     L2.assign(10, 100);
  56.  
  57.     cout << "before change: " << endl;
  58.     printList(L1);
  59.     printList(L2);
  60.  
  61.     L1.swap(L2);
  62.     cout << "after change: " << endl;
  63.     printList(L1);
  64.     printList(L2);
  65. }
  66. int main(){
  67.     test01();
  68.     test02();
  69.     system("pause");
  70.     return 0;
  71. }

总结：list赋值和交换操作能够灵活运用即可

4 list大小操作

功能描述：

○对list容器的大小进行操作

函数原型：

○size(); //返回容器中元素的个数

○empty(); //判断容器是否为空

○resize(num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。

○resize(num,elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。

  1. #include<iostream>
  2. using namespace std;
  3. #include<list>
  4.  
  5. void printList(const list<int>&L)
  6. {
  7.     for (list<int>::const_iterator it = L.begin(); it != L.end();it++)
  8.     {
  9.         cout << *it << " ";
  10.  
  11.     }
  12.     cout << endl;
  13. }
  14.  
  15. //list容器大小操作
  16. void test01()
  17. {
  18.     //创建list容器
  19.     list<int> L1;
  20.  
  21.     //添加数据
  22.     L1.push_back(10);
  23.     L1.push_back(20);
  24.     L1.push_back(30);
  25.     L1.push_back(40);
  26.     printList(L1);
  27.  
  28.     //判断容器是否为空
  29.     if(L1.empty())
  30.     {
  31.         cout << "L1 is empty" << endl;
  32.     }
  33.     else
  34.     {
  35.         cout << "L1 is not empty" << endl;
  36.         cout << "L1's size is : " << L1.size() << endl;
  37.     }
  38.  
  39.     //重新指定大小
  40.     L1.resize(10, 10000);
  41.     printList(L1);
  42.  
  43.     L1.resize(2);
  44.     printList(L1);
  45.     
  46. }
  47.  
  48. int main(){
  49.  
  50.     system("pause");
  51.     return 0;
  52. }

总结：

○判断是否为空——empty

○返回元素个数——size

○重新指定个数——resize

5 list的插入和删除

功能描述：

○对list容器进行数据的插入和删除

函数原型：

○ push_back(elem); //在容器尾部加入一个元素

○pop_back(); //删除容器中最后一个元素

○push_front(); //从容器开头插入第一个元素

○pop_front(); //从容器开头移除第一个元素

○insert(pos, elem); //在pos位置插elem元素的拷贝，返回新数据的位置

○insert(pos, n, elem); //在pos位置插入n个elem数据，无返回值

○insert(pos, beg, end); //在pos位置插入[beg, end)区间的数据，无返回值

○clear(); //移除容器的所有数据

○erase(beg, end); //删除[beg, end)区间的数据，返回下一个数据的位置

○erase(pos); //删除pos位置的数据，返回下一个数据的位置

○remove(elem); //删除容器中所有与elem值匹配的元素

  1. #include<iostream>
  2. using namespace std;
  3. #include<list>
  4.  
  5. void printList(const list<int>&L)
  6. {
  7.     for (list<int>::const_iterator it = L.begin(); it != L.end();it++)
  8.     {
  9.         cout << *it << " ";
  10.  
  11.     }
  12.     cout << endl;
  13. }
  14.  
  15. //list容器插入和删除
  16.  
  17. /*
  18. ○ push_back(elem); //在容器尾部加入一个元素
  20. ○ pop_back(); //删除容器中最后一个元素
  22. ○ push_front(); //从容器开头插入第一个元素
  24. ○ pop_front(); //从容器开头移除第一个元素
  26. ○ insert(pos, elem); //在pos位置插elem元素的拷贝，返回新数据的位置
  28. ○ insert(pos, n, elem); //在pos位置插入n个elem数据，无返回值
  30. ○ insert(pos, beg, end); //在pos位置插入[beg, end)区间的数据，无返回值
  32. ○ clear(); //移除容器的所有数据
  34. ○ erase(beg, end); //删除[beg, end)区间的数据，返回下一个数据的位置
  36. ○ erase(pos); //删除pos位置的数据，返回下一个数据的位置
  38. ○ remove(elem); //删除容器中所有与elem值匹配的元素
  39. */
  40.  
  41. void test01()
  42. {
  43.     //创建list容器
  44.     list<int> L1;
  45.  
  46.     //尾插
  47.     L1.push_back(10);
  48.     L1.push_back(20);
  49.     L1.push_back(30);
  50.  
  51.     //头插
  52.     L1.push_front(100);
  53.     L1.push_front(200);
  54.     L1.push_front(300);
  55.  
  56.     printList(L1);
  57.  
  58.     //尾删
  59.     L1.pop_back();
  60.     printList(L1); 
  61.     //头删
  62.     L1.pop_front();
  63.     printList(L1);
  64.  
  65.     //insert插入
  66.     list<int>::iterator it = L1.begin();
  67.  
  68.     L1.insert(++it, 1000);
  69.     printList(L1);
  70.  
  71.     //删除
  72.     it = L1.begin();
  73.     L1.erase(it);
  74.     printList(L1);
  75.  
  76.     //移除
  77.     L1.push_back(10000);
  78.     L1.push_back(10000);
  79.     printList(L1);
  80.     L1.remove(10000);
  81.     printList(L1);
  82.  
  83.     //清空
  84.     L1.clear();
  85.     printList(L1);
  86. }
  87.  
  88.  
  89. int main(){
  90.     test01();
  91.     system("pause");
  92.     return 0;
  93. }

总结：

○尾删——push_back

○尾删——pop_back

○头插——push_front

○头删——pop_front

○插入——insert

○删除——erase

○移除——remove

○清空——clear

6 list数据存取

功能描述：

○对list容器中数据进行存取

函数原型：

○front(); //返回第一个元素

○back(); //返回最后一个元素

  1. #include<iostream>
  2. using namespace std;
  3. #include<list>
  4.  
  5. //list容器 数据存取
  6. void test01()
  7. {
  8.     list<int> L1;
  9.     L1.push_back(10);
  10.     L1.push_back(20);
  11.     L1.push_back(30);
  12.     L1.push_back(40);
  13.  
  14.     //L1[0]不可以用[]访问list容器中的元素
  15.  
  16.     //L1.at(0) 不可以用 at方式访问list容器中的元素
  17.  
  18.     //原因是list本质链表，不是用连续线性空间存储数据，迭代器也是不支持随机访问的
  19.  
  20.     cout << "the fist element is : " << L1.front() << endl;
  21.     cout << "the last element is : " << L1.back() << endl;
  22.  
  23.     //验证迭代器是不支持随机访问的
  24.     list<int> iterator it = L1.begin();
  25.     it++; //支持双向
  26.     it--;
  27.     // it = it + 1; //不支持随机访问
  28. }
  29.  
  30. int main(){
  31.     test01();
  32.     system("pause");
  33.     return 0;
  34. }

总结：

○list容器中不可以通过[]或者at方式访问数据

○返回第一个元素—— front

○返回最后一个二元素—— back

7 list反转和排序

功能描述：

○将容器中的元素反转，以及将容器中的数据进行排序

函数原型：

○reverse() //反转链表

○sort() //链表排序

  1. #include<iostream>
  2. using namespace std;
  3. #include<list>
  4. #include<algorithm>
  5. //list容器 翻转和排序
  6.  
  7. void printList(const list<int>&L)
  8. {
  9.     for (list<int>::const_iterator it = L.begin(); it != L.end();it++)
  10.     {
  11.         cout << *it << " ";
  12.  
  13.     }
  14.     cout << endl;
  15. }
  16.  
  17. void test01()
  18. {
  19.     //反转
  20.     list<int> L1;
  21.     L1.push_back(20);
  22.     L1.push_back(10);
  23.     L1.push_back(50);
  24.     L1.push_back(40);
  25.  
  26.     printList(L1);
  27.  
  28.     //反转
  29.     cout << "after reverse : " << endl;
  30.     L1.reverse();
  31.     printList(L1);
  32.  
  33.     
  34. }
  35.  
  36. bool myCompare(int v1, int v2)
  37. {
  38.     //降序 就让第一个数 > 第二个数
  39.     return v1 > v2;
  40. }
  41.  
  42. //排序
  43. void test02()
  44. {
  45.     //反转
  46.     list<int> L1;
  47.     L1.push_back(20);
  48.     L1.push_back(10);
  49.     L1.push_back(50);
  50.     L1.push_back(40);
  51.  
  52.     printList(L1);
  53.  
  54.     //反转
  55.     cout << "after sort : " << endl;
  56.  
  57.     //所有不支持随机访问迭代器的容器，不可以用标准算法
  58.     //不支持随机访问迭代器的容器，内部会提供对应一些算法
  59.  
  60.     // sort(L1.begin(), L1.end());
  61.     L1.sort(myCompare);//默认排序 从小到大
  62.     printList(L1);
  63.  
  64.     
  65. }
  66.  
  67.  
  68. int main(){
  69.     test02();
  70.     system("pause");
  71.     return 0;
  72. }

总结：

○反转——reverse

○排序——sort（成员函数）

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/528928
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号