第十四章 堆

    这章的内容主要是围绕堆这个数据结构和围绕堆的结构提供的两种操作：siftup，由下向上调整重新获得堆的性质；siftdown，由上向下调整重新获得堆的性质。通过堆（和对堆的性质的定义），两个调整堆的函数，就可以完成本章后面两部分介绍的内容：1，优先级队列。2，堆排序。本章的代码主要是针对优先级队列的。

    优先级队列操作一个初始为空的元素集合，S。insert函数在集合中插入一个新元素，extractmin删除集合中最小的元素并通过单个参数返回。

    可以使用模板定义一个C++类来完成这一任务：

    template<class T>

    class priqueue

    {

                private:

                public:

                       priqueue(int maxsize);    // init set S to empty

                       void insert(T t);

                       T extractmin();

    }

    优先级队列在很多应用中都非常有用，操作系统可以使用这样一种结构来表示一组任务，按任意顺序插入它们，然后进行提取： priqueue<Task> queue;

    可以使用数组或链表之类的顺序结构来实现优先级队列。下表比较了几种结构的性能：

   

    文中用堆来实现优先级队列，insert插入新数据并调整为堆，extractmin返回最小值并重新调整为堆，各需要O(nlogn)。在文中的第二部分堆排序中，只是用一个一维数组的空间和siftup和siftdown操作便完成堆排序。

    优先级队列的实验代码如下：

 

//  priority queues(优先级队列), using heaps

#include <iostream>

using namespace std;

template <class T>         //
class priqueue
{
      private:
              int n, maxsize;
              T *x;
              void swap(int i, int j){ T temp=x[i]; x[i]=x[j]; x[j]=temp; }
      public:
             priqueue(int m)
             {
                           maxsize=m;    // 初始化私有成员 
                           x = new T[maxsize+1];
                           n=0;
             }
             /*
             void insert(T t)
             {
                  x[++n]=t;
                  int h=n;
                  for(;;)
                  {
                         // two stop conditiions
                         if(h<=1)
                                 break;
                         else if(x[h]>=x[h/2])
                                 break;
                         else
                                 swap(h, h/2);
                         h=h/2;
                  }
             }
             */
             void insert(T t)
             {
                  int i, p;
                  x[++n]=t;
                  // 判断条件放在for循环中 
                  for(i=n; i>1 && x[p=i/2]>x[i]; i=p)
                      swap(i, p);
             }
             
             /* 
             T extractmin()   由于只定义了一个变量导致表示很复杂 
             {
                           T min = x[1];
                           swap(1, n--);
                           int c=1;
                           for(;;)
                           {
                                  // two stop conditions
                                  if(2*c>n)
                                      break;
                                  if(2*c==n)
                                  {
                                            if(x[c]<=x[2*c])
                                                break;
                                            else
                                            {
                                                c=2*c;
                                                swap(c/2, c);
                                            }
                                  }
                                  else
                                  {
                                      if(x[c]<=x[2*c] && x[c]<=x[2*c+1])
                                                break;
                                      else
                                      {
                                          c=2*c;
                                          if(x[c]>x[c+1])
                                              c++;
                                          swap(c/2, c);
                                      }
                                  }
                           }
                           
                           return min;
             }
             */
             
             T extractmin()
	         {	
                           int i, c;
		                   T min = x[1];
                           swap(1, n--);
                           // 判断条件放在for循环中 
		                   for(i=1;(c=2*i)<=n;i=c)
		                   {
                                                  if(c+1<=n && x[c+1]<x[c])
                                                      c++;
                                                  if(x[i]<=x[c])
                                                      break;
                                                  swap(c, i);
                           }
		                   return min;
		     }
};

template <class T>
void pqsort(T m[], int n)
{
     priqueue<int> p(n);
     for(int i=0;i<n;i++)
         p.insert(m[i]);
     for(int i=0;i<n;i++)
         m[i]=p.extractmin();
}

int main()
{
    int n=10;
    int i, v[n];
    for(i=0;i<n;i++)
        v[i]=n-i;

    cout<<"Before Using priorityqueque:"<<endl;
    for(i=0;i<n;i++)
        cout<<v[i]<<endl;
    pqsort(v, n);
    cout<<"After Using priorityqueque:"<<endl;
    for(i=0;i<n;i++)
        cout<<v[i]<<endl;

    return 0;
}

运行结果：