C/C++教程
C++ 提高篇 5 之 stack、queue、list 容器
本文主要是介绍C++ 提高篇 5 之 stack、queue、list 容器，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
C++ 自学
- stack 容器
- queue 容器
- list 容器
- list 构造函数
- list 赋值和交换
- list 大小
- list 插入和删除
- list 数据存取
- list 反转和排序
- list 排序案例
stack 容器
概念
- stack（栈） 是一种先进后出的数据结构
- 栈中只有顶端的元素才可以被外界使用，因此栈不予许有遍历行为
常用接口
1. 构造函数
stack<T> st;// stack 采用模板类实现，默认构造函数stack<T> st1(const stack &st);// 拷贝构造函数
2. 数据存取
push(elem);// 向栈顶添加元素pop();// 从栈顶移除一个元素top();// 返回栈顶元素
3. 赋值操作
stack& operator=(const stack &st);// 重载等号运算符
4. 大小操作
empty();// 判断栈是否为空size();// 返回栈的大小
#include <iostream>
using namespace std;
#include <stack>
int main() {
// 1. 构造函数
stack<int> st;
stack<int> st1;
// 2. 数据存取删
// 存 -- 先进后出
st.push(1);
st.push(2);
st.push(3);
// 取栈顶元素
cout << st.top() << endl; // 3
// 删栈顶元素
st.pop();
cout << st.top() << endl; // 2
// 3. 赋值操作
st1 = st;
// 取栈顶元素
cout << st1.top() << endl; // 2
// 4. 大小操作
// 判断栈是否为空
if (st.empty()) {
cout << "栈为空！" << endl;
}
else {
cout << "栈不为空！";
// 如果栈不为空，则输出栈的大小
cout << "，且栈的大小为：" << st.size() << endl; // 栈不为空！，且栈的大小为：2
}
// 利用某种方式取出栈中所有元素
while (!st.empty()) { // 只要栈非空，则进入循环
// 取栈顶元素
cout << st.top() << " "; // 2 1
// 删栈顶元素
st.pop();
}
cout << endl;
system("pause");
return 0;
}
queue 容器
概念
- queue（队列） 是一种先进先出的数据类型，它有二个出口
- 队列容器允许从一端新增元素，从另一端移除元素
- 队列中只有队头和队尾才可以被外界使用，因此队列不许被遍历
- 队列中进数据称为：入队（push）；队列中出数据称为：出队（pop）
常用接口
1. 构造函数
queue<T> que;// queue 采用模板类实现，默认构造函数queue<T> que1(const queue &que);// 拷贝构造函数
2. 数据存取
push(elem);// 往队尾添加元素pop();// 从队头移除一个元素front();// 返回第一个元素back();// 返回最后一个元素
3. 赋值操作
queue& operator=(const queue &que);// 重载等号运算符
4. 大小操作
empty();// 判断队列是否为空size();// 返回队列的大小
#include <iostream>
using namespace std;
#include <queue>
int main() {
// 1. 构造函数
queue<int> que;
queue<int> que1;
// 2. 数据存取
// 存
que.push(1);
que.push(2);
que.push(3);
// 取
// 取队头的第一个元素
cout << que.front() << endl; // 1
// 取队尾的第一个元素
cout << que.back() << endl; // 3
// 删 -- 删队头的第一个元素
que.pop();
cout << que.front() << endl; // 2
// 3. 赋值操作
que1 = que;
cout << que1.front() << endl; // 2
// 4. 大小操作
// 判断队列是否为空
if (que.empty()) {
cout << "队列为空！" << endl;
}
else {
cout << "队列不为空！";
// 如果队列不为空，输出队列的大小
cout << "，且队列大小为：" << que.size() << endl; // 队列不为空！，且队列大小为：2
}
// 利用某种方式取出队列中所有元素
while (!que.empty()) { // 当队列不为空则进入循环
// 显示队头元素
cout << que.front() << " "; // 2 3
// 删除队头元素
que.pop();
}
cout << endl;
system("pause");
return 0;
}
list 容器
概念
》》list（链表）可以将数据进行链式存储，STL 中的链表是一个双向循环链表
》》链表（由一系列的节点组成）是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针实现的
》》节点 由二部分组成，一是存储数据元素的数据域，另一个是存储下一个节点地址的指针域
重点
- 由于链表的存储方式并不是连续的内存空间，因此链表 list 中的迭代器只支持前移和后移，属于双向迭代器
- 性质：插入操作和删除操作都不会造成原有 list 迭代器的失效，这在其它容器，如 vector 中是不成立的
优点
- 采用动态存储分配，不会造成内存浪费和溢出
- 链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素
缺点
链表灵活，但是空间（指针域）和时间（遍历）额外耗费较大
总结
STL 中 list 和 vector 是二个最常被使用的容器，各有优缺点
list 构造函数
函数原型
list<T> li;// list 采用模板类实现，默认构造函数list<T> li1(li.begin(), li.end());// 构造函数将容器 li 区间元素拷贝给自身list<T> li(n, elem);// 构造函数将 n 个 elem 拷贝给自身list<T> li1(const list &li);// 拷贝构造函数
#include <iostream>
using namespace std;
#include <list>
void PrintList(list<int> &li) {
// 利用迭代器遍历 list 容器
for (list<int>::iterator it = li.begin(); it != li.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
int main() {
// 1. 构造函数
list<int> li;
// 插入数据
for (int i = 0; i < 5; i++) {
li.push_back(i + 1);
}
// 打印容器 list 中的元素
PrintList(li); // 1 2 3 4 5
// 2. 构造函数将容器 li 区间元素拷贝给自身
list<int> li1(li.begin(), li.end());
PrintList(li1); // 1 2 3 4 5
// 3. 构造函数将 n 个 elem 拷贝给自身
list<int> li2(6, 6);
PrintList(li2); // 6 6 6 6 6 6
// 4. 拷贝构造函数
list<int> li3(li2);
PrintList(li3); // 6 6 6 6 6 6
system("pause");
return 0;
}
list 赋值和交换
函数原型
list& operator=(const list &li);// 重载赋值运算符li1.assign(li.begin(), li.end());// 将 [begin, end] 区间的数据拷贝给自身li1.assign(n, elem);// 将 n 个 elem 拷贝赋值给本身li1.swap(li);// 容器 li 和 li1 的元素互换
#include <iostream>
using namespace std;
#include <list>
void PrintList(list<int> &li) {
// 利用迭代器遍历 list 容器
for (list<int>::iterator it = li.begin(); it != li.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
int main() {
// 构造函数
list<int> li;
list<int> li1;
list<int> li2;
list<int> li3;
// 插入数据
for (int i = 0; i < 5; i++) {
li.push_back(i + 1);
}
PrintList(li); // 1 2 3 4 5
// 1. 重载赋值运算符
li1 = li;
PrintList(li1); // 1 2 3 4 5
// 2. assign -- 将容量 li 区间元素拷贝过来
// li2.assign(li.begin(), li.begin() + 3); // 双向迭代器，不支持随机访问
li2.assign(li.begin(), ++li.begin());
PrintList(li2); // 1
// 3. assign -- 将 n 个 elem 拷贝给自身
li3.assign(6, 6);
PrintList(li3); // 6 6 6 6 6 6
// 4. 互换容器 -- li3 和 li
li.swap(li3);
PrintList(li); // 6 6 6 6 6 6
PrintList(li3); // 1 2 3 4 5
system("pause");
return 0;
}
list 大小
函数原型
empty();// 判断容器是否为空size();// 容器的大小resize(int num);// 重新指定容器的长度为 num，若容器变长，则以默认值填充新位置；如果容器变短，则末尾超出容器长度的元素将被删除resize(int num, elem);// 重新指定容器的长度为 num，若容器变长，则以 elem 填充新位置；如果容器变短，则末尾超出容器长度的元素将被删除
#include <iostream>
using namespace std;
#include <list>
void PrintList(list<int> &li) {
// 利用迭代器遍历 list 容器
for (list<int>::iterator it = li.begin(); it != li.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
int main() {
// 构造函数
list<int> li;
// 1. 判断容器是否为空
if (li.empty()) {
cout << "容器为空！" << endl; // 容器为空！
}
// 插入数据
for (int i = 0; i < 5; i++) {
li.push_back(i + 1);
}
PrintList(li); // 1 2 3 4 5
// 2. 输出容器大小
cout << li.size() << endl; // 5
// 3. 重新指定容器长度
// 变长 -- 以默认值(0)填充新位置
li.resize(10);
// 输出容器内数据
PrintList(li); // 1 2 3 4 5 0 0 0 0 0
// 变短 -- 超出长度的元素将被删除
li.resize(3);
// 输出容器内数据
PrintList(li); // 1 2 3
// 4. 重新指定容器长度和新位置的默认值
// 变成 -- 以第二个参数 num 填充新位置
li.resize(5, 666);
PrintList(li); // 1 2 3 666 666
// 变短 -- 超出长度的元素将被删除
li.resize(2);
// 输出容器内数据
PrintList(li); // 1 2
system("pause");
return 0;
}
list 插入和删除
函数原型
1. 二端插入和删除
push_back(elem);// 在容器尾部插入一个元素push_front(elem);// 在容器头部插入一个元素pop_back();// 删除容器尾部第一个元素pop_front();// 删除容器头部第一个元素
#include <iostream>
using namespace std;
#include <list>
void PrintList(list<int> &li) {
// 利用迭代器遍历 list 容器
for (list<int>::iterator it = li.begin(); it != li.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
int main() {
// 构造函数
list<int> li;
// 1. 在容器尾部插入元素
li.push_back(1);
li.push_back(2);
li.push_back(3);
PrintList(li); // 1 2 3
// 2. 在容器头部插入元素
li.push_front(4);
li.push_front(5);
li.push_front(6);
PrintList(li); // 6 5 4 1 2 3
// 3. 删除容器头部第一个元素
li.pop_front();
PrintList(li); // 5 4 1 2 3
// 3. 删除容器尾部第一个元素
li.pop_back();
PrintList(li); // 5 4 1 2
system("pause");
return 0;
}
2. 指定位置插入和删除
insert(const_iterator pos, elem);// 迭代器指向 pos 插入元素insert(const_iterator pos, n, elem);// 迭代器指向 pos 插入 n 个元素insert(const_iterator pos, li.begin(), li.end());// 将容器 li 区间元素插入迭代器指向的 pos 位置erase(const_iterator pos);// 删除迭代器指向的元素erase(const_iterator start, const_iterator end);// 删除迭代器指向从 start 到 end 之间的元素remove(elem);// 删除容器中所有与 elem 匹配的元素clear();// 清空容器
#include <iostream>
using namespace std;
#include <list>
void PrintList(list<int> &li) {
// 利用迭代器遍历 list 容器
for (list<int>::iterator it = li.begin(); it != li.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
int main() {
// 构造函数
list<int> li;
// 尾插法
li.push_back(1);
li.push_back(2);
li.push_back(3);
PrintList(li); // 1 2 3
// 1. 迭代器指向位置 pos 插入元素
li.insert(li.begin(), 4);
PrintList(li); // 4 1 2 3
// 2. 迭代器指向位置 pos 插入 n 个元素
li.insert(li.end(), 5, 6);
PrintList(li); // 4 1 2 3 6 6 6 6 6
// 3. 将容量 li 区间元素插入迭代器指向位置 pos
li.insert(++li.begin(), ++li.begin(), --li.end());
PrintList(li); // 4 1 2 3 6 6 6 6 1 2 3 6 6 6 6 6
// 4. 删除迭代器指向位置 pos
li.erase(li.begin());
PrintList(li); // 1 2 3 6 6 6 6 1 2 3 6 6 6 6 6
// 5. 删除迭代器指向从 start 到 end 的元素
li.erase(++li.begin(), --(--li.end()));
PrintList(li); // 1 6 6
// 6. 删除容器中所有与 elem 匹配的元素
li.remove(6);
PrintList(li); // 1
// 7. 清空容器
li.clear();
PrintList(li); // 空
system("pause");
return 0;
}
list 数据存取
函数原型
front();// 返回容器的第一个元素back();// 返回容器最后一个元素
#include <iostream>
using namespace std;
#include <list>
void PrintList(list<int> &li) {
// 利用迭代器遍历 list 容器
for (list<int>::iterator it = li.begin(); it != li.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
int main() {
// 构造函数
list<int> li;
// 尾插法
li.push_back(1);
li.push_back(2);
li.push_back(3);
PrintList(li); // 1 2 3
// 1. 返回容器第一个元素
cout << li.front() << endl; // 1
// 2. 返回容器最后一个元素
cout << li.back() << endl; // 3
system("pause");
return 0;
}
list 反转和排序
函数原型
reverse();// 反转链表sort();// 排序链表
#include <iostream>
using namespace std;
#include <list>
void PrintList(list<int> &li) {
// 利用迭代器遍历 list 容器
for (list<int>::iterator it = li.begin(); it != li.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
int main() {
// 构造函数
list<int> li;
// 尾插法
li.push_back(1);
li.push_back(7);
li.push_back(3);
li.push_back(5);
li.push_back(6);
PrintList(li); // 1 7 3 5 6
// 1. 反转链表
li.reverse();
PrintList(li); // 6 5 3 7 1
// 2. 排序链表
li.sort();
PrintList(li); // 1 3 5 6 7
system("pause");
return 0;
}
list 排序案例
这篇关于C++ 提高篇 5 之 stack、queue、list 容器的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
您可能喜欢
-
增量更新怎么做？-icode9专业技术文章分享11-23
-
压缩包加密方案有哪些？-icode9专业技术文章分享11-23
-
用shell怎么写一个开机时自动同步远程仓库的代码？-icode9专业技术文章分享11-23
-
webman可以同步自己的仓库吗？-icode9专业技术文章分享11-23
-
在 Webman 中怎么判断是否有某命令进程正在运行？-icode9专业技术文章分享11-23
-
如何重置new Swiper?-icode9专业技术文章分享11-23
-
oss直传有什么好处？-icode9专业技术文章分享11-23
-
如何将oss直传封装成一个组件在其他页面调用时都可以使用？-icode9专业技术文章分享11-23
-
怎么使用laravel 11在代码里获取路由列表？-icode9专业技术文章分享11-23
-
怎么实现ansible playbook 备份代码中命名包含时间戳功能？-icode9专业技术文章分享11-22
-
ansible 的archive 参数是什么意思？-icode9专业技术文章分享11-22
-
ansible 中怎么只用archive 排除某个目录？-icode9专业技术文章分享11-22
-
exclude_path参数是什么作用？-icode9专业技术文章分享11-22
-
微信开放平台第三方平台什么时候调用数据预拉取和数据周期性更新接口？-icode9专业技术文章分享11-22
-
uniapp 实现聊天消息会话的列表功能怎么实现？-icode9专业技术文章分享11-22
栏目导航
