排序算法6之堆排序

本文主要参考：
http://blog.csdn.net/morewindows/article/details/6709644/

堆的定义

二叉堆是完全二叉树或者是近似完全二叉树。
在这里补充一下，什么是完全二叉树：
完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。
性质：
可以根据公式进行推导，假设$n_0$是度为0的结点总数（即叶子结点数），$n_1$是度为1的结点总数，$n_2$是度为2的结点总数，由二叉树的性质可知：$n_0=n_2+1$，$n= n_0+n_1+n_2$（其中$n$为完全二叉树的结点总数），由上述公式把$n_2$消去得：$n= 2n_0+n_1-1$，由于完全二叉树中度为1的结点数只有两种可能0或1，由此得到$n_0=(n+1)/2$或$n_0=n/2$。
总结起来，就是 $n_0=[n/2]$，其中[]表示上取整。可根据完全二叉树的结点总数计算出叶子结点数。

二叉堆满足二个特性：

1．父结点的键值总是大于或等于（小于或等于）任何一个子节点的键值。

2．每个结点的左子树和右子树都是一个二叉堆。

当父结点的键值总是大于或等于任何一个子节点的键值时为最大堆。当父结点的键值总是小于或等于任何一个子节点的键值时为最小堆。

子节点和父节点的下标关系

作为数据结构意义上的堆，一般利用数组进行存储。比如：
当已知子节点的数组下标为$i$时，父节点的数组下标为$\frac{i-1}{2}$；
当已知父节点的数组下标为$i$时，左子节点的数组下标为$(2*i+1)$，右子节点的数组下标为$(2*i+2)$。

堆的插入

每次插入都是将新数据放在数组最后。可以发现从这个新数据的父结点到根结点必然为一个有序的数列，现在的任务是将这个新数据插入到这个有序数据中，代码如下：

void minHeapFixUp(int *p,int i)
{
    int tmp=p[i];//i是子节点的下标
    int j=(i-1)/2;//j是父节点的下标
    while(j>=0)
    {
        if (p[j]<=tmp)
            break;//如果父节点比子节点小，说明数组已经是有序的了。
        p[i]=p[j];//否则交换父节点和子节点的位置
        i=j;
        j=(i-1)/2;
    }
    p[i]=tmp;
    return;
}//插入节点

//在最小堆中加入新的数据nNum  
void MinHeapAddNumber(int *p, int n, int nNum)  
{  
     p[n] = nNum;  
     minHeapFixUp(p, n);  
 }  

堆的删除

按定义，堆中每次都只能删除第0个数据。为了便于重建堆，实际的操作是将最后一个数据的值赋给根结点，然后再从根结点开始进行一次从上向下的调整。调整时先在左右儿子结点中找最小的，如果父结点比这个最小的子结点还小说明不需要调整了，反之将父结点和左右子节点中较小交换。

void minHeapFixDown(int *p,int i,int n)
{
    int tmp=p[i];//n是节点个数
    int j=2*i+1;//i是父节点，j是子节点
    while(j<n)
    {
        if((j+1)<n&&(p[j+1]<p[j]))
            j++;//找出左右子节点中较小的
        if(tmp<p[j])//如果父节点比子节点小，说明已经是正确顺序
            break;
        p[i]=p[j];//否则交换父节点和子节点
        i=j;
        j=2*i+1;
    }
    p[i]=tmp;
    return;
}//剔除节点后，重新排列成堆
void swap(int& a,int& b)
{
    int tmp;
    tmp=a;
    a=b;
    b=tmp;
}

//在最小堆中删除数  
void MinHeapDeleteNumber(int *p, int n)  
{  
    swap(p[0], p[n-1]);  
    MinHeapFixdown(a, 0, n - 1);  
}  

堆化数组

由于叶子节点是不需要比较大小的，所以可以认为所有的叶子节点都是正确排列的，那么叶子节点之前的父节点，可以理解为一个个待排序的根节点，也就是一个“下沉”过程。由完全二叉树的性质，存在$n_0=[n/2]$个叶子节点，如果在c++里定义就是$n_0=\frac{n}{2}+1$个叶子节点，也就是存在$n/2$个父节点，那么我们需要从数组下标$i=\frac{n}{2}-1$处开始进行“下沉”过程：

void MakeMinHeap(int p*, int n)  
{  
    for (int i = n / 2 - 1; i >= 0; i--)  
        MinHeapFixdown(p, i, n);  
}  

堆排序

首先可以看到堆建好之后堆中第0个数据是堆中最小的数据。取出这个数据再执行堆的删除操作。这样堆中第0个数据又是堆中最小的数据，重复上述步骤直至堆中只有一个数据时就直接取出这个数据。

    void MinheapsortTodescendarray(int p*, int n)  //n是总的节点数
    {  
        for (int i = n - 1; i >= 1; i--)  
        {  
            swap(a[i], p[0]);  //将根节点删除
            MinHeapFixdown(p, 0, i);  
        }  
    }  

时间复杂度分析

由于每次重新恢复堆的时间复杂度为$O(logN)$，共$N - 1$次重新恢复堆操作，再加上前面建立堆时$N / 2$次向下调整，每次调整时间复杂度也为$O(logN)$。二次操作时间相加还是$O((\frac{3*N}{2}-1)* logN)=O(NlogN)$。故堆排序的时间复杂度为$O(N * logN)$。