STL容器——stack、queue、priority_queue

stack是堆栈容器，是一种“先进后出”的容器。

stack是简单地装饰deque容器而成为另外的一种容器。

stack.push(elem);   //往栈头添加元素

stack.pop();   //从栈头移除第一个元素

stack(const stack &stk);           //拷贝构造函数
stack& operator=(const stack &stk);     //重载等号操作符

stack.top();   //返回最后一个压入栈元素,返回值是引用，可做左值使用

stack.empty();   //判断堆栈是否为空

stack.size();         //返回堆栈的大小

queue是队列容器，是一种“先进先出”的容器。

queue是简单地装饰deque容器而成为另外的一种容器。

queue.push(elem);   //往队尾添加元素

queue.pop();   //从队头移除第一个元素

queue.back();   //返回队尾元素

queue.front();   //返回队头元素

queue(const queue &que);          //拷贝构造函数
queue& operator=(const queue &que);   //重载等号操作符

queue.empty();   //判断队列是否为空

queue.size();       //返回队列的大小

详细事例，以及用两个栈模拟队列

#include <iostream>
#include <stack>
#include <queue>
using namespace std;

//栈
void func1()
{
	stack<int> s;
	s.push(8);
	s.push(4);
	s.push(2);
	s.push(19);

	cout << "栈的元素个数：" << s.size() << endl;
	cout << "栈顶元素    ：" << s.top()  << endl;

	while (!s.empty())
	{
		cout << s.top() << endl;
		s.pop();//删除栈顶元素
	}
	cout << s.size() << endl;
}

//队列
void func2()
{
	queue<int> q;
	q.push(8);
	q.push(4);
	q.push(2);
	q.push(19);
	
	cout << "队列的元素个数：" << q.size() << endl;
	cout << "队头元素    ：" << q.front()  << endl;
	cout << "队尾元素    ：" << q.back()  << endl;
	while(!q.empty())
	{
		cout << q.front() << endl;
		q.pop();
	}
	cout << q.size() << endl;
}

//用两个栈来模拟队列
class MyQueue
{
public:
	//入队
	void push(int num)
	{
		s1.push(num);//入队操作放在栈s1中进行
	}


	//出队
	void pop()
	{
		if (s2.empty())//如果栈s2为空
		{
			while (s1.size() > 1)//将s1中的数据放入s2中，只剩余第一个入队的元素（方便有其他数据进队，不影响之前元素的出队）
			{
				s2.push(s1.top());//s2存储不用出队的元素
				s1.pop();//删除不用出队的元素，s1中只留出队的元素
			}


			if (!s1.empty())//正式出队
				s1.pop();//元素出队
		}
		else//s2不为空，经过一次出栈（s1中的数据出栈后，放入s2）后，s2的出栈顺序与队列的出队顺序相符
			s2.pop();//s2的出栈，和正常队列的出队效果一致
	}


	bool empty()//判断队是否空
	{
		if (s1.empty() && s2.empty())
			return true;
		else
			return false;
	}


	int front()//取队头元素
	{
		if (s2.empty())//如果s2为空，将s1中的数据都放入s2中
		{
			while (!s1.empty())
			{
				s2.push(s1.top());
				s1.pop();
			}
		}


		return s2.top();//s2不空，返回s2的栈顶元素（也就是队头元素）
	}

private:
	stack<int> s1;
	stack<int> s2;
};

void func3()
{
	MyQueue q;
	q.push(8);
	q.push(4);
	q.push(2);
	q.push(19);

	while (!q.empty())
	{
		cout << q.front() << endl;
		q.pop();
	}
}

int main()
{
	//func1();
	func2();
	return 0;
}

priority_queue优先级队列

内部数据默认是从大到小排序

 priority_queue<int> p1; //默认是 最大值优先级队列 

    //priority_queue<int, vector<int>, less<int> > p1; //相当于这样写

    priority_queue<int, vector<int>, greater<int>> p2; //改为最小值优先级队列
 
    p1.push(33);
    p1.push(11);
    p1.push(55);
    p1.push(22);
    cout <<"队列大小" << p1.size() << endl;
    cout <<"队头" << p1.top() << endl;
 
    while (p1.size() > 0)
    {
         cout << p1.top() << " ";
         p1.pop();
    }
    cout << endl;
 
    cout << "测试 最小值优先级队列" << endl;
    p2.push(33);
    p2.push(11);
    p2.push(55);
    p2.push(22);
    while (p2.size() > 0)
    {
         cout << p2.top() << " ";
         p2.pop();
 
    }