【C++STL详解(十)】--------priority

前言

一、堆的向上调整算法

二、堆的向下调整算法

三、优先队列模拟实现

Ⅰ、接口总览

Ⅱ、各个接口实现

1.构造函数

2.仿函数

3.向上调整

4.向下调整

5.其余接口

Ⅲ、完成代码

前言

上节内容我们简单的介绍了关于priority_queue的使用内容，我们明白了它的默认容器是vector，以及优先队列实际上默认就是个大堆等相关知识，那么接下来就来看看底层的模拟实现究竟是什么样的！但在此之前先简单介绍两个堆算法，向上调整和向下调整算法！

一、堆的向上调整算法

我们在数据结构中都知道堆在物理空间上是采用数组去存储的，但是呢在逻辑上我们可以将其看作一棵完全二叉树，形如：

以上这个是大堆，小堆反之，下面以大堆为例介绍向上调整算法！

向上调整：

①在大堆的末尾插入一个数据，然后和其父亲结点去比较！

②如果大于父亲结点，那就和父亲结点交换位置，并更新父亲结点，直到比父亲结点小；如果比父亲结点小，那就停止交换！此时就是大堆了！

小堆过程相反！！把小的向上调即可

注意：在数据结构的树与二叉树中提到过父亲结点和孩子结点的下标关系

左孩子=父亲*2+1；

右孩子=父亲*2+2；

例如，在上述堆中插入一个数据77。过程如下：

和其父亲结点比较发现，比父亲结点大，那就交换！

在去新的父节点比较，即和66相比，比它大，交换！

到这里就调整完毕了，此时就是个大堆了！

具体代码如下：

//建大堆
void AdjustUp(vector<int>& v1 int child)
{int parent = (child - 1) / 2;//通过父子下标关系得出while (child > 0){if (v[child] > v[parent]){swap(v[child], v[parent]);//交换child = parent;//更新孩子parent = (child - 1) / 2;//更新父亲}//至此已成堆else{break;}}
}

二、堆的向下调整算法

同样还是以大堆为例，进行向下调整，但是这里有个前提：一定要保证左右子树是一个大堆，才可以进行向下调整！建小堆，也是要保证左右子树都是小堆才可以！

向下调整：

①从堆顶向下，先选出当前父节点的左右孩子中的最大节点，然后再用当前节点去和最大节点的比较！

②如果父节点小于最大孩子节点，那就交换父子节点，并重新更新父子节点；如果大于最大节点，那就不能交换，此时就是大堆了！

小堆就是相反的，实际就是把大的向下调！大堆就是把小的向下调！！

例如，上图先找出左右孩子中的最大节点，即77作为最大孩子。22与77相比，22比77小，那就交换！

再重复上述步骤，因为只有33这个节点，并且22小于33，即父亲小于孩子，那就交换！

至此已经来到了末尾，交换结束，此时的结构就是大堆！！！！

具体实现代码如下：

void Adjustdown(vector<int>& a, int size, int parent)
{int child = parent * 2 + 1;//左孩子while (child<size){//找左右孩子哪个大，把大给childif (child + 1 < size && a[child + 1] > a[child]){child = child + 1;}//比较孩子和父亲if (a[child] > a[parent]){swap(a[child], a[parent]);parent=child;//更新父亲child = parent * 2 + 1;//更新孩子}//至此已成大堆else{break;}}
}

总结一下：向上调整就是拿孩子去比父亲，所以参数得是孩子的；向下调整实际就是拿父亲去比孩子，所以参数得父亲的下标！！

注意：实际应用中，大多数都是采用向下调整建堆，因为时间复杂度为O(N),而向上调整时间复杂度为O(N*logN);

三、优先队列模拟实现

有上面两个算法的铺垫，接下来的模拟实现就简单很多了！

Ⅰ、接口总览

#include<vector>namespace Pq
{//仿函数，控制比较方式template <class T>class less{public:bool operator()(const T& x, const T& y);};template <class T>class greater{public:bool operator()(const T& x, const T& y);};template <class T, class Container = vector<T>, class Compare = less<T> >class priority_queue{public://构造空队列priority_queue();//迭代器区间构造队列template <class InputIterator>priority_queue(InputIterator first, InputIterator last);void push(const T& x);void pop();bool empty() const;size_t size() const;const T& top() const;private:Container c;Compare comp;//向上调整算法void AdjustUp(size_t child);//向下调整算法void Adjustdown(size_t parent);};};

注意：一样的，模拟实现，毕竟只是模拟，一定要记得在自己的空间里面去模拟哦！同时我们这里为了更真实的去模拟，我们将向上调整和向下调整设置为私有函数！！！因为平时去调用时，根本就看不见这两个函数，是吧哥们！

Ⅱ、各个接口实现

1.构造函数

构造空队列

//构造空队列
priority_queue():c()
{}

迭代器区间初始化

写法一：

//迭代器区间构造队列
template <class InputIterator>
priority_queue(InputIterator first, InputIterator last)
{while (first != last){c.push_back(*first);first++;}//插入数据应该要继续保持堆结构//这里是将一堆已经存在的数据进行建堆//向下调整建大堆时间复杂度更低for (int i = (c.size() - 1 - 1) / 2; i >= 0; i--){Adjustdown(i);}
}

这样的写法实际和vector、list等模拟实现相类似，都是通过尾插操作去实现的！但是要注意一点，优先队列就是个堆结构，插入数据时应该要调整它的结构，前面也说过向下调整时间复杂度低，所以这里采用向下调整算法建堆，但是一定要注意向下调整是有前提的，必须要求左右子树都是一个大堆(或者小堆)，因此我们应该从最后一个非叶子结点开始去调整，也就是最后一个父结点开始向下调整！！！！

写法二：

template <class InputIterator>
priority_queue(InputIterator first, InputIterator last):c(first,last)
{for (int i = (c.size() - 1 - 1) / 2; i >= 0; i--){Adjustdown(i);}
}

这个写法就是利用优先队列实际上是一个容器适配器，也就是说用别人的东西去创造自己，也就是它的成员变量实际上就是对应容器，相当与一个自定义类型，那么对于自定义类型，他就会去调用自己的构造函数完成初始化工作！

例如：当传进来的是vector容器时，优先队列里面的成员变量就是vector示例化出来的对象，对这个对象进行初始化工作，实际上就是在调用vector的默认成员函数完成构造！！！

2.仿函数

这里在前面的优先队列介绍中就有涉及，要注意一点仿函数可以控制比较逻辑，在优先队列的底层，大堆(less)实际上是用<比较，小堆(greater)实际上是用>比较！

//大堆,<比较
template <class T>
class less
{public:bool operator()(const T& x, const T& y){return x < y;}
};//小堆，>比较
template <class T>
class greater
{public:bool operator()(const T& x, const T& y){return x > y;}
};

3.向上调整

//向上调整算法(大堆为例)
void AdjustUp(size_t child)
{size_t parent = (child - 1) / 2;while (child > 0){//if (_con[parent] < _con[child])if (comp(c[parent], c[child])){swap(c[parent], c[child]);child = parent;parent = (child - 1) / 2;}else{break;}}
}

注意：整体逻辑和上面讲到的差不多，只不过这里的比较逻辑采用了仿函数，comp实际上是仿函数实例化出来的对象，在成员变量里面了！

4.向下调整

 //向下调整算法(默认大堆)void Adjustdown(size_t parent){size_t child = 2 * parent + 1;while (child < c.size()){if (child + 1 < c.size() && comp(c[child], c[child + 1]))//仿函数控制比较逻辑{child = child + 1;}//用仿函数                if (comp(c[parent], c[child])){swap(c[parent], c[child]);parent = child;child = 2 * parent + 1;}//至此已成大堆else{break;}}}

5.其余接口

void push(const T& x)
{c.push_back(x);AdjustUp(c.size() - 1);//最后一个元素向上调整
}void pop()
{swap(c[0], c[c.size() - 1]);c.pop_back();//在使用向下调整堆结构Adjustdown(0);
}bool empty() const
{return c.empty();
}size_t size() const
{return c.size();
}const T& top() const
{return c[0];
}

需要注意的是堆的删除操作(pop),它实际上就是先把堆顶元素与最后一个元素交换，然后在把最后一个元素不看做堆的元素，也就是删除，最后在采用向下调整堆结构！！

例如：

Ⅲ、完成代码

#pragma once
#include<vector>namespace Pq
{template <class T>class less{public:bool operator()(const T& x, const T& y){return x < y;}};//建小堆，>比较template <class T>class greater{public:bool operator()(const T& x, const T& y){return x > y;}};template <class T, class Container = vector<T>, class Compare = less<T> >class priority_queue{public://构造空队列priority_queue():c(){}//迭代器区间构造队列template <class InputIterator>priority_queue(InputIterator first, InputIterator last){while (first != last){c.push_back(*first);first++;}for (int i = (c.size() - 1 - 1) / 2; i >= 0; i--){Adjustdown(i);}}void push(const T& x){c.push_back(x);AdjustUp(c.size() - 1);//最后一个元素向上调整}void pop(){swap(c[0], c[c.size() - 1]);c.pop_back();Adjustdown(0);}bool empty() const{return c.empty();}size_t size() const{return c.size();}const T& top() const{return c[0];}private:Container c;Compare comp;void AdjustUp(size_t child){size_t parent = (child - 1) / 2;while (child > 0){//if (_con[parent] < _con[child])if (comp(c[parent], c[child])){swap(c[parent], c[child]);child = parent;parent = (child - 1) / 2;}else{break;}}}void Adjustdown(size_t parent){size_t child = 2 * parent + 1;while (child < c.size()){if (child + 1 < c.size() && comp(c[child], c[child + 1])){child = child + 1;}          if (comp(c[parent], c[child])){swap(c[parent], c[child]);parent = child;child = 2 * parent + 1;}else{break;}}}};};

今天就分享到这里，如果对你有帮助，请多多支持，你的支持是我更新的动力！！