本人博客主页

本篇博客相关博客

二叉树--讲解

---

前言

在我们学习二叉树时接触过大小堆；

大堆：在一颗完全二叉树中，大数在堆顶，小数在下方；

小堆：乃相反，在完全二叉树中，最小的数在堆顶，大数在下方；

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、priority_queue是什么？

1. 优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。

2. 此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶部的元 素)。

3. 优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特 定的成员函数来访问其元素。元素从特定容器的“尾部”弹出，其称为优先队列的顶部。

4. 底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过随机访问迭 代器访问，并支持以下操作：

empty()：检测容器是否为空

size()：返回容器中有效元素个数

front()：返回容器中第一个元素的引用

push_back()：在容器尾部插入元素

pop_back()：删除容器尾部元素

二、priority_queue的使用

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

1、相关函数

2、代码使用

代码如下（示例）：

void test_priority_queue()
{
	//priority_queue<int, vector<int>, greater<int>> pq;
	priority_queue<int> pq;//定义一个堆；默认为大堆
	//priority_queue<int, deque<int>> pq;
//向堆里压入数据
	pq.push(1);
	pq.push(0);
	pq.push(5);
	pq.push(2);
	pq.push(1);
	pq.push(7);
//通过push函数将数据大的数据就放到堆顶了
	while (!pq.empty())//堆不是空就进行循环
	{
		cout << pq.top() << " ";//打印堆顶数据
		pq.pop();//弹出堆顶数据
	}
	cout << endl;
}

 我们默认建立的是大堆，所以在压入数据时，在vector末尾压入数据，然后通过向上调整，比较大的数就到堆顶了。

弹出数据时，我们将堆顶的数据和末尾的数据进行交换，然后将末尾数据删除，再将堆顶的数据向下调整。

在模拟实践时会细讲。

3、堆的插入删除

先插入一个10到数组的尾上，再进行向上调整算法，直到满足堆。

删除堆是删除堆顶的数据，将堆顶的数据根最后一个数据一换，然后删除数组最后一个数据，再进行向下调 整算法。 

三、模拟实现

1、大框架

代码如下（示例）：

template<class T, class Container = vector<T>, class Comapre = less<T>>
class priority_queue
{
public:	
    void push(const T& x)
	{
		_con.push_back(x);
		adjust_up(_con.size() - 1);
	}

	void pop()
	{
		swap(_con[0], _con[_con.size() - 1]);
		_con.pop_back();
		adjust_down(0);
	}

	const T& top()
	{
		return _con[0];
	}

	size_t size()
	{
		return _con.size();
	}

	bool empty()
	{
		return _con.empty();
	}
private:
	Container _con;
};

2、仿函数

我们在向上调整和向下调整时，我们可以用同一份代码，只有父亲节点和孩子节点的大小关系的区别，这时我们就用了仿函数，当我们想要建大堆时，我们不需要向上下调整函数传递任何参数，这时候我们默认就用的less函数里的对括号的重载，即x<y的大小关系。

当我们想要建小堆时，我们传一个函数参数，然comapre这个类具有greater这个类型的性质，这时候com对象遇到括号和括号结合就调用x>y这个函数了 。

仿函数和c语言中的函数调用非常像，区别在于传递的参数，c语言传递的是函数参数，这里我们传递的是模板参数。

代码

template<class T>
struct less
{
	bool operator()(const T& x, const T& y)
	{
		return x < y;
	}
};

template<class T>
struct greater
{
	bool operator()(const T& x, const T& y)
	{
		return x > y;
	}
};

3、向下调整 

我们建立大堆和小堆时，孩子节点和父亲节点的大小关系有所差异。所以我们这里借助了仿函数。

void adjust_down(int parent)
{
	size_t child = parent * 2 + 1;
	while (child < _con.size())
	{
		Comapre com;

		//if (child + 1 < _con.size() 
		//	&& _con[child] < _con[child + 1])
		if (child + 1 < _con.size()
			&& com(_con[child], _con[child + 1]))//我们这里调用了com这个对象了的对括号的重载
		{
			++child;
		}

		//if (_con[parent] < _con[child])
		if (com(_con[parent], _con[child]))
		{
			swap(_con[child], _con[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

4、向下调整

	void adjust_up(int child)
	{
		Comapre com;

		int parent = (child - 1) / 2;
		while (child > 0)
		{
			//if (_con[parent] < _con[child])
			if (com(_con[parent], _con[child]))
				//if (Comapre()(_con[parent], _con[child]))
			{
				swap(_con[child], _con[parent]);
				child = parent;
				parent = (child - 1) / 2;
			}
			else
			{
				break;
			}
		}
	}

 

---

总结

会用priority_queue的各个函数和理解堆

掌握仿函数的调用和函数的重载