c++ priority_queue

平常使用queue，今天遇到一个priority_queue，记录一下啊

 

queue：

　　是一种先进先出的数据结构，元素在队列尾追加，而从队列头删除。

priority_queue：

        元素按照优先级排序了，当访问元素时，具有最高优先级的元素最先pop。优先队列具有最高级先出 （first in, largest out）的行为特征。

        优先队列具有queue的所有特性，包括队列的基本操作，只是在这基础上添加了内部的一个排序，它本质是一个堆实现的。

         参考：c++二叉堆

 

先看看简单的例子：

class QueData
{
public:
	QueData(int data, string name) :m_data(data), m_strName{ name } {
		;
	}
	virtual ~QueData() { ; }

public:
	bool operator < (const QueData &data) const  //注意此处重载函数后面的const，曾经遇到过const没加上，报错问题
	{
		return m_data < data.m_data;
	}

	string name() { return m_strName; }
	int data() { return m_data; }

private:
	int m_data = 0;
	string m_strName{ "" };
};




#include <queue>
#include <functional>  //std::greater
void testPriorityQue()
{
	std::cout << "From large to small, default: less" << std::endl;
	std::priority_queue<int> priorityQueInt;
	//等同于： 
	//priority_queue<int, std::vector<int>, std::less<int> > priorityQueInt;
	priorityQueInt.push(8);
	priorityQueInt.push(6);
	priorityQueInt.push(7);
	priorityQueInt.push(9);
	priorityQueInt.push(10);

	//默认由大到小
	while(!priorityQueInt.empty())
	{
		std::cout << priorityQueInt.top() << std::endl;
		priorityQueInt.pop();
	}
///////////////////////////


	std::cout << "From small to large, use: greater" << std::endl;
	//更改到-->小到大：
	std::priority_queue<int, std::vector<int>, std::greater<int> > priorityGreaterQueInt;
	priorityGreaterQueInt.push(8);
	priorityGreaterQueInt.push(6);
	priorityGreaterQueInt.push(7);
	priorityGreaterQueInt.push(9);
	priorityGreaterQueInt.push(10);

	while (!priorityGreaterQueInt.empty())
	{
		std::cout << priorityGreaterQueInt.top() << std::endl;
		priorityGreaterQueInt.pop();
	}
///////////////////////

	std::cout << "For customize type defined, use override operator <" << std::endl;
	std::priority_queue<QueData> que;
	QueData data8{ 8,"8" };
	que.push(data8);
	QueData data6{ 6,"6" };
	que.push(data6);
	QueData data7{ 7,"7" };
	que.push(data7);
	QueData data9{ 9,"9" };
	que.push(data9);
	QueData data10{ 10,"10" };
	que.push(data10);

	//大小顺序由QueData的operator <决定
	while (!que.empty())
	{
		QueData queData = que.top();
		std::cout << queData.data() << std::endl;
		que.pop();
	}

}



int main()
{
    testPriorityQue();

    return 0;
}

输出：

From large to small, default: less
10
9
8
7
6
From small to large, use: greater
6
7
8
9
10
For customize type defined, use override operator <
10
9
8
7
6
Press any key to continue . . .

　　

定义：http://www.cplusplus.com/reference/queue/priority_queue/?kw=priority_queue

　　priority_queue<Type, Container, Functional>

　　Type ：         数据类型， 基本类型或者自定义类

　　Container ： 容器类型（Container必须是用数组实现的容器，比如vector,deque等等，但不能用 list。STL里面默认用的是vector）

       Functional ：比较的方式， 自定义类型 通过override  operator <实现，

　　　　　　　　　　　　　　 基本类型，stl functional提供了greater和less来比较大小，

　　　　　　　　　　　　　　　　　　　　　 greater和less是std实现的两个仿函数， 其实现就是类中实现一个operator()，具体可以查看functional

 

当需要用自定义的数据类型时才需要传入这三个参数，使用基本数据类型时，不填，默认是less，从大到小

1 //默认：大->小，大顶堆

std::priority_queue<int> priorityQueInt;

priority_queue<int, std::vector<int>, std::less<int> > priorityQueInt;

2 //小->大，小顶堆 
 std::priority_queue<int, std::vector<int>, std::greater<int> > priorityGreaterQueInt;