STL之heap与优先级队列Priority Queue详解

一、heap

             heap并不属于STL容器组件,它分为 max heap 和min heap,在缺省情况下,max-heap是优先队列(priority queue)的底层实现机制。而这个实现机制中的max-heap实际上 是以一个vector表现的完全二叉树(complete binary tree)。STL在中实现了对 存储在vector/deque 中的元素进行堆操作的函数,包括make_heap, pop_heap, push_heap, sort_heap,对不愿自己写数据结构堆的C++选手来说,这几个算法函数很有用,详细解释可以参见: http://www.cplusplus.com/reference/algorithm/make_heap/

下面的_First与_Last为可以随机访问的迭代器(指针),_Comp为比较函数(仿函数),其规则——如果函数的第一个参数小于第二个参数应返回true,否则返回false。

1.make_heap():

make_heap(_First, _Last)

make_heap(_First, _Last, _Comp)

默认是建立最大堆的。对int类型,可以在第三个参数传入greater()得到最小堆。

2.push_heap(_First, _Last):

新添加一个元素在末尾,然后重新调整堆序。也就是把元素添加在底层vector的end()处。

该算法必须是在一个已经满足堆序的条件下,添加元素。该函数接受两个随机迭代器,分别表示first,end,区间范围。

关键是我们执行一个siftup()函数,上溯函数来重新调整堆序。具体的函数机理很简单,可以参考我的编程珠玑里面堆的实现的文章。

3.pop_heap(_First, _Last):

这个算法跟push_heap类似,参数一样。不同的是我们把堆顶元素取出来,放到了数组或者是vector的末尾,用原来末尾元素去替代,然后end迭代器减1,执行siftdown()下溯函数来重新调整堆序。

注意算法执行完毕后,最大的元素并没有被取走,而是放于底层容器的末尾。如果要取走,则可以使用底部容器(vector)提供的pop_back()函数。

4.sort_heap(_First, _Last):

既然每次pop_heap可以获得堆中最大的元素,那么我们持续对整个heap做pop_heap操作,每次将操作的范围向前缩减一个元素。当整个程序执行完毕后,我们得到一个非降的序列。注意这个排序执行的前提是,在一个堆上执行。

下面是这几个函数操作vector中元素的例子。

#include
#include
#include

using namespace std;

int main()
{
  int a[] = {15, 1, 12, 30, 20};
  vector ivec(a, a+5);
  for(vector::iterator iter=ivec.begin();iter!=ivec.end();++iter)
    cout<<*iter<<" ";
  cout<::iterator iter=ivec.begin();iter!=ivec.end();++iter)
    cout<<*iter<<" ";
  cout<::iterator iter=ivec.begin();iter!=ivec.end();++iter)
    cout<<*iter<<" ";
  cout<::iterator iter=ivec.begin();iter!=ivec.end();++iter)
    cout<<*iter<<" ";
  cout<::iterator iter=ivec.begin();iter!=ivec.end();++iter)
    cout<<*iter<<" ";
  cout<

二、priority queue

       优先队列(priority_queue)首先是一个queue,那就是必须在末端推入,必须在顶端取出元素。除此之外别无其他存取元素的途径。内部元素按优先级高低排序,优先级高的在前。缺省情况下,priority_heap利用一个max-heap完成,后者是一个以vector表现的完全二叉树。我们说优先队列不是一个STL容器,它以底部容器而实现,修改了接口,形成另一种性质,这样的东西称之为适配器(adapter)。

详情参见: http://www.cplusplus.com/reference/stl/priority_queue/

优先级队列是一个拥有权值观念的queue。它允许在底端添加元素、在顶端去除元素、删除元素。

优先级队列内部的元素并不是按照添加的顺序排列,而是自动依照元素的权值排列。权值最高者排在最前面。

缺省情况下,优先级队列利用一个大顶堆完成。关于堆可以参考:STL堆详解与编程实现

优先级队列以底部容器完成其所有工作,具有这种“修改某物接口,形成另一种风貌”这种性质者,成为配接器(adapter)。在STL中优先级队列不被归类为容器,而被归类为容器配接器(container adapter)
priority_queue 对于基本类型的使用方法相对简单。

他的模板声明带有三个参数,priority_queue
Type 为数据类型, Container 为保存数据的容器,Functional 为元素比较方式。
Container 必须是用数组实现的容器,比如 vector, deque 但不能用 list.
STL里面容器默认用的是 vector. 比较方式默认用 operator< , 所以如果你把后面俩个参数 缺省的话,优先队列就是大顶堆,队头元素最大。
看例子

#include 
#include 
using namespace std;
int main(){
    priority_queue,less >q;//使用priority_queue q1;一样
    for(int i=0;i<10;i++) 
		q1.push(i);
    while(!q1.empty()){
        cout<
如果要用到小顶堆,则一般要把模板的三个参数都带进去。
STL里面定义了一个仿函数 greater<>,对于基本类型可以用这个仿函数声明小顶堆
例子:

#include 
#include 
using namespace std;
int main(){
    priority_queue,greater >q;
    for(int i=0;i<10;i++) 
		q.push(i);
    while(!q.empty()){
        cout<
对于 自定义类型,则必须自己重载 operator< 或者自己写仿函数先看看例子:
#include 
#include 
using namespace std;
struct Node{
	int x, y;
}node;
 bool operator<( Node a, Node b){
    if(a.x==b.x) return a.y>b.y;
    return a.x>b.x;
}
 int main(){
    priority_queueq;
    for(int i=0;i<10;i++){
    	node.x=i;
    	node.y=10-i/2;
    	q.push(node);
    }	
    while(!q.empty()){
        cout<
自定义类型重载 operator< 后,声明对象时就可以只带一个模板参数。
此时不能像基本类型这样声明priority_queue, greater >;
原因是 greater 没有定义,如果想用这种方法定义
则可以按如下方式例子:( 个人喜欢这种方法,因为set的自定义比较函数也可以写成这种形式
#include 
#include 
using namespace std;
struct Node{
	int x, y;
}node;
struct cmp{
    bool operator()(Node a,Node b){
        if(a.x==b.x) return a.y>b.y;
        return a.x>b.x;}
};

 int main(){
    priority_queue,cmp>q;
    for(int i=0;i<10;i++){
    	node.x=i;
    	node.y=10-i/2;
		q.push(node);	
    }	
    while(!q.empty()){
        cout<

SGI STL中优先级队列定义

定义完整代码:

    template ,   
              class Compare = less >   
    class priority_queue {   
    public:   
      typedef typename  Sequence::value_type  value_type;   
      typedef typename  Sequence::size_type  size_type;   
      typedef typename  Sequence::reference  reference;   
      typedef typename  Sequence::const_referenceconst_reference;   
    protected:   
    Sequence c;  //底层容器   
        Compare comp;//元素大小比较标准   
    public:   
    priority_queue() : c() {}   
      explicit  priority_queue(const Compare& x) :  c(), comp(x) {}   
       
    //以下用到的 make_heap(), push_heap(), pop_heap()都是泛型算法   
    //注意,任一个建构式都立刻于底层容器内产生一个 implicit representation heap。   
      template     
    priority_queue(InputIterator first, InputIterator last, const Compare& x)   
        : c(first, last), comp(x) {make_heap(c.begin(), c.end(), comp); }   
      template     
    priority_queue(InputIterator first, InputIterator last)   
        : c(first,  last)  { make_heap(c.begin(), c.end(), comp); }   
       
      bool empty() const { return c.empty(); }   
      size_typesize() const { return c.size(); }   
      const_referencetop() const { return c.front(); }   
      void push(const value_type& x) {   
        __STL_TRY {   
    // push_heap是泛型算法,先利用底层容器的 push_back() 将新元素   
          // 推入᳿端,再重排 heap。见 C++ Primer p.1195。   
    c.push_back(x);   
    push_heap(c.begin(), c.end(), comp);// push_heap是泛型算法   
        }   
        __STL_UNWIND(c.clear());   
      }   
      void pop() {   
        __STL_TRY {   
    // pop_heap 是泛型算法,从 heap 内取出一个元素。它并不是真正将元素   
          // 弹出,而是重排 heap,然后再以底层容器的 pop_back() 取得被弹出   
          // 的元素。见 C++ Primer p.1195。   
    pop_heap(c.begin(), c.end(), comp);   
    c.pop_back();   
        }   
        __STL_UNWIND(c.clear());   
      }   
    };   

优先级队列编程实现(C Plus Plus)

在这里自己用C++编程实现了简易版的优先级队列。

其中用到了前一篇博客里面的堆heap.h:

    //STL堆算法实现(大顶堆)  
      
    //包含容器vector的头文件:Heap用vector来存储元素  
    #include   
    #include   
    #include   
      
    #define MAX_VALUE 999999 //某个很大的值,存放在vector的第一个位置(最大堆)  
      
    const int StartIndex = 1;//容器中堆元素起始索引  
      
    using namespace std;  
      
    //堆类定义  
    //默认比较规则less  
    template  >  
    class MyHeap{  
    private:  
        vector heapDataVec;//存放元素的容器  
        int numCounts;//堆中元素个数  
        Compare comp;//比较规则  
      
    public:  
        MyHeap();  
      
        vector& getVec();  
      
        void initHeap(ElemType *data,const int n);//初始化操作  
        void printfHeap();//输出堆元素  
        void makeHeap();//建堆  
        void sortHeap();//堆排序算法  
        void pushHeap(ElemType elem);//向堆中插入元素  
        void popHeap();//从堆中取出堆顶的元素  
        void adjustHeap(int childTree,ElemType adjustValue);//调整子树  
        void percolateUp(int holeIndex,ElemType adjustValue);//上溯操作  
      
        void setNumCounts(int val);//设置当前所要构建的堆中元素个数  
    };  
      
    template   
    MyHeap::MyHeap()  
    :numCounts(0)  
    {  
        heapDataVec.push_back(MAX_VALUE);  
    }  
      
    template   
    vector& MyHeap::getVec()  
    {  
        return heapDataVec;  
    }  
      
    template   
    void MyHeap::initHeap(ElemType *data,const int n)  
    {  
        //拷贝元素数据到vector中  
        for (int i = 0;i < n;++i)  
        {  
            heapDataVec.push_back(*(data + i));  
            ++numCounts;  
        }  
    }  
      
    template   
    void MyHeap::printfHeap()  
    {  
        cout << "Heap : ";  
        for (int i = 1;i <= numCounts;++i)  
        {  
            cout << heapDataVec[i] << " ";  
        }  
        cout << endl;  
    }  
      
    template   
    void MyHeap::makeHeap()  
    {  
        //建堆的过程就是一个不断调整堆的过程,循环调用函数adjustHeap依次调整子树  
        if (numCounts < 2)  
            return;  
        //第一个需要调整的子树的根节点多音  
        int parent = numCounts / 2;  
        while(1)  
        {  
            adjustHeap(parent,heapDataVec[parent]);  
            if (StartIndex == parent)//到达根节点  
                return;  
      
            --parent;  
        }  
    }  
      
    template   
    void MyHeap::sortHeap()  
    {  
        //堆排序思路  
        //每执行一次popHeap操作,堆顶的元素被放置在尾端,然后针对前面的一次再执行popHeap操作  
        //依次下去,最后即得到排序结果  
        while(numCounts > 0)  
            popHeap();  
    }  
      
    template   
    void MyHeap::pushHeap(ElemType elem)  
    {  
        //将新元素添加到vector中  
        heapDataVec.push_back(elem);  
        ++numCounts;  
      
        //执行一次上溯操作,调整堆,以使其满足最大堆的性质  
        percolateUp(numCounts,heapDataVec[numCounts]);  
    }  
      
    template   
    void MyHeap::popHeap()  
    {  
        //将堆顶的元素放在容器的最尾部,然后将尾部的原元素作为调整值,重新生成堆  
        ElemType adjustValue = heapDataVec[numCounts];  
        //堆顶元素为容器的首元素  
        heapDataVec[numCounts] = heapDataVec[StartIndex];  
        //堆中元素数目减一  
        --numCounts;  
      
        adjustHeap(StartIndex,adjustValue);  
    }  
      
    //调整以childTree为根的子树为堆  
    template   
    void MyHeap::adjustHeap(int childTree,ElemType adjustValue)  
    {  
        //洞节点索引  
        int holeIndex = childTree;  
        int secondChid = 2 * holeIndex + 1;//洞节点的右子节点(注意:起始索引从1开始)  
        while(secondChid <= numCounts)  
        {  
            if (comp(heapDataVec[secondChid],heapDataVec[secondChid - 1]))  
            {  
                --secondChid;//表示两个子节点中值较大的那个  
            }  
      
            //上溯  
            heapDataVec[holeIndex] = heapDataVec[secondChid];//令较大值为洞值  
            holeIndex = secondChid;//洞节点索引下移  
            secondChid = 2 * secondChid + 1;//重新计算洞节点右子节点  
        }  
        //如果洞节点只有左子节点  
        if (secondChid == numCounts + 1)  
        {  
            //令左子节点值为洞值  
            heapDataVec[holeIndex] = heapDataVec[secondChid - 1];  
            holeIndex = secondChid - 1;  
        }  
        //将调整值赋予洞节点  
        heapDataVec[holeIndex] = adjustValue;  
      
        //此时可能尚未满足堆的特性,需要再执行一次上溯操作  
        percolateUp(holeIndex,adjustValue);  
    }  
      
    //上溯操作  
    template   
    void MyHeap::percolateUp(int holeIndex,ElemType adjustValue)  
    {  
        //将新节点与其父节点进行比较,如果键值比其父节点大,就父子交换位置。  
        //如此,知道不需要对换或直到根节点为止  
        int parentIndex = holeIndex / 2;  
        while(holeIndex > StartIndex && comp(heapDataVec[parentIndex],adjustValue))  
        {  
            heapDataVec[holeIndex] = heapDataVec[parentIndex];  
            holeIndex = parentIndex;  
            parentIndex /= 2;  
        }  
        heapDataVec[holeIndex] = adjustValue;//将新值放置在正确的位置  
    }  
      
    template   
    void MyHeap::setNumCounts(int val)  
    {  
        numCounts = val;  
    }  

PriorityQueue.h:

    #include "Heap.h"  
      
    //优先级队列类定义  
    //默认:值最小的权值最大  
    template  >  
    class MyPriorityQueue{  
    private:  
        MyHeap heap;//底层用堆实现  
      
    public:  
        //构造函数  
        MyPriorityQueue(ElemType *data,int n);  
      
        //判断优先级队列是否为空  
        int empty(){return heap.getVec().size() - 1;}  
        //返回优先级队列大小  
        long size(){return heap.getVec().size() - 1;}//注意底层容器第一个元素是无效元素  
        //取得优先级队列头元素  
        ElemType top(){return heap.getVec()[StartIndex];}  
        //添加元素  
        void push(const ElemType &val);  
        //弹出队首元素  
        void pop();  
        MyHeap& getHeap(){return heap;};  
    };  
      
    template   
    MyPriorityQueue::MyPriorityQueue(ElemType *data, int n)  
    {  
        heap.initHeap(data,n);  
        heap.makeHeap();  
        heap.sortHeap();  
    }  
      
    template   
    void MyPriorityQueue::push(const ElemType &val)  
    {  
        heap.setNumCounts(heap.getVec().size() - 1);//排除容器首部的哨兵元素  
        heap.makeHeap();  
        heap.pushHeap(val);  
        heap.sortHeap();  
    }  
      
    template   
    void MyPriorityQueue::pop()  
    {  
        heap.getVec().erase(heap.getVec().begin() + 1);//删除队列首部的元素  
        heap.setNumCounts(heap.getVec().size() - 1);//排除容器首部的哨兵元素  
        heap.makeHeap();  
        heap.sortHeap();  
    }  

PriorityQueueTest.cpp:

    #include "PriorityQueue.h"  
      
    #include   
    #include   
      
    using namespace std;  
      
    int main()  
    {  
        const int n = 9;  
        int data[n] = {0,1,2,3,4,8,9,3,5};  
        MyPriorityQueue *priorityObj1 = new MyPriorityQueue(data,n);  
        cout << "Current Heap: " << endl;  
        for (int i = 1;i <= priorityObj1->size();++i)  
        {  
            cout << priorityObj1->getHeap().getVec()[i] << " ";  
        }  
        cout << endl;  
        cout << "Size = " << priorityObj1->size() << endl;  
        cout << "Top element = " << priorityObj1->top() << endl;  
        priorityObj1->pop();  
        cout << "After pop one element:" << endl;  
        cout << "Size = " << priorityObj1->size() << endl;  
        cout << "Top element = " << priorityObj1->top() << endl;  
      
        cout << "Current Heap: " << endl;  
        for (int i = 1;i <= priorityObj1->size();++i)  
        {  
            cout << priorityObj1->getHeap().getVec()[i] << " ";  
        }  
        cout << endl;  
      
        priorityObj1->pop();  
        cout << "After pop one element:" << endl;  
        cout << "Size = " << priorityObj1->size() << endl;  
        cout << "Top element = " << priorityObj1->top() << endl;  
      
        cout << "Current Heap: " << endl;  
        for (int i = 1;i <= priorityObj1->size();++i)  
        {  
            cout << priorityObj1->getHeap().getVec()[i] << " ";  
        }  
        cout << endl;  
      
        priorityObj1->push(7);  
        cout << "After push one element 7:" << endl;  
        cout << "Size = " << priorityObj1->size() << endl;  
        cout << "Top element = " << priorityObj1->top() << endl;  
      
        cout << "Current Heap: " << endl;  
        for (int i = 1;i <= priorityObj1->size();++i)  
        {  
            cout << priorityObj1->getHeap().getVec()[i] << " ";  
        }  
        cout << endl;  
      
        delete priorityObj1;  
    }  
运算结果:

转载于:https://www.cnblogs.com/tham/p/6827233.html

你可能感兴趣的:(STL之heap与优先级队列Priority Queue详解)