堆排序

 

   一、要实现堆排序首先要理解堆相关的一些重要概念。

 

    （1）什么是堆，堆于优先队列的关系？

    堆实际上是优先队列数据结构的实现，也可以说，堆是具有优先队列性质的容器实现。

    优先队列是允许下面两个操作的数据结构：

• Insert

• DeleteMin

    即    DeleteMin <----[优先队列] <----Insert

    尤其要强调的是DeleteMin的操作，这步操作目的是找到，返回，或删除最小项。切记！不仅仅是简单的出队，是做了一系列换位后将最小元素置换出来。

    提供了类似这样的deleteMin操作和Insert操作的即是优先队列的实现。

 

    （2）比如最容易想到的两种实现方式为：

    [1] 以一个链表来实现，这样Insert操作很容易为O(1), deleteMin操作则需要遍历链表实现为O(n)

    [2] 让一个链表始终保持排序状态，这样Insert操作变得复杂需要遍历链表才能确定插入位置，为O(n)；deleteMin操作变为O(1)    

    堆也恰恰提供了这样的操作实现。并综合降低了Insert，deleteMin操作的复杂度。

    

    我们常指的堆实际上是二叉堆，还有很多其他堆，如左式堆，斜堆，等等这里不介绍。！！

    binary heap, 是一棵完全二叉树（不一定是满二叉树）每个结点的父节点都小于等于该节点，根节点除外。

    

    完全二叉树有个非常非常重要的性质：可以用数组表示，而不需要用链表。 一定要理解此性质！！！

    也就是说堆可以用数组实现。这样最大的好处是，可以在常数时间找到min，Insert操作为O(logn)，deleteMin操作平均为O(logn)

 

   二、举个例子，下图就是个最小堆，父节点都比子节点小。如果将其反过来，父节点都比子节点大，那就是最大堆。

   如图，想象一下东西是怎么磊成堆的，就能理解这个名字的精妙了。

            1

          /     \

        2      7

       / \      / \

     3  4  8  9

   堆很容易就可以用数组表示，任意元素i，其子节点就是[2*i]，[2*i+1]，其父节点就是[j/2]，写起来很简单吧，也很容易理解。

 

   堆排序的思想就是利用堆的这种父子节点大小关系的特性，来降低比较次数。

   想象一下单循环淘汰赛，比如说欧洲冠军杯。先捉对厮杀，再一层一层往上走。堆排序就是这么做的。第一次从N中选出冠军。然后将冠军拿掉，剩下的N-1再选，以此计算，直到剩最后一个时，全部排序也就完成了。

   举个例子：数组为：2, 5, 3, 2, 3, 0, 8, 1

   得到初始状态如下图：

            2

          /   \

        5     3

       / \     / \

      2  3  0  8

     /

   1

   选出第一个冠军：

           8

         /   \

        5     2

       / \     / \

      2  3  0  3

     /

   1

   将冠军移到最后，然后，图也就变成

           1

         /   \

       5     2

      / \     / \

    2  3  0  3

   8

   继续选冠军：

            5

          /   \

       1      3

      / \      / \

    2  3  0  2

   8

   再将冠军移到树的最后：

            2

           /   \

         1      3

        / \     / \

      2  3  0  5

    8

   继续选冠军：

              3

            /   \

         2      3

        / \      / 

      2  1   0  5

    8

   再将冠军移到树的最后：

           0

          /   \

       2     3

       / \

      2  1  3  5

     8

   继续选冠军：

              3

            /   \

          2     0

        / \

       2  1  3  5

     8

   再将冠军移到树的最后：

            1

           /   \

        2     0

        /

     2  3  3  5

    8

   继续选冠军：

             2

            /   \

          1     0

          /

         2  3  3  5 

      8

   再将冠军移到树的最后：

                2

              /   \

           1     0

        2  3  3  5

        8

   继续选冠军：

               2

             /   \

           1     0

         2  3  3  5

        8

   再将冠军移到树的最后：

              0

            /

          1     2

        2  3  3  5

      8

   继续选冠军：

           1

          /

       0     2

     2  3  3  5

    8

  再将冠军移到树的最后：

        0

      1     2

    2  3  3  5

   8

 

   搞定啦！

  0, 1, 2, 3, 3, 5, 8

 

   代码如下：

 void FindMaxInHeap(int arr[], const int size) { 
    for (int j = size - 1; j > 0; --j) { 
        int parent = j / 2; 
        int child = j; 
        if (j < size - 1 && arr[j] < arr[j+1]) { 
            ++child; 
        } 
        if (arr[child] > arr[parent]) { 
            int tmp = arr[child]; 
            arr[child] = arr[parent]; 
            arr[parent] = tmp; 
        } 
    } 
} 
void HeapSort(int arr[], const int size) { 
    for (int j = size; j > 0; --j) { 
        FindMaxInHeap(arr, j); 
        int tmp = arr[0]; 
        arr[0] = arr[j - 1]; 
        arr[j - 1] = tmp; 
    } 
} 
void TestHeapSort() { 
    int arr[] = {2, 5, 3, 2, 3, 0, 8, 1}; 
    int n = sizeof(arr) / sizeof(arr[0]); 
    HeapSort(arr, n); 
    for (int j = 0; j < n; ++j) { 
        cout << arr[j] << ", "; 
    } 
    cout << endl; 
} 

   三、由（一）的讨论，我们可以得到另外一种排序实现方法

 

      排序的简单思路是，因为每次都能得到最大值（根结点），所以每做一次deleteMax操作即可去除一个最大值。这样做n次变得到排序结果。

    于是容易得到基本代码：

     void HeapSort(int p[], int size)

     {

        BuildMaxHeap(p, size);

        for(int i=size-1; i>0; i--)

        {

            DeleteMax(p, i);

        }

     }

    问题转化为如何实现BuildMaxHeap， DeleteMax操作。并有良好的时间，空间复杂度。

    设待排序列为数组p[n] 如果将p建成堆后，很明显p[0]为根结点，即最大值。

    考虑每次DeleteMax操作后，堆的大小变为n-1，可将p[0]与最后一个元素交换，于是DeleteMax操作的效果可视为：

    n个元素的堆序列 -> n-1个元素的堆序列|Max 如此循环下去便能完成排序。   

    这里的BuildMaxHeap, DeleteMax均会用到下滤算法：如果某个元素影响堆序性质（父节点>=孩子）则将较大的孩子结点与其对换，如此往复下去，直至该元素到达正确位置。

    BuildMaxHeap，建堆的实现方式：由于所有树叶无需进行下滤（没有孩子）， 所以只对0 - size/2的结点进行下滤即可。

    DeleteMax 操作需要将最大值即p[0]与堆数组的最后一个元素（如p[n]）互换，然后对p[0]进行下滤操作即可得到一个 n-1个元素堆序列|max

 

    代码实现：

 

#include <iostream>
using namespace std;

//template <typename Comparable>

void BuildMaxHeap(int p[], int size);
void DeleteMax(int p[], int size);
void PercolateDown(int array[],int hole, int size);

void HeapSort(int p[], int size)
{
    BuildMaxHeap(p, size);
    for (int i=size; i>=1; i--)
    {
        DeleteMax(p, i);
    }
}


void BuildMaxHeap(int p[], int size)
{
    //由于所有树叶无需进行下滤（没有孩子）， 所以只对0 - size/2的结点进行下滤即可。
    for (int i=size/2-1; i>=0; i--)
        PercolateDown(p, i, size);
}

void DeleteMax(int p[], int size)
{
    int tmp;
    tmp = p[0];
    p[0] = p[size-1];
    p[size-1] = tmp;
    PercolateDown(p, 0, --size);   
}

void PercolateDown(int array[],int hole, int size)
{
    int tmp = array[hole];
    int child=0;
    for (; (hole*2+1)<=(size-1); hole=child)
    {
        child = hole*2 + 1;
        if (child<size-1 && (array[child+1] > array[child]))
            child++;
        if (array[child]>tmp)
            array[hole] = array[child];
        else
            break;
    }
    array[hole] = tmp;
}

void PrintArray(int data[], int size)
{
    for (int i=0; i<size; ++i)
    {
        cout <<data[i]<<" ";
    }
    cout<<endl;
}

int main(int argc, const char** argv)
{
    int data[] = {20,34,4,53,43,42,6,67,193};
    int size = sizeof(data)/sizeof(data[0]);
    HeapSort(data, size);
    PrintArray(data, size);
    return 0;
}