C++——list的了解和使用

server/2025/2/4 3:43:12/

目录

引言

list%E4%B8%8Elist-toc" name="tableOfContents" style="margin-left:40px">forward_list与list

list-toc" name="tableOfContents" style="margin-left:40px">标准库中的list

list%E7%9A%84%E5%B8%B8%E7%94%A8%E6%8E%A5%E5%8F%A3-toc" name="tableOfContents" style="margin-left:80px">一、list的常用接口

list%E7%9A%84%E8%BF%AD%E4%BB%A3%E5%99%A8-toc" name="tableOfContents" style="margin-left:120px">1.list的迭代器

list%E7%9A%84%E5%88%9D%E5%A7%8B%E5%8C%96-toc" name="tableOfContents" style="margin-left:120px">2.list的初始化

list%E7%9A%84%E5%AE%B9%E9%87%8F%E6%93%8D%E4%BD%9C-toc" name="tableOfContents" style="margin-left:120px">3.list的容量操作

list%E7%9A%84%E8%AE%BF%E9%97%AE%E6%93%8D%E4%BD%9C-toc" name="tableOfContents" style="margin-left:120px">4.list的访问操作

list%E7%9A%84%E4%BF%AE%E6%94%B9%E6%93%8D%E4%BD%9C-toc" name="tableOfContents" style="margin-left:120px">5.list的修改操作

list%E7%9A%84%E5%85%B6%E4%BB%96%E6%93%8D%E4%BD%9C-toc" name="tableOfContents" style="margin-left:120px">6.list的其他操作

list%E4%B8%8Evector%E7%9A%84%E5%AF%B9%E6%AF%94-toc" name="tableOfContents" style="margin-left:80px">二、list与vector的对比

结束语

引言

本篇博客要介绍的是STL中的list。

求点赞收藏评论关注！！！十分感谢！！！

list%E4%B8%8Elist" name="forward_list%E4%B8%8Elist">forward_list与list

首先我们先简单了解一下forward_list与list：

forward_list与list都是C++标准模板库（STL）中的容器，它们提供了不同的链表实现，适用于不同的场景。

forward_list

定义与结构：

1.forward_list是C++11引入的一种容器，它提供了一种单向链表的数据结构。

2.它只维护一个指向下一个节点的指针，因此内存使用相对高效。

特点：

1.只能在单向遍历，即只能从前往后遍历，不能反向遍历。

2.在已知位置的情况下，插入和删除操作非常高效，时间复杂度为O(1)。

3.不支持通过索引访问元素，只能使用迭代器进行访问。

适用场景：

1.适用于需要频繁进行前向遍历和插入、删除操作的场景。

2.当内存使用要求较高，且不需要双向遍历时，forward_list是更好的选择。

list

定义与结构：

1.list是C++标准库中基于带头双向循环链表实现的容器。

2.它支持双向迭代器，可以从前往后和从后往前遍历。

特点：

1.在任何位置进行插入和删除操作的时间复杂度都是近似O(1)。

2.支持双向遍历，迭代器使用更灵活。

3.与forward_list相比，内存占用稍多，因为每个节点需要维护两个指针（一个指向前一个节点，一个指向下一个节点）。

适用场景：

1.适用于需要双向遍历和更灵活操作的场景。

2.当需要在列表中间频繁插入或删除元素时，list是更好的选择。

具体内容可以看看这两篇文章：

数据结构——单链表

数据结构——双向链表

本文的重点是list。

list" name="%E6%A0%87%E5%87%86%E5%BA%93%E4%B8%AD%E7%9A%84list" style="background-color:transparent">标准库中的list

list%E7%9A%84%E5%B8%B8%E7%94%A8%E6%8E%A5%E5%8F%A3" name="%E4%B8%80%E3%80%81list%E7%9A%84%E5%B8%B8%E7%94%A8%E6%8E%A5%E5%8F%A3">一、list的常用接口

list接口

list%E7%9A%84%E8%BF%AD%E4%BB%A3%E5%99%A8" name="1.list%E7%9A%84%E8%BF%AD%E4%BB%A3%E5%99%A8" style="background-color:transparent">1.list的迭代器

list的迭代器访问元素与我们之前学习的其他容器的迭代器访问一样。

int main()
{list<int> li = { 1, 2, 3, 4, 5 };list<int>::iterator it = li.begin();cout << "顺序遍历：";while (it != li.end()){cout << *it << " ";++it;}cout << endl;cout << "逆序遍历：";list<int>::reverse_iterator rit = li.rbegin();while (rit != li.rend()){cout << *rit << " ";++rit;}return 0;
}

由于list的迭代器是双向迭代器，支持++和--操作，因此可以在list中向前和向后遍历。

list%E7%9A%84%E5%88%9D%E5%A7%8B%E5%8C%96" name="2.list%E7%9A%84%E5%88%9D%E5%A7%8B%E5%8C%96" style="background-color:transparent">2.list的初始化

list的初始化与我们之前学习的其他容器的初始化一样，我们直接看个简单的使用示例：

int main()
{// 默认构造函数list<int> numbers1;cout << "默认构造: ";for (const auto& num : numbers1) {cout << num << " ";}cout << endl;// n个val构造list<int> numbers2(5, 5);cout << "n个val构造: ";for (const auto& num : numbers2) {cout << num << " ";}cout << endl;int arr[] = { 1, 2, 3, 4, 5 };// 通过vector的迭代器初始化list<int> numbers3(arr, arr + sizeof(arr) / sizeof(arr[0]));cout << "迭代器区间构造: ";for (const auto& num : numbers3) {cout << num << " ";}cout << endl;list<int> numbers4 = { 6, 7, 8, 9, 10 };// 拷贝构造list<int> numbers5(numbers4);cout << "拷贝构造: ";for (const auto& num : numbers5) {cout << num << " ";}cout << endl;numbers1 = numbers2;// 赋值重载cout << "赋值重载: ";for (const auto& num : numbers1) {cout << num << " ";}cout << endl;return 0;
}

输出结果为：

list%E7%9A%84%E5%AE%B9%E9%87%8F%E6%93%8D%E4%BD%9C" name="3.list%E7%9A%84%E5%AE%B9%E9%87%8F%E6%93%8D%E4%BD%9C" style="background-color:transparent">3.list的容量操作
函数名称功能
size返回列表中元素的数量
max_size返回列表可容纳的最大元素数量
empty检查列表是否为空，是则返回 true，否则返回 false
resize重新设置列表中元素的数量，超过原来数量则用默认值填充
clear清空列表中的所有元素

这些函数也是很容易理解的，我们还是直接看代码示例：

int main()
{list<int> li = { 1,2,3,4,5 };cout << "Size of list: " << li.size() << endl;cout << "Max size of list: " << li.max_size() << endl;if (li.empty()){cout << "empty" << endl;}else{cout << "not empty" << endl;}li.clear();if (li.empty()){cout << "empty" << endl;}else{cout << "not empty" << endl;}return 0;
}

输出结果为

与deque这一容器一样，list也没有reserve这一接口。

int main()
{list<int> li = { 1,2,3 };li.resize(5);for (auto& num : li){cout << num << " ";}cout << endl;li.resize(2);for (auto& num : li){cout << num << " ";}return 0;
}

输出结果为；

list%E7%9A%84%E8%AE%BF%E9%97%AE%E6%93%8D%E4%BD%9C" name="4.list%E7%9A%84%E8%AE%BF%E9%97%AE%E6%93%8D%E4%BD%9C" style="background-color:transparent">4.list的访问操作
函数名称功能
back返回列表最后一个元素
front返回列表第一个元素

由于list 是一个双向链表，不支持高效的随机访问。在链表中，访问某个元素需要从头节点开始顺序遍历，直到找到目标元素。因此，为 list 提供下标运算符或 at 方法并不合适。

访问操作的使用示例如下：

int main()
{list<int> li = { 1,2,3 };cout << li.front() << endl;cout << li.back() << endl;return 0;
}

输出结果为：

list%E7%9A%84%E4%BF%AE%E6%94%B9%E6%93%8D%E4%BD%9C" name="5.list%E7%9A%84%E4%BF%AE%E6%94%B9%E6%93%8D%E4%BD%9C">5.list的修改操作

常用的修改操作有如下几个：

函数名称功能
push_back在列表尾部添加元素
push_front在列表头部添加元素
pop_back删除列表最后一个元素
pop_front删除列表第一个元素
insert在指定位置插入元素
erase删除指定位置或区间的元素
swap交换两个列表
assign使用指定列表替换原列表

这些接口我们也是十分熟悉了，我们直接看代码示例：

尾删和尾插：

int main()
{list<int> li;li.push_back(1);li.push_back(2);li.push_back(3);li.push_back(4);for (auto& num : li) {cout << num << " ";}cout << endl;li.pop_back();for (auto& num : li){cout << num << " ";}cout << endl;return 0;
}

输出结果为：

头删和头插：

int main()
{list<int> li;li.push_front(1);li.push_front(2);li.push_front(3);li.push_front(4);for (auto& num : li){cout << num << " ";}cout << endl;li.pop_front();for (auto& num : li){cout << num << " ";}cout << endl;return 0;
}

输出结果为：

assign和swap：

int main()
{list<int> li1 = { 1,1,1,1,1 };li1.assign(3, 3);for (auto& num : li1){cout << num << " ";}cout << endl;list<int> li2 = { 2,2,2,2,2 };li1.swap(li2);for (auto& num : li1){cout << num << " ";}cout << endl;for (auto& num : li2){cout << num << " ";}return 0;
}

输出结果为：

insert：

int main()
{list<int> li = { 1,2,3,4,5 };list<int>::iterator it = li.begin();it = li.insert(it, 6);it = li.insert(it, 7);for (auto& num : li){cout << num << " ";}return 0;
}

输出结果为：

erase：

int main()
{list<int> li = { 1,2,3,4,5 };list<int>::iterator it = li.begin();it = li.erase(it);for (auto& num : li){cout << num << " ";}return 0;
}

输出结果为：

list%E7%9A%84%E5%85%B6%E4%BB%96%E6%93%8D%E4%BD%9C" name="6.list%E7%9A%84%E5%85%B6%E4%BB%96%E6%93%8D%E4%BD%9C" style="background-color:transparent">6.list的其他操作

接下来我们来学习list的其他操作：

函数名称功能描述
splice将元素从一个列表转移到另一个列表
remove移除具有特定值的元素
remove_if移除满足条件的元素
unique移除重复的值
sort对容器中的元素进行排序
merge合并已排序的列表
reverse反转元素的顺序

splice：

splice 是 list 提供的一个成员函数，用于将一个列表（list）中的元素移动到另一个列表中，而不需要进行元素复制或移动操作。

使用示例：

int main()
{list<int> li1 = { 1,2,3 };list<int> li2 = { 4,5,6 };list<int> li3 = { 7,8,9 };list<int> li4 = { 0 };// 将 li2 的所有元素拼接到 li1 的末尾// li1 现在包含 {1, 2, 3, 4, 5, 6}// li2 现在为空 {}li1.splice(li1.end(), li2);for (auto num : li1){cout << num << " ";}cout << endl;// 获取 li3 的迭代器，指向第一个元素（7）auto begin1 = li3.begin();// 将迭代器向前移动一位，指向第二个元素（8）++begin1;// 将 li3 的第一个元素（7）移动到 li4 的末尾// li4 现在包含 {0, 7}// li3 现在包含 {8, 9}li4.splice(li4.end(), li3, li3.begin(), begin1);for (auto num : li4){cout << num << " ";}return 0;
}

输出结果为：

remove：

用于从容器中移除所有等于指定值的元素。

与成员函数 erase 不同，成员函数 erase 按元素的位置擦除元素（使用迭代器），此函数  按元素的值删除元素。

int main()
{list<int> li = { 1,2,3,3,4,5 };li.remove(3);for (auto num : li){cout << num << " ";}cout << endl;return 0;
}

输出结果为：

remove_if：

用于从容器中移除满足特定条件的元素。

bool fun(int num)
{return num == 3;
}int main()
{list<int> li = { 1,2,3,3,4,5 };li.remove_if(fun);for (auto num : li){cout << num << " ";}cout << endl;return 0;
}

输出结果为：

unique：

用于移除容器中连续重复的元素。

int main()
{list<int> li = { 1,2,3,3,4,5 };li.unique();for (auto num : li){cout << num << " ";}return 0;
}

输出结果为：

sort：

用于对容器中的元素进行排序。

int main()
{list<int> li = { 9,1,5,3,2,4,8,0,7,6 };li.sort();for (auto num : li){cout << num << " ";}return 0;
}

输出结果为：

merge：

用于将两个已排序的范围合并成一个有序范围。

要求输入的两个范围必须是有序的（通常是升序）。它会将两个范围中的元素按顺序合并到目标范围中。目标范围必须有足够的空间来存储合并后的结果。

int main()
{list<int> li1 = { 1,3,2,5,7 };list<int> li2 = { 2,3,4,6,8 };li1.sort();li2.sort();li1.merge(li2);for (auto num : li1){cout << num << " ";}return 0;
}

输出结果为：

reverse：

用于反转容器中元素的顺序。

int main()
{list<int> li = { 9,1,5,3,2,4,8,0,7,6 };li.reverse();for (auto num : li){cout << num << " ";}return 0;
}

输出结果为：

list%E4%B8%8Evector%E7%9A%84%E5%AF%B9%E6%AF%94" name="%E4%BA%8C%E3%80%81list%E4%B8%8Evector%E7%9A%84%E5%AF%B9%E6%AF%94" style="background-color:transparent">二、list与vector的对比

vectorlist
底层结构动态顺序表，一段连续空间带头结点的双向循环链表
随机访问支持随机访问，访问某个元素效率O(1)不支持随机访问，访问某个元素效率O(N)
插入和删除任意位置插入和删除效率低，需要搬移元素，时间复杂度为O(N)，插入时有可能需要增容，增容:开辟新空间，拷贝元素，释放旧空间，导致效率更低任意位置插入和删除效率高，不需要搬移元素，时间复杂度为0(1)
空间利用率底层为连续空间，不容易造成内存碎片，空间利用率高，缓存利用率高底层节点动态开辟，小节点容易造成内存碎片，空间利用率低，缓存利用率低
迭代器原生态指针对原生态指针(节点指针)进行封装
迭代器失效在插入元素时，要给所有的迭代器重新赋值，因为插入元素有可能会导致重新扩容，致使原来迭代器失效，删除时，当前迭代器需要重新赋值否则会失效插入元素不会导致选代器失效，删除元素时，只会导致当前迭代器失效，其他迭代器不受影响
使用场景需要高效存储，支持随机访问，不关心插入删除效率大量插入和删除操作，不关心随机访问

结束语

求点赞收藏评论关注！！！

感谢各位大佬的支持！！！


http://www.ppmy.cn/server/164792.html

相关文章

Elasticsearch 指南 [8.17] | Search APIs

Elasticsearch 指南 [8.17] | Search APIs

Search API 返回与请求中定义的查询匹配的搜索结果。 http GET /my-index-000001/_search Request GET /<target>/_search GET /_search POST /<target>/_search POST /_search Prerequisites 如果启用了 Elasticsearch 安全功能&#xff0c;针对目标数据流…
阅读更多...
TikTok 推出了一款 IDE，用于快速构建 AI 应用

TikTok 推出了一款 IDE，用于快速构建 AI 应用

字节跳动（TikTok 的母公司）刚刚推出了一款名为 Trae 的新集成开发环境（IDE）。 Trae 基于 Visual Studio Code（VS Code）构建，继承了这个熟悉的平台，并加入了 AI 工具，帮助开发者更快、更轻松地构建应用——有时甚至无需编写任何代码。 如果你之前使用过 Cursor AI，T…
阅读更多...
NLP模型大对比：Transformer ＞Seq2Seq ＞ LSTM ＞ RNN ＞ n-gram

NLP模型大对比：Transformer ＞Seq2Seq ＞ LSTM ＞ RNN ＞ n-gram

结论 Transformer 大于 传统的Seq2Seq 大于 LSTM 大于 RNN 大于 传统的n-gram n-gram VS Transformer 我们可以用一个 图书馆查询 的类比来解释它们的差异&#xff1a; 一、核心差异对比 维度n-gram 模型Transformer工作方式固定窗口的"近视观察员"全局关联的&q…
阅读更多...
《DeepSeek手机版：开启AI移动新时代》

《DeepSeek手机版：开启AI移动新时代》

DeepSeek 手机版爆火&#xff1a;现象与背景 在当今数字化时代&#xff0c;AI 技术的发展日新月异&#xff0c;如同一股汹涌澎湃的浪潮&#xff0c;深刻地改变着我们的生活。而在这股浪潮中&#xff0c;DeepSeek 手机版宛如一颗璀璨的新星&#xff0c;迅速崛起&#xff0c;引发…
阅读更多...
[牛客]公交线路(dijkstra+链式前向星)

[牛客]公交线路(dijkstra+链式前向星)

登录—专业IT笔试面试备考平台_牛客网 #include<bits/stdc.h> using namespace std; #define endl \n typedef long long ll; const int N1e65,M1e85; int cnt0,head[N]; int n,m,s,t; struct node {int v,w,next; }edge[M]; void addedge(int u,int v,int w) {cnt;edge…
阅读更多...
STM32标准库移植RT-Thread nano

STM32标准库移植RT-Thread nano

STM32标准库移植RT-Thread Nano 哔哩哔哩教程链接&#xff1a;STM32F1标准库移植RT_Thread Nano 移植前的准备 stm32标准库的裸机代码&#xff08;最好带有点灯和串口&#xff09;RT-Thread Nano Pack自己的开发板 移植前的说明 本人是在读学生&#xff0c;正在学习阶段&a…
阅读更多...
Nxopen 直齿轮参数化设计

Nxopen 直齿轮参数化设计

NXUG1953 Visualstudio 2019 参考论文&#xff1a; A Method for Determining the AGMA Tooth Form Factor from Equations for the Generated Tooth Root Fillet //FullGear// Mandatory UF Includes #include <uf.h> #include <uf_object_types.h>// Internal I…
阅读更多...
Java 在包管理与模块化中的优势：与其他开发语言的比较

Java 在包管理与模块化中的优势：与其他开发语言的比较

在开发复杂的、规模庞大的软件系统时&#xff0c;包管理和模块化设计起着至关重要的作用。它们不仅决定了代码的组织和可维护性&#xff0c;还直接影响到团队协作效率、扩展性和性能。在众多编程语言中&#xff0c;Java 凭借其成熟的生态系统、强类型系统和标准化的包管理机制&…
阅读更多...
最新文章

Copyright @ 2022~2023