算法导论学习之堆+堆排序+堆构成优先队列

注：堆分为最大堆和最小堆两种，下面我们讨论的堆都是指的最大堆，最小堆的性质与其是类似的。

堆数据结构是一种数组对象，可以被视为一棵完全二叉树(这棵二叉树除最后一层外，其余每层都是填满的)；我们用一个数组来存储一个堆，表示堆的数组有两个属性：length[A]表示的是数组中的元素个数，headsize[A]表示堆中元素个数(也就是说数组中的元素不一定都是堆中的元素)。
下面不加证明的给出一些堆的性质：
对于任何一个节点,其父节点为i/2(i>1)；左儿子:2*i,右儿子：2*i+1;
对于最大堆每个节点满足：A[parent[i]]>=A[i]
含n个元素堆的高度为lgn
含n个元素堆的叶子节点的编号为:n/2+1,n/2+2,……,n。

一.堆的调整函数—保持堆的性质
考虑这样一种情况，如果对于节点i，其左右子树都是一个合法的大根堆，但是节点i不满足堆的性质，那么我们可以通过调整使得以i为根节点的树满足堆的性质。那么具体的调整过程是怎样的呢？我们令largest表示A[i],A[i*2],A[2*i+1]中最大的那个，如果largest不是i那么我们就交换A[i]和A[largest]并且递归的进入到以largest为根节点的子树中继续进行调整。具体的代码实现如下：

void MaxHeadfly(int *a,int i,int HeadSize)
{  ///堆调整函数：调整以i为根的子树,使得其符合大根堆的特性(在其左右子树都是合法的大根堆的情况下)
  ///最大堆调整函数是堆排序中最重要的函数，是后面几个函数的重要组成部分；
 ///其主要思想是：先是调整根节点然后递归的调整受影响的左(右)子树，直到叶子节点

        int l=2*i,r=2*i+1; ///取出节点i的左右儿子节点的编号
        int largest;  ///记录最大值的节点编号
        if(a[i]<a[l]&&l<=HeadSize)
            largest=l;
        else
            largest=i;
       if(a[largest]<a[r]&&r<=HeadSize)
            largest=r;
        if(largest!=i)
        {///递归调整受影响的子树
                swp(a[i],a[largest]);
                MaxHeadfly(a,largest,HeadSize);
        }
}

二.堆的建立
堆的建立其实就是一个不断调用调整函数的过程。我们知道堆的叶子节点可以看成只含有一个元素合法的大根堆，这样如果我们从第一个非叶子节点开始依次调用调整函数，就可以保证被调整的节点的左右子树都是合法的大根堆，进而可以保证调整得到的树也是合法的大根堆。具体的代码实现如下：

void BuildMaxHead(int *a,int n)
{ ///最大堆建立函数：通过对数组元素有序的进行调整，使得数组成为一个大根堆
  ///由完全二叉树的性质：含n个元素的堆，其叶子节点编号为n/2+1,n/2+2。。。n;
  ///对于叶子节点可以看成合法的单个元素的大根堆，由MaxHeadfly函数的性质可以知道
  ///如果节点i不满足大根堆的性质，但是其左右子树都是合法的大根堆，那么调用MaxHeadfly
  ///调整后以i为根节点可以构成一个合法的大根堆，而一个节点的左右儿子节点编号都是大于其的
  ///所以我们可以从编号n/2--1的节点依次调用堆的调整函数，然后就可以得到一个大根堆了。

  for(int i=n/2;i>=1;i--)
          MaxHeadfly(a,i,n);
}

三.堆排序
顾名思义堆排序就是利用堆的性质对数组进行排序，对于一个堆来说我们能利用的性质就是其根节点中的元素是最大的，这次每次我们都可以将A[1]与A[HeadSize]进行交换，交换以后HeadSize的值减1,并且调用MaxHeadfly(a,1,HeadSize)对堆进行调整，使得A[1]又变成剩下元素中最大的，然后继续这个过程。最后得到一个有序的数组。堆排序的时间复杂度是nlgn；具体的代码实现如下：

void HeadSort(int *a,int n)
{///堆排序函数：实现对数组中的n个元素进行从小到大的排序，时间复杂度nlgn
  ///我们知道如果一个数组构成大根堆后，那么其根节点a[1]必定是其中最大的元素
  ///此时如果我们将a[1]与a[n]互换，那么a[n]就是最大的元素了；
  ///但是a[1--n-1]构成的堆可能不再满足最大堆的性质，我们再调用MaxHeadfly(a,1,n-1)调整成最大堆
  ///然后a[1]就成了a[1--n-1]中最大的元素了，然后我们交换a[1]和a[n-1]，那么a[n-1]和a[n]就是有序的了。
  ///继续这个过程直到堆的规模减少到2，然后进行最后一次调整交换，a数组就有小到大排列了。
  ///时间复杂度：建立大根堆时间O(n),每次调整时间O(lgn)共调整n-1次，所以总的复杂度nlgn
        BuildMaxHead(a,n);  ///建立一个大根堆
        int HeadSize = n;
        for(int i=n;i>=2;i--) ///堆的规模不断减少
        {
               swp(a[1],a[i]);
               HeadSize--;   ///交换以后就要减少堆的大小
               MaxHeadfly(a,1,HeadSize);   ///根节点改变了,重新调整成大根堆
        }
}

下面附上一份完整的堆排序的代码：

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;

int swp(int &a,int &b)
{
       int t=a;
        a=b;
        b=t;
}

void MaxHeadfly(int *a,int i,int HeadSize)
{  
        int l=2*i,r=2*i+1; ///取出节点i的左右儿子节点的编号
        int largest;  ///记录最大值的节点编号
        if(a[i]<a[l]&&l<=HeadSize)
            largest=l;
        else
            largest=i;
       if(a[largest]<a[r]&&r<=HeadSize)
            largest=r;
        if(largest!=i)
        {///递归调整受影响的子树
                swp(a[i],a[largest]);
                MaxHeadfly(a,largest,HeadSize);
        }
}

void BuildMaxHead(int *a,int n)
{ 
  for(int i=n/2;i>=1;i--)
          MaxHeadfly(a,i,n);
}

void HeadSort(int *a,int n)
{
        BuildMaxHead(a,n);  ///建立一个大根堆
        int HeadSize = n;
        for(int i=n;i>=2;i--) ///堆的规模不断减少
        {
               swp(a[1],a[i]);
               HeadSize--;   ///交换以后就要减少堆的大小
               MaxHeadfly(a,1,HeadSize);   ///根节点改变了,重新调整成大根堆
        }
}

int main()
{
      int n=5,a[10];
      cout<<"请输入"<<n<<"个数："<<endl;
      for(int i=1;i<=n;i++)
           cin>>a[i];
      HeadSort(a,n);
      cout<<"排序以后的数组："<<endl;
      for(int i=1;i<=n;i++)
          cout<<a[i]<<" ";
      cout<<endl;
   return 0;
}

四.优先队列
对于一般的队列来说，满足先进先出的性质(队尾入队，对首出队)，但对于优先队列来说，每次都是最大的/最小的元素出队。堆可以实现优先队列的基本操作，利用的也是堆的性质。优先队列一些具体的函数操作及其原理见下面的代码。

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;

#define INF 0x3f3f3f3f

///一般的队列满足先进先出的性质，而优选队列不同，其
///总是最大的/最小的先出队。借助于堆的性质，我们可以
///在lgn的时间内实现优选队列的任何操作
void swp(int &a,int &b)
{
      int t=a;
      a=b;
      b=t;
}

void MaxHeadfly(int *a,int i,int HeadSize)///堆调整函数
{
        int largest;
        int l=i*2,r=2*i+1;
        if(a[i]<a[l]&&l<=HeadSize)
             largest=l;
        else
             largest=i;
        if(a[largest]<a[r])
             largest=r;
        if(largest!=i)
        {
             swp(a[i],a[largest]);
             MaxHeadfly(a,largest,HeadSize);
        }
}

void BuildMaxHead(int *a,int n) ///建立一个最大堆
{
        int k=n/2;
        for(int i=k;i>=1;i--)
               MaxHeadfly(a,i,n);
}

///以下为优先队列的操作

int MaxNum(int *a) ///取出最大的元素
{
      return a[1];   ///直接返回
}

void IncreaseKey(int *a,int x,int k)
{   ///将堆中编号为x的元素的值提升到k,k不能小于原来的值。
     ///这种提升只可能会导致父节点不满足最大堆的性质，所以直接向上递归的检查
     a[x]=k;
     while(x>1&&a[x/2]<a[x])
     {
             swp(a[x],a[x/2]);
             x=x/2;
     }
}

int ExtractMax(int *a,int &HeadSize)
{    ///去掉堆中最大的元素，并返回其值
      ///思想类似于堆排序的一次调整:我们先交换a[1]与a[HeadSize]的值
      ///然后再将HeadSize的值减1(相当于去掉一个叶子节点)；然后再调用
      ///MaxHeadfly(a,1,HeadSize)对堆进行调整，保证堆的性质。
      swp(a[1],a[HeadSize]);
      HeadSize--;
      MaxHeadfly(a,1,HeadSize);
      return a[HeadSize];
}

void Insert(int *a,int &HeadSize,int x)
{    ///向堆中加入一个元素x
     ///思想：先在堆中加入一个叶子节点，并将其值赋值为-INF
     ///然后再调用上面的调整函数将该叶子节点的值调整为x

     HeadSize++;  ///增加一个叶子节点
     a[HeadSize]=-1*INF;
     IncreaseKey(a,HeadSize,x);
}

int main()
{
        int a[10];
        int n=5;
        cout<<"请输入5个数: "<<endl;
        for(int i=1;i<=n;i++)
             cin>>a[i];
        int HeadSize=n;
        BuildMaxHead(a,n);
        ///取出队列中 最大的那个元素
        cout<<"最大的元素是: "<<MaxNum(a)<<endl;
        ExtractMax(a,HeadSize);
        cout<<"移除最大元素后，剩下元素中最大的是: "<<MaxNum(a)<<endl;
        ///将第4个元素增加到100
        IncreaseKey(a,4,100);
        cout<<"将第4个元素增加到100后,最大元素是: "<<MaxNum(a)<<endl;
        ///将110插入到队列中
        Insert(a,HeadSize,110);
        cout<<"插入110后，最大元素是: "<<MaxNum(a)<<endl;
   return 0;
}