C++ STL容器篇(二) day13

[小瓜偷学编程]

已于 2023-09-25 11:24:04 修改

阅读量76

点赞数

分类专栏：励志学习C瓜瓜文章标签： c++ 开发语言笔记学习

于 2023-09-09 11:21:06 首次发布

本文链接：https://blog.csdn.net/qq_44924388/article/details/132739278

版权

励志学习C瓜瓜专栏收录该内容

19 篇文章 0 订阅

订阅专栏

本文详细介绍了C++STL中的四种容器：stack（栈）、queue（队列）、deque（双端队列）和priority_queue（优先队列），包括它们的基本功能、操作方法以及如何处理自定义类型的使用。

摘要由CSDN通过智能技术生成

C++ STL容器篇(二) day13

STL(stack)

stack就是栈的意思,存储容器满足FILO(先进后出)规则
栈的库函数不多，具体查官方手册stack官方手册
- empty 测试 stack 是否为空。
- pop 从 stack 的顶部删除元素。
- push 将元素添加到 stack 顶部。
- size 返回 stack 中的元素数量。
- top 返回对 stack 顶部元素的引用。

#include <iostream>
#include <stack>
void testStack()
{
	std::stack<int> sta;
	//入栈
	for (int i = 1; i <= 10; i++)
	{
		sta.push(i);
	}
	std::cout << "此时栈里的元素个数：" << sta.size() << std::endl;
	//出栈
	while (!sta.empty())
	{
		//获取栈顶元素
		std::cout << sta.top() << " ";
		//删除顶部元素
		sta.pop();
	}
	std::cout << std::endl << "删除后栈里的元素个数：" << sta.size() << std::endl;
}
class student
{
public:
	student(std::string name = "", int age = 0) : m_name(name), m_age(age) {}
	//运算符重载
	friend student operator<<(std::ostream& out, student& xiaogua)
	{
		out << xiaogua.m_name <<" " << xiaogua.m_age;
		return xiaogua;
	}
	//提供共有接口
	std::string getName()
	{
		return m_name;
	}
	int getAge()
	{
		return m_age;
	}
protected:
	std::string m_name;
	int m_age;
};
void testOperation()
{
	//操作自定义类型，注意提供共有接口或者运算符重载
	std::stack<student> xiaogua;
	xiaogua.push(student("小瓜", 21));
	xiaogua.push(student("大瓜", 22));
	//运算符重载的方法
	while (!xiaogua.empty())
	{
		std::cout << xiaogua.top();
		std::cout << std::endl;
		xiaogua.pop();
	}
	xiaogua.push(student("小瓜", 21));
	xiaogua.push(student("大瓜", 22));
	//共有接口的方法
	while (!xiaogua.empty())
	{
		std::cout << xiaogua.top().getName() << " " << xiaogua.top().getAge()<<std::endl;
		xiaogua.pop();
	}
}
int main()
{
	//testStack();
	testOperation();
	return 0;
}

一个小例子：十进制转二进制(整除法栈运用)

#include <iostream>
#include <stack>
int binaryTodecimalism(int num)
{
	std::stack<int> sta;
	while (num != 0)
	{
		sta.push(num % 2);
		num /= 2;
	}
	while (!sta.empty())
	{
		std::cout << sta.top();
		sta.pop();
	}
	std::cout << std::endl;
	return 0;
}
int main()
{
	binaryTodecimalism(123);
	return 0;
}

运行结果

STL(queue)

普通队列(queue)

queue就是队列的意思，存储容器满足FIFO(先进先出)规则
普通队列和栈通常称为适配器容器，是没有迭代器的
库函数基本与栈差不多，具体查看官方手册queue官方手册
- back 返回对在 queue 后部最近添加的最后一个元素的引用。
- empty 测试 queue 是否为空。
- front 返回对 queue 前部的第一个元素的引用。
- pop 从 queue 前端移除一个元素。
- push 将元素添加到 queue 的后部。
- size 返回 queue 中的元素数量。

#include <iostream>
#include <queue>
void testQueue()
{
	std::queue<int> que;
	//插入
	for (int i = 1; i <= 10; i++)
	{
		que.push(i);
	}
	std::cout << "size:" << que.size() << std::endl;
	//比栈多一个返回尾部元素back
	std::cout << "尾部元素：" << que.back() << std::endl;
	while (!que.empty())
	{
		//返回第一个元素
		std::cout << que.front() << " ";
		que.pop();
	}
	std::cout << std::endl << "size:" << que.size() << std::endl;
}
int main()
{
	testQueue();
	return 0;
}

双端队列(deque)

双端队列相当于融合了栈和普通队列，可以使用迭代器与下标访问
库函数较多，但是大部分不怎么常用，具体查看官方手册deque官方手册
- assign 将元素从 deque 中清除并将新的元素序列复制到目标 deque。
- at 返回对 deque 中指定位置的元素的引用。
- back 返回对 deque 中最后一个元素的引用。
- begin 返回对 deque 中第一个元素进行寻址的随机访问迭代器。
- cbegin 返回指向 deque 中第一个元素的 const 迭代器。
- cend 返回指向刚超出 deque 末尾位置的随机访问 const 迭代器。
- clear 清除 deque 的所有元素。
- crbegin 返回指向以相反顺序查看的 deque 中的第一个元素的随机访问 const 迭代器。
- crend 返回指向以相反顺序查看的 deque 中的第一个元素的随机访问 const 迭代器。
- emplace 将就地构造的元素插入到指定位置的 deque 中。
- emplace_back 将就地构造的元素添加到 deque 的末尾。
- emplace_front 将就地构造的元素添加到 deque 的开头。
- empty 如果 deque 包含零个元素，则返回 true；如果它包含一个或多个元素，则返回 false。
- end 返回指向刚超出 deque 末尾位置的随机访问迭代器。
- erase 从指定位置删除 deque 中一个或一系列元素。
- front 返回对 deque 中第一个元素的引用。
- get_allocator 返回用于构造 allocator 的 deque 对象的副本。
- insert 将一个、多个或一系列元素插入到指定位置的 deque 中。
- max_size 返回 deque 的最大可取长度。
- pop_back 清除 deque 末尾处的元素。
- pop_front 清除 deque 开头处的元素。
- push_back 将元素添加到 deque 的末尾。
- push_front 将元素添加到 deque 的开头。
- rbegin 返回指向反向 deque 中的第一个元素的随机访问迭代器。
- rend 返回指向刚超出反向 deque 中的最后一个元素位置的随机访问迭代器。
- resize 为 deque 指定新的大小。
- shrink_to_fit 放弃额外容量。
- size 返回 deque 中的元素数量。
- swap 交换两个 deque 的元素。

#include <iostream>
#include <deque>
void testDeque()
{
	std::deque<int> deq;
	//插入
	for (int i = 1; i <= 10; i++)
	{
		deq.push_back(i);
	}
	//迭代器访问
	std::cout << "迭代器访问：";
	std::deque<int>::iterator iter;
	for (iter = deq.begin(); iter != deq.end(); iter++)
	{
		std::cout << *iter << " ";
	}
	std::cout << std::endl;
	std::cout << "下标访问：" << std::endl;
	//下标访问
	for (auto v : deq)
	{
		std::cout << v << " ";
	}
	std::cout << std::endl;
	for (int i = 0; i < deq.size(); i++)
	{
		//std::cout << deq[i] << " ";
		std::cout << deq.at(i) << " ";
	}
	std::cout << std::endl;
	std::cout << "从头到尾访问：";
	//从头到尾访问
	while (!deq.empty())
	{
		std::cout << deq.front() << " ";
		deq.pop_front();
	}
	std::cout << std::endl;
	std::cout << "从尾到头访问：";
	//插入
	for (int i = 1; i <= 10; i++)
	{
		deq.push_back(i);
	}
	//从尾到头访问
	while (!deq.empty())
	{
		std::cout << deq.back() << " ";
		deq.pop_back();
	}
}

int main()
{
	testDeque();
	return 0;
}

优先队列(priority_queue)

优先队列里面有个less方法，如果不写默认从大到小排序，出队就会是从大到小的排序
less需要包含头文件#include <functional>，less方法从大到小
greater方法，从小到大
在操作自定义类型时，需要重载一下<符号，因为有less方法
优先队列的top返回的是常对象，重载运算符的时候记得带const修饰
因为less源码有重载()所以自定义排序方式需要重载()

#include <iostream>
#include <queue>
#include <vector>
#include <functional>
void testPriority_queue()
{
	//默认写法,从大到小，默认less方法
	std::priority_queue<int> num;
	num.push(1);
	num.push(3);
	num.push(2);
	//出队
	while (!num.empty())
	{
		std::cout << num.top() << " ";
		num.pop();
	}
	std::cout << std::endl;
	//完整传参写法，greater方法，从小到大
	std::priority_queue<int, std::vector<int>, std::greater<int>> pri;
	pri.push(1);
	pri.push(3);
	pri.push(2);
	while (!pri.empty())
	{
		std::cout << pri.top() << " ";
		pri.pop();
	}
}

class student
{
public:
	student(std::string name = " ", int age = 0) :name(name), age(age) {}
	//提供共有接口
	std::string getName()const { return name; }
	int getAge()const { return age; }
	//const对象去比较 重载 < 要const限定
	bool operator<(const student& xiaogua) const
	{
		return this->age < xiaogua.age;
	}
protected:
	std::string name;
	int age;
};
//重载一下括号运算符就可以自定义排序方式
class customSort
{
public:
	bool operator()(const student& xiaogua,const student& dagua) const
	{
		return xiaogua.getAge() > dagua.getAge();
	}
};
void priority_queueOperation()
{
	//默认less方法
	std::priority_queue<student> xiaogua;
	xiaogua.push(student("小瓜", 21));
	xiaogua.push(student("大瓜", 23));
	xiaogua.push(student("傻瓜", 22));
	while (!xiaogua.empty())
	{
		std::cout << xiaogua.top().getName() << " " << xiaogua.top().getAge() << std::endl;
		xiaogua.pop();
	}
	std::cout << std::endl;
	//自定义排序方法,显示调用
	std::priority_queue<student,std::vector<student>,customSort> dagua;
	dagua.push(student("小瓜", 21));
	dagua.push(student("大瓜", 23));
	dagua.push(student("傻瓜", 22));
	while (!dagua.empty())
	{
		std::cout << dagua.top().getName() << " " << dagua.top().getAge() << std::endl;
		dagua.pop();
	}
}
int main()
{
	//testPriority_queue();
	priority_queueOperation();
	return 0;
}

STL(list)

list：双向链表
包含头文件#include <list>
list库函数，具体查看官方手册 list官方手册
- assign 将元素从列表中擦除并将一组新的元素复制到目标列表。
- back 返回对列表中最后一个元素的引用。
- begin 返回发现列表中第一个元素的位置的迭代器。
- cbegin 返回发现列表中第一个元素的位置的常量迭代器。
- cend 返回发现一个列表中最后一个元素之后的位置的敞亮表达式。
- clear 消除列表中的全部元素。
- crbegin 返回发现反向列表中第一个元素的位置的常量迭代器。
- crend 返回用于发现反向列表中最后一个元素之后的位置的常量迭代器。
- emplace 将构造的元素插入到列表中的指定位置。
- emplace_back 在列表的结尾处添加一个就地构造的元素。
- emplace_front 在列表的起始位置添加一个就地构造的元素。
- empty 测试列表是否为空。
- end 返回用于发现列表中最后一个元素之后的位置的迭代器。
- erase 从列表中的指定位置移除一个或一系列元素。
- front 返回对列表中第一个元素的引用。
- get_allocator 返回用于构造列表的 allocator 对象的一个副本。
- insert 将一个、几个或一系列元素插入列表中的指定位置。
- max_size 返回列表的最大长度。
- merge 将元素从参数列表移除，将它们插入目标列表，将新的组合元素集以升序或其他指定顺序排序。
- pop_back 删除列表末尾的元素。
- pop_front 删除列表起始处的一个元素。
- push_back 在列表的末尾添加元素。
- push_front 在列表的开头添加元素。
- rbegin 返回发现反向列表中第一个元素的位置的迭代器。
- remove 清除列表中与指定值匹配的元素。
- remove_if 将满足指定谓词的元素从列表中消除。
- rend 返回发现反向列表中最后一个元素之后的位置的迭代器。
- resize 为列表指定新的大小。
- reverse 反转列表中元素的顺序。
- size 返回列表中元素的数目。
- sort 按升序或其他顺序关系排列列表中的元素。
- splice 将元素从自变量列表中删除或将它们插入目标列表。
- swap 交换两个列表的元素。
- unique 从列表中删除满足某些其他二元谓词的相邻重复元素或相邻元素。

#include <list>
#include <iostream>
void testList() 
{
	std::list<int> num = { 1,2,3,4,5,6 };
	for (auto v : num)
	{
		std::cout << v << " ";
	}
	std::cout << std::endl;
	std::list<std::string> str;
	str.push_back("尾部");
	str.push_front("头部");
	std::cout << "Front:" << str.front() << std::endl;
	std::cout << "Back:" << str.back() << std::endl;
	for (std::list<std::string>::iterator iter = str.begin(); iter != str.end(); iter++) 
	{
		std::cout << *iter << "\t";
	}
	std::cout << std::endl;
	//采用删除的方式去遍历
	//while (!str.empty()) 
	//{
	//	std::cout << str.front() << "\t";
	//	str.pop_front();
	//}
	//std::cout << std::endl << "size:" << str.size() << std::endl;
	while (!str.empty()) 
	{
		std::cout << str.back() << "\t";
		str.pop_back();
	}
	std::cout << std::endl << "size:" << str.size() << std::endl;
}
void ListOpration() 
{
	std::list<int> num = { 4,5,6,1,2,3 };
	for (auto v : num)
	{
		std::cout << v << " ";
	}
	std::cout << std::endl << "---------反转链表-----------" << std::endl;
	//反转链表
	num.reverse();
	for (auto v : num)
	{
		std::cout << v << " ";
	}
	std::cout << std::endl << "---------排序链表-----------" << std::endl;
	num.sort();
	//从小到大
	num.sort(std::less<int>());
	for (auto v : num)
	{
		std::cout << v << " ";
	}
	//从大到小
	num.sort(std::greater<int>());
	for (auto v : num)
	{
		std::cout << v << " ";
	}
	//指定位置插入
	std::cout << std::endl << "---------指定位置插入-----------" << std::endl;
	num.insert(find(num.begin(), num.end(), 3), 10);
	for (auto v : num)
	{
		std::cout << v << " ";
	}
	std::cout << std::endl << "---------指定删除-----------" << std::endl;
	num.erase(find(num.begin(), num.end(), 10));
	for (auto v : num)
	{
		std::cout << v << " ";
	}
}
int main() 
{
	testList();
	ListOpration();
	return 0;
}