C++容器适配器标准库笔记

C++容器适配器标准库

stack堆栈，queue队列，priority_queue优先队列:

stack堆栈

初始化：

函数	功能
stack<数据类型，容器类型> 标识符	后者为底层实现的容器类型，默认为deque

e.g:stack<int,vector<int>> s  构造一个存放int类型的空栈

加入元素：

函数	功能
s.push(a)	将元素a加入栈区，没有返回值
s.emplace(a)	将元素a加入栈区，a可以为类类型，传入构造函数的参数，将对象加入栈区

删除元素:

函数	功能
s.pop()	将栈顶元素删除，没有返回值

元素个数：

函数	功能
s.size()	返回栈区元素的数量
s.empty()	若堆栈为空则返回真

访问元素：

函数	功能
s.top()	返回栈顶元素

#include<iostream>
#include<stack>
#include<deque>
using namespace std;
class test {
private:
	int a;
	int b;
public:
	test(int a_=0, int b_=0) { a = a_; b = b_; }
	void show() { cout << a << "," << b << " "; }
};
int main()
{
	deque<test> d(5, 0);
	stack<test> s(d);//用双向队列d构造堆栈
	for (; !s.empty(); s.pop())
	{
		s.top().show();	//输出一个元素弹出一个元素
	}
	cout << endl;
	int a[5] = { 1,2,3,4,5 };
	int b[5] = { 11,22,33,44,55 };
	for (int i = 0; i < 5; i++)
	{
		s.emplace(a[i],b[i]);	//添加元素
	}
	cout << "堆栈元素数量：" << s.size() << endl;	//判断元素数量
}

参考:https://www.cnblogs.com/magisk/p/9193351.html

queue队列：

初始化：

函数	功能
queue<数据类型，容器类型> 标识符	后者为底层实现的容器类型，默认为deque

e.g:queue<int,vector<int>> s  构造一个存放int类型的队列

加入元素：

函数	功能
q.push(a)	队尾加入元素a
q.emplace(a)	队尾加入元素a，可传入类类型，与stack类似；

删除元素:

函数	功能
q.pop()	删除队首第一个元素

元素个数：

函数	功能
q.size()	返回队列元素个数
q.empty()	判断队列是否为空

访问元素：

函数	功能
q.front()	返回第一个元素（从队首开始）
q.back()	返回最后一个元素

#include<iostream>
#include<queue>
using namespace std;
int main()
{
	queue<int> q;
	for (int i = 0; i < 5; i++)
		q.push(i);	//加入元素也可q.emplace(i)
	cout << "队头元素:" << q.front() << endl;
	cout << "队尾元素:" << q.back() << endl;
	q.pop();
	cout << "现队头元素:" << q.front() << endl;
	cout << "队列现有元素:" << q.size() << endl;
}

参考:https://www.cnblogs.com/magisk/p/9193351.html

priority_queue优先队列：

初始化:

函数	功能
priority_queue<Type,Container = vector,pr> 标识符	底层容器类型默认为vector，pr为比较的方式，默认降序

如果自定义类型需重载<运算符或重写函数

加入元素:

函数	功能
pq.push(a)	往队尾加入元素a，会经过排序
pq.emplace(a)	加入元素a，可传入类类型，与stack类似

删除元素:

函数	功能
pq.pop()	删除队首第一个元素

元素个数：

函数	功能
pq.size()	返回队列元素的个数
pq.empty()	判断队列是否为空

访问元素：

函数	功能
pq.top()	返回队首第一个元素

#include<iostream>
#include<queue>
using namespace std;
class test {
private:
	int a, b;
public:
	test(int a_, int b_) { a = a_; b = b_; }
	friend bool operator >(const test& t1, const test& t2);
	void show() const { cout << a << "-" << b; }	
	//一定要常函数，pq.top()为一个常函数，一个常函数里面不可以调用非常函数
};

bool operator>(const test& t1, const test& t2)
{
	return t1.a > t2.a;
}

int main()
{
	priority_queue<test,vector<test>,greater<test>> pq; //默认或less自定义类型重载<,greater重载>
	//现在是升序排列
	int a[5] = { 1,2,3,4,5 };
	int b[5] = { 11,22,33,44,55 };
	for (int i = 0; i < 5; i++)
		pq.emplace(a[i], b[i]);//加入元素
	cout << "现有元素的数量" << pq.size() << endl;
	for (; !pq.empty(); pq.pop())
	{
		pq.top().show();		//显示元素
		cout << " ";
	}
}

参考：https://www.cnblogs.com/shona/p/12163381.html