【C++】-- STL容器适配器之priority_queue

目录

一、什么是priority_queue

二、priority_queue的使用

1.priority_queue的构造

2.push( )

3.pop( )

4.size( )

5.empty( ) 

 三、priority_queue模拟实现

1.仿函数

(1)概念 

(2)优点

(3)缺点

(4)实现

2.堆的插入删除

3.代码实现

 (1)仿函数<

(2)仿函数>

(3)push()

(4)pop()

(5)top()

(6)size()

(7)empty()

4.完整代码段


一、什么是priority_queue

(1)priority_queue即优先级队列,是一种容器适配器,最大元素放在第一个。

(2)底层用堆实现,默认是大堆,因为默认大的优先级高,可随时插入元素,可快速查找最大元素,即优先级队列中第一个元素。

(3)优先级队列元素从特定容器的“尾部”弹出,其称为优先队列的顶部。

(4)底层容器可以是任何标准容器类模板,也可以是其他特定设计的容器类。容器应该可以通过随机访问迭代器访问,并支持以下操作:
        empty( ):检测容器是否为空
        size( ):返回容器中有效元素个数
        front( ):返回容器中第一个元素的引用
        push_back( ):在容器尾部插入元素
        pop_back( ):删除容器尾部元素

(5)标准容器类vector和deque满足这些需求。默认情况下,如果没有为特定的priority_queue类实例化指定容器类,则使用vector,堆的物理结构是数组,所以优先级队列也是一个vector。

(6) 需要支持随机访问迭代器,以便始终在内部保持堆结构。容器适配器通过在需要时自动调用算法函数make_heap、push_heap和pop_heap来自动完成此操作。

二、priority_queue的使用

优先级队列默认使用vector作为其底层存储数据的容器,在vector上又使用了堆算法将vector中元素构造成堆的结构,因此priority_queue就是堆,所有需要用到堆的位置,都可以考虑使用priority_queue。

1.priority_queue的构造

priority_queue有两种构造方式:

(1)构造一个空的优先级队列

explicit priority_queue (const Compare& comp = Compare(),
                         const Container& ctnr = Container());//构造一个控的优先级队列

构造一个空的优先级队列pq1: 

#include
#include//队列
#include//数组
#include//比较符号,less 或 greater

using namespace std;

int main()
{
	priority_queue pq1;//构造一个空的优先级队列
    
    pq1.push(3);//向优先级队列中插入元素
	pq1.push(1);
	pq1.push(6);
	pq1.push(12);
	pq1.push(7);

    while (!pq1.empty())
	{
		cout << pq1.top() << endl;
		pq1.pop();
	}
}

【C++】-- STL容器适配器之priority_queue_第1张图片

(2)用迭代器区间构造一个优先级队列

template 
         priority_queue (InputIterator first, InputIterator last,
                         const Compare& comp = Compare(),
                         const Container& ctnr = Container());//用first和last之间的元素构造优先级队列

使用数组的迭代器区间构造一个优先级队列:

    vector v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);

	priority_queue pq2(v.begin(), v.end()) ;//用v的迭代器区间构造pq2

以上都构造的是大堆,如何构造一个小堆呢?

可以使用如下模板构造:T是元素类型,Container 指定容器,Compare是元素比较方式,大于还是小于,默认为大于less,即大堆,如果想改成小堆,就用greater。

template ,
  class Compare = less > class priority_queue;

 value_type被typedef为T,编译器编译的时候是没有vecto的,因为vector没有被实例化,所以编译器编译的时候不知道Container是vector,不知道value_type类型。

构造一个小堆: 

    priority_queue,greater::value_type>> pq4;
	pq4.push(20);
	pq4.push(2);
	pq4.push(8);
	pq4.push(5);

	while (!pq4.empty())
	{
		cout << pq4.top() << endl;
		pq4.pop();
	}

【C++】-- STL容器适配器之priority_queue_第2张图片  

2.push( )

向优先级队列中插入元素 

void push (const value_type& val);//向优先级队列中插入元素

 向pq3中插入元素:

    priority_queue pq3;
	pq3.push(6);//向优先级队列中插入元素
	pq3.push(3);
	pq3.push(9);
	pq3.push(8);

3.pop( )

删除优先级队列第一个元素 

void pop();//删除优先级队列第一个元素

 删除pq3的第一个元素:

    pq3.pop();//删除优先级队列第一个元素

4.size( )

 返回优先级队列的元素个数

size_type size() const;//返回优先级队列的元素个数

 返回pq3的元素个数

    cout << pq3.size() << endl;//返回pq3的元素个数

【C++】-- STL容器适配器之priority_queue_第3张图片

5.empty( ) 

判断优先级队列是否为空

bool empty() const;//判断优先级队列是否为空

 判断pq3是否为空

    cout << pq3.empty() << endl;

【C++】-- STL容器适配器之priority_queue_第4张图片

 三、priority_queue模拟实现

priority_queue底层用堆实现,priority_queue的模拟实现只需要对堆进行封装即可。

1.仿函数

priority_queue默认是大堆,那么该如何实现小堆呢?需要先了解仿函数。

(1)概念 

仿函数让一个类的使用看上去像个函数。仿函数是在类中实现了一个operator( ),是一个类的对象,这个类就有了类似函数的行为,所以这个类就是一个仿函数类,目的是为了让函数拥有类的性质。

这个类的对象即仿函数,可以当作一般函数去用,只不过仿函数的功能是在一个类中的运算符operator()中实现的,使用的时候把函数作为参进行传递即可。

(2)优点

 ① 仿函数比函数指针的执行速度快,函数指针通过地址调用,而仿函数是对运算符operator进行自定义来提高调用的效率。
 ② 仿函数比一般函数灵活,可以同时拥有两个不同的状态实体,一般函数不具备此种功能。
 ③ 仿函数可以作为模板参数使用,因为每个仿函数都拥有自己的类型。

(3)缺点

 ① 需要单独实现一个类。
 ② 定义形式比较复杂。

(4)实现

 先看如下函数isLess,它实现了<的比较

#include

bool isLess(int l, int r)
{
	return l < r;
}

int main()
{
	cout << isLess(1, 3) << endl;
}

如果在一个类里,实现同样功能,Less这个类就变成了仿函数类,它的对象就是一个仿函数

struct less
{
	bool operator()(int l, int r)
	{
		return l < r;
	}
};

 这个类还可以再完善一下,使用类模板来支持不同类型的数据使用<比较大小

template 
struct less
{
	bool operator()(const T& l, const T& r)
	{
		return l < r;//<的比较
	}
};

同样,>的仿函数类也可以实现了:

template 
struct greater
{
	bool operator()(const T& l, const T& r)
	{
		return l > r;//>的比较
	}
};

如何使用仿函数呢?

int main()
{
	less lessInt;//定义一个仿函数类对象,参数类型指定为int
	std::cout << lessInt(1, 3) << std::endl;//对仿函数的调用等价于std::cout << lessInt.operator()(1, 3) << std::endl;
}

priority_queue模板中的less替换成greater就可以实现>的比较了:

template ,
  class Compare = greater > class priority_queue;

2.堆的插入删除

要对priority_queue插入删除,就是在堆上插入删除,堆在物理上是数组,在逻辑上是一颗完全二叉树。根据【数据结构】堆-C语言版一文回忆一下堆的插入删除相关知识

(1)堆的插入(先插入,再向上调整)

【C++】-- STL容器适配器之priority_queue_第5张图片

 (2)堆的删除(先交换,然后删除,再向下调整)

【C++】-- STL容器适配器之priority_queue_第6张图片

3.代码实现

priority_queue类默认的Container是vector,是自定义类型。因此priority_queue的构造函数、拷贝构造函数、赋值运算符重载函数、析构函数都不用写,会调vector的默认构造函数、拷贝构造函数、赋值运算符重载函数、析构函数。只需要实现7个函数:仿函数<、仿函数>、push、pop、top、size、empty。

 (1)仿函数<

template
struct less
{
	bool operator()(const T& l, const T& r)
	{
		return l < r;
	}
};

(2)仿函数>

	template
	struct greater
	{
		bool operator()(const T& l, const T& r)
		{
			return l > r;
		}
	};

(3)push()

	template,class Compare = delia::less>//指定Compare方式是less,按<比较
	class priority_queue
	{
	public:		
		//向上调整算法
		void AdjustUp(size_t child)
		{
			Compare com;//定义仿函数类对象

			size_t parent = (child - 1) / 2;//找父亲的位置
			while (child > 0)
			{
				//if (_con[parent] < _con[child])//父亲比孩子小,孩子就要往上提
				if (com(_con[parent] , _con[child]))//使用仿函数比较
				{
					swap(_con[parent], _con[child]);//交换父亲和孩子
					child = parent;//父亲变孩子
					parent = (child - 1) / 2;//重新计算新孩子的父亲位置
				}
				else
				{
					//父亲>=孩子就不用动
					break;
				}	
			}
		}

		//插入
		void push(const T& x)
		{
			_con.push_back(x);//尾插到堆
			AdjustUp(_con.size() - 1);//向上调整
		}
    
    private:
		Container _con;
	};

(4)pop()

		//向下调整算法
		void AdjustDown(size_t parent)
		{
			Compare com;//定义仿函数类对象

			size_t child = 2 * parent + 1;//找孩子位置
			while (child < _con.size())
			{
				//找大孩子
				if (child + 1 < _con.size() && _con[child+1] > _con[child])
				{
					child++;
				}

				//if(_con[parent] < _con[child])父亲比孩子小,父亲就要往下挪
				if (com(_con[parent], _con[child]))//使用仿函数比较
				{
					swap(_con[parent], _con[child]);//交换父亲和孩子
					parent = child;//孩子变父亲
					child = parent * 2 + 1;//重新计算孩子的位置
				}
				else
				{
					break;
				}
			}
		}

        //删除
		void pop()
		{
			swap(_con[0], _con[_con.size() - 1]);//交换堆顶元素和堆尾元素
			_con.pop_back();//删除堆顶元素			
			AdjustDown(0);//向下调整算法
		}

(5)top()

		//返回priority_queue第一个元素,即堆顶元素
		T top()
		{
			return _con[0];
		}

(6)size()

		//求priority_queue队列中元素个数
		size_t size()
		{
			return _con.size();
		}

(7)empty()

		//判断priority_queue是否为空
		bool empty()
		{
			return _con.empty();
		}

4.完整代码段
 

018-priority_queue.h

#pragma once
#include
using namespace std;

namespace delia
{
	template
	struct less
	{
		bool operator()(const T& l, const T& r)
		{
			return l < r;
		}
	};

	template
	struct greater
	{
		bool operator()(const T& l, const T& r)
		{
			return l > r;
		}
	};

	template,class Compare = std::less>
	class priority_queue
	{
	public:
		//Container默认是vector,自定义类型
		//构造函数、拷贝构造函数、赋值运算符重载函数、析构函数都不用写,会调用vector的构造函数和析构函数等
		
		

		//向上调整算法
		void AdjustUp(size_t child)
		{
			Compare com;//定义仿函数类对象

			size_t parent = (child - 1) / 2;//找父亲的位置
			while (child > 0)
			{
				//if (_con[parent] < _con[child])//父亲比孩子小,孩子就要往上提
				if (com(_con[parent] , _con[child]))//使用仿函数比较
				{
					swap(_con[parent], _con[child]);//交换父亲和孩子
					child = parent;//父亲变孩子
					parent = (child - 1) / 2;//重新计算新孩子的父亲位置
				}
				else
				{
					//父亲>=孩子就不用动
					break;
				}	
			}
		}

		//插入
		void push(const T& x)
		{
			_con.push_back(x);//尾插到堆
			AdjustUp(_con.size() - 1);//向上调整
		}

		//向下调整算法
		void AdjustDown(size_t parent)
		{
			Compare com;//定义仿函数类对象

			size_t child = 2 * parent + 1;//找孩子位置
			while (child < _con.size())
			{
				//找大孩子
				if (child + 1 < _con.size() && _con[child+1] > _con[child])
				{
					child++;
				}

				//if(_con[parent] < _con[child])父亲比孩子小,父亲就要往下挪
				if (com(_con[parent], _con[child]))//使用仿函数比较
				{
					swap(_con[parent], _con[child]);//交换父亲和孩子
					parent = child;//孩子变父亲
					child = parent * 2 + 1;//重新计算孩子的位置
				}
				else
				{
					break;
				}
			}
		}

		//删除
		void pop()
		{
			swap(_con[0], _con[_con.size() - 1]);//交换堆顶元素和堆尾元素
			_con.pop_back();//删除堆顶元素			
			AdjustDown(0);//向下调整算法
		}

		//返回priority_queue第一个元素,即堆顶元素
		T top()
		{
			return _con[0];
		}

		//求priority_queue队列中元素个数
		size_t size()
		{
			return _con.size();
		}

		//判断priority_queue是否为空
		bool empty()
		{
			return _con.empty();
		}

	private:
		Container _con;
	};

}

018-test.cpp

#include "018-priority_queue.h"
#include

void test_priority_queue()
{
	delia::priority_queue pq;
	pq.push(9);
	pq.push(26);
	pq.push(31);
	pq.push(3);
	pq.push(11);
	pq.push(1);
	pq.push(5);
	pq.push(39);
	pq.push(23);
	pq.push(18);

	std::cout << "priority_queue:" << std::endl;
	while (!pq.empty())
	{
		std::cout << pq.top() << std::endl;
		pq.pop();
	}
	std::cout << std::endl;
}

void test_priority_queue_push()
{
	delia::priority_queue pq;
	pq.push(9);
	pq.push(26);
	pq.push(31);
	pq.push(3);
	pq.push(11);
	pq.push(1);
	pq.push(5);
	pq.push(39);
	pq.push(23);
	pq.push(18);

	pq.push(83);

	std::cout << "push:" << std::endl;
	while (!pq.empty())
	{
		std::cout << pq.top() << std::endl;
		pq.pop();
	}
	std::cout << std::endl;
}

void test_priority_queue_pop()
{
	delia::priority_queue pq;
	pq.push(9);
	pq.push(26);
	pq.push(31);
	pq.push(3);
	pq.push(11);
	pq.push(1);
	pq.push(5);
	pq.push(39);
	pq.push(23);
	pq.push(18);

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

void test_priority_queue_top()
{
	delia::priority_queue pq;
	pq.push(9);
	pq.push(26);
	pq.push(31);
	pq.push(3);
	pq.push(11);
	pq.push(1);
	pq.push(5);
	pq.push(39);
	pq.push(23);
	pq.push(18);

	std::cout << "top:" << std::endl;
	std::cout << pq.top() << std::endl;
	std::cout << std::endl;
}

void test_priority_queue_size()
{
	delia::priority_queue pq;
	pq.push(9);
	pq.push(26);
	pq.push(31);
	pq.push(3);
	pq.push(11);
	pq.push(1);
	pq.push(5);
	pq.push(39);
	pq.push(23);
	pq.push(18);

	std::cout << "size:" << std::endl;
	std::cout << pq.size() << std::endl;
	std::cout << std::endl;
}

void test_priority_queue_empty()
{
	delia::priority_queue pq;
	pq.push(9);
	pq.push(26);
	pq.push(31);
	pq.push(3);
	pq.push(11);
	pq.push(1);
	pq.push(5);
	pq.push(39);
	pq.push(23);
	pq.push(18);

	std::cout << "empty:" << std::endl;
	std::cout << pq.empty() << std::endl;
	std::cout << std::endl;
}

int main()
{
	test_priority_queue();
	test_priority_queue_push();
	test_priority_queue_pop();
	test_priority_queue_top();
	test_priority_queue_size();
	test_priority_queue_empty();

	return 0;

}

运行结果如下 

【C++】-- STL容器适配器之priority_queue_第7张图片

【C++】-- STL容器适配器之priority_queue_第8张图片

你可能感兴趣的:(C++,c++,开发语言)