堆的实现、堆排序及其应用

堆排序和其他排序算法的比较



上图引自：http://hi.baidu.com/ycdoit/item/6b5f5b9571a843becc80e560，这篇文章也解释了可能的优化途径。

（sort 是STL的排序方法，qsort是库函数，quicksort是没有经过优化的快速排序实现，Heapsort是一般的堆排序实现）

堆的定义

谈堆排序首先要有堆，堆类似于一种特殊的完全二叉树，分为最大堆和最小堆。

最大堆：所有结点的值都不大于其父结点。

最小堆：所有结点的值都不小于其父结点。

关于堆的定义和特性，请参考http://blog.csdn.net/v_JULY_v/article/details/6198644，非常好的一篇关于堆排序的文章。

堆的实现

谈这个话题是写这篇文章的主要原因。

我们常说程序就是数据结构和算法的组合，具体到堆的实现上，算法体现出了非常强大的抽象作用，表现在：

1. 存储最小堆或者最大堆的数据结构就是一个简单的数组。

2. 算法实现的时候，把这个数组看作一种完全二叉树：

(1) 从根结点开始（编号为1），分层遍历这颗二叉树，每个结点的编号是上一个遍历到的结点编号+1，就是说：

1

/ \

2 3

/ \

4 5

(2) 二叉树各个结点按照编号顺序存在数组中。

(3) 对于完全二叉树来说，下面的条件成立：

第i个结点的父结点为第|_i/2_|个结点（|_i/2_|表示对i/2的结果向下取整）。

第i个结点的左孩子结点为第2i个结点。

第i个结点的右孩子结点为第2i+1个结点。

带着上面的逻辑来实现最小堆和最大堆，就是把父结点和左右子结点的大小关系映射为数组中第i个数据和第2i以及第2i+1个数据的大小关系。

这里我们没有定义二叉树的数据结构，而是在处理数组的时候将其看作分层遍历的完全二叉树结点，具体表现在算法的实现上面。

很多人在想到堆的时候就想到二叉树的数据结构，进而认为堆的实现就基于这种数据结构，堆排序也是对二叉树的排序，这是不准确的，其实我们的操作，包括创建一个最小堆或最大堆，以及进行堆排序都是在上面映射关系的基础上，用处理数组元素的方式进行的。

当然，可以用二叉树的数据结构，但是考虑到这种数据结构相比数组而言，每个结点的大小增加了，而堆排序的算法却没有优化，还是平均N*log2(N)（N为结点数量），必要性在哪里？

所以，有时候一种不同的对待事物的方式可以极大提高我们的编程效率，这就是算法的威力所在。

寻找M个数中的前K个最小的数并保持有序

这个算法题在这篇文章中得到了精彩详尽的讨论，强烈推荐感兴趣的同学学习一下。

这里我们使用最大堆来解决：

1. 用M个数里面的前K个数创建一个K个元素的最大堆。

2. 将第M-k个数到第M个数依次和上面最大堆的第一个元素（存储这个最大堆的第1个数据，也即是抽象的完全二叉树的根结点数据）比较，如果大于等于堆顶元素，继续下一个数进行比较（堆顶元素在最大堆中最大），如果小于堆顶元素，就把堆顶元素值设置为这个数，然后重新对这个堆进行重新最大堆化，使之符合最大堆的要求。

3. 结束之后最大堆里面放的就是最小的K个数了，这时对最大堆进行堆排序，就解决这个问题了。

时间复杂度为 :

O(K) + (M - K)*log2(K)

| |

创建K个元素最大堆的时间复杂度 对剩余M-K个数据进行比较并每次对最大堆进行重新最大堆化

在K远小于M的时候，时间复杂度相当于M*log2(K)。

完整代码实现：

P.S.如果需要在M非常大的情况下测试，可以考虑将M个数据保存在文件中，然后依次读取进行处理。

#include <iostream>
using namespace std;

/******************
根据输入的int数组创建一个最大堆
input：      输入的int数组
maxHeap:     最大堆数组
maxHeapCount 最大堆中元素的个数
******************/
void createMaxHeap(const int * input, int * maxHeap, const int maxHeapCount);

/******************
对输入int数组进行操作，使之符合最大堆的条件：
所有结点的值不大于其父结点

maxHeap:     最大堆数组
pos:         最大堆中的元素标志位，由1开始
maxHeapCount 最大堆中元素的个数
******************/
void heapifyMaxHeap(int * maxHeap, const int pos, const int maxHeapCount);

/******************
对最大堆排序，使之由小到大有序

maxHeap:     最大堆数组
maxHeapCount 最大堆中元素的个数
******************/
void maxHeapSort(int * maxHeap, const int maxHeapCount);

/******************
根据指定的长度初始化输入的int数组
bigData：    输入的int数组
arrayLength: 数组长度
******************/
void initBigDataArray(int * bigData, const int arrayLength);

void main()
{
const int M = 1000;
const int K = 5;
int bigDataM[M];
int maxHeap[K];

initBigDataArray(bigDataM, M);
createMaxHeap(bigDataM, maxHeap, K);

for(int step = K; step < M; ++step)
{
if(bigDataM[step] < maxHeap[0])
{
maxHeap[0] = bigDataM[step];
heapifyMaxHeap(maxHeap, 1, K);
}
}

maxHeapSort(maxHeap, K);

cout<<"bigData array is: ";
for(int step = 0; step < M; ++step)
{
cout<<bigDataM[step]<<" ";
}
cout<<endl;

cout<<"Output maxHeap from less to larger: ";
for(int step = 0; step < K; ++step)
{
cout<<maxHeap[step]<<" ";
}
cout<<endl;

cout<<"Output maxHeap from larger to less: ";
for(int step = 0; step < K; ++step)
{
cout<<maxHeap[K - 1 - step]<<" ";
}
cout<<endl;

return;
}

void heapifyMaxHeap(int * maxHeap, const int pos, const int maxHeapCount)
{
int left = 2 * pos;
int right = 2 * pos + 1;
int largestElemPos = 0;
if(left <= maxHeapCount && maxHeap[left - 1] > maxHeap[pos - 1])
largestElemPos = left;
else
largestElemPos = pos;

if(right <= maxHeapCount && maxHeap[right - 1] > maxHeap[largestElemPos - 1])
largestElemPos = right;

if(largestElemPos != pos)
{
swap(maxHeap[pos - 1], maxHeap[largestElemPos - 1]);
heapifyMaxHeap(maxHeap, largestElemPos, maxHeapCount);
}

}

void createMaxHeap(const int * input, int * maxHeap, const int maxHeapCount)
{
for(int step = 0; step < maxHeapCount; ++step)
{
maxHeap[step] = input[step];
}

for(int startHeapifyPos = maxHeapCount/2; startHeapifyPos >= 1; --startHeapifyPos)
{
heapifyMaxHeap(maxHeap, startHeapifyPos, maxHeapCount);
}
}

void initBigDataArray(int * bigData, const int arrayLength)
{
for(int i = 0; i< arrayLength; ++i)
{
bigData[i] = rand();
}
}

void maxHeapSort(int * maxHeap, const int maxHeapCount)
{
int maxHeapSize = maxHeapCount;
for(int step = maxHeapSize; step >=2; --step)
{
swap(maxHeap[step - 1], maxHeap[0]);
maxHeapSize -=1;
heapifyMaxHeap(maxHeap, 1 , maxHeapSize);
}
}

如有任何错误或者不足，欢迎不吝指出。