C++ 提高篇 5 之 stack、queue、list 容器
2021/11/2 22:11:13
本文主要是介绍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 容器的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
- 2024-11-23增量更新怎么做？-icode9专业技术文章分享
- 2024-11-23压缩包加密方案有哪些？-icode9专业技术文章分享
- 2024-11-23用shell怎么写一个开机时自动同步远程仓库的代码？-icode9专业技术文章分享
- 2024-11-23webman可以同步自己的仓库吗？-icode9专业技术文章分享
- 2024-11-23在 Webman 中怎么判断是否有某命令进程正在运行？-icode9专业技术文章分享
- 2024-11-23如何重置new Swiper?-icode9专业技术文章分享
- 2024-11-23oss直传有什么好处？-icode9专业技术文章分享
- 2024-11-23如何将oss直传封装成一个组件在其他页面调用时都可以使用？-icode9专业技术文章分享
- 2024-11-23怎么使用laravel 11在代码里获取路由列表？-icode9专业技术文章分享
- 2024-11-22怎么实现ansible playbook 备份代码中命名包含时间戳功能？-icode9专业技术文章分享
