[算法导论]第六章《堆排序》

本章开始介绍了堆的基本概念，然后引入最大堆和最小堆的概念。全章采用最大堆来介绍堆的操作，两个重要的操作是调整最大堆和创建最大堆，接着着两个操作引进了堆排序，最后介绍了采用堆实现优先级队列。

一.堆

　　（二叉）堆数据结构是一种数组对象，它可以被视为一棵完全二叉树。除了最底层外，该树是完全充满的，而且是从左到右填充的。树中每个节点与数组中的存放该节点值的那个元素对应。堆与完全二叉树的对应关系如下图所示：



　　表示堆的数组A包括两个属性： A.length是数组中的元素个数，A.heap-size是存放在中的堆的元素个数。通常给定节点i，可以根据其在数组中的位置求出该节点的父亲节点、左右孩子节点。输的根节点是A[1],对于一个给定结点的下标i，所有可到：



　　根据节点数值满足的条件，可以将分为最大堆和最小堆。最大堆的特性是：除了根节点以外的每个节点i，有A[PARENT(i)] >= A[i],最小堆的特性是：除了根节点以外的每个节点i，有A[PARENT(i)] >=A[i]。

　　把堆看成一个棵树，有如下的特性：

（1）含有n个元素的堆的高度是lgn。

（2）当用数组表示存储了n个元素的堆时，叶子节点的下标是n/2+1，n/2+2，……，n。

（3）在最大堆中，最大元素该子树的根上；在最小堆中，最小元素在该子树的根上。

二.维护堆的性质

　　堆的关键操作过程是如何维持堆的特有性质，给定一个节点i，要保证以i为根的子树满足堆性质。书中以最大堆作为例子进行讲解，并给出了递归形式的保持最大堆性的操作过程MAX-HEAPIFY。先从看一个例子，操作过程如下图所示：


从图中可以看出，在节点i=2时，不满足最大堆的要求，需要进行调整，选择节点2的左右孩子中最大一个进行交换，然后检查交换后的节点i=4是否满足最大堆的要求，从图看出不满足，接着进行调整，直到没有交换为止。书中给出了递归形式的伪代码：

MAX-HEAPIFY(A,i)
1     l = LEFT(i)
2     r = RIGHT(i)
3     if l<=A.heap-size and A[l] > A[i]
4             largest = l
5     else largest = i
6     if r <= A.heap-size and A[r] > A[largest]
7             largest = r
8    if largest != i
9             exchange A[i] with A[largest]
10           MAX-HEAPIFY(A, largest)

三.建堆

　　建立最大堆的过程是自底向上地调用最大堆调整程序将一个数组A[1.....N]变成一个最大堆。将数组视为一颗完全二叉树，从其最后一个非叶子节点（n/2）开始调整。调整过程如下图所示：



书中给出了创建堆的为代码

BUILD-MAX-HEAP(A)
1   A.heap-size = A.length
2   for i = A.length/2  downto 1
3   MAX-HEAPIFY(A, i)

四.堆排序算法

　　堆排序算法过程为：先调用创建堆函数将输入数组A[1...n]造成一个最大堆，使得最大的值存放在数组第一个位置A[1]，然后用数组最后一个位置元素与第一个位置进行交换，并将堆的大小减少1，并调用最大堆调整函数从第一个位置调整最大堆。给出堆数组A={4,1,3,16,9,10,14,8,7}进行堆排序简单的过程如下：

（1）创建最大堆，数组第一个元素最大，执行后结果下图：



（2）进行循环，从length(a)到2，并不断的调整最大堆，给出一个简单过程如下：



书中给出了对排序为代码

HEAPSORT(A)
1   BUILD-MAX-HEAP(A)
2   for i = A.length downto 2
3        exchange A[1] with A[i]
4        A.heap-size = A.heap-size-1
5       MAX-HEAPIFY(A, 1)

五.代码的C++实现

结合上面的调整堆和创建堆 的过程，写个简单测试程序连续堆排序，程序如下所示：

/*
*Created by RogerKing
*Email:jin_tengfei@163.com
*/

#include <iostream>
#include <stdlib.h>

using namespace std;
int heap_size,i;

int PARENT(int i)
{
return i/2;
}//查找堆中节点父母

int LEFT(int i)
{
return 2*i+1;
}//查找堆中节点左孩子(因为程序下标是从0开始的)

int RIGHT(int i)
{
return 2*i+2;
}//查找堆中节点右孩子

void Max_Heapify(int A[],int i,int n)
{
int l=LEFT(i);
int r=RIGHT(i);
int largest;
heap_size=n;

if( l<heap_size&&A[l]>A[i] )
largest=l;
else
largest=i;
if( r<heap_size&&A[r]>A[largest] )
largest=r;
if( largest!=i )
{
int tmp=A[largest];
A[largest]=A[i];
A[i]=tmp;
Max_Heapify(A,largest,heap_size);
}
}

void Bulid_Max_Heap(int A[],int n)
{
heap_size=n;
for( i=heap_size/2+1; i>=0; --i)
Max_Heapify(A,i,heap_size);
}

void HeapSort(int A[],int n)
{
heap_size=n;
Bulid_Max_Heap(A,heap_size);
int tmp;
for( i=heap_size-1 ; i>=1 ; --i  )
{
tmp=A[0];
A[0]=A[i];
A[i]=tmp;
Max_Heapify(A,0,--heap_size);
}

}

void display(int A[],int n)
{
for( i=0; i<n ; i++)
cout<<A[i]<<" ";
cout<<endl;
}
int main(int argc, char *argv[])
{
int A[100];
int n;
while (cin >> n)
{
for (int i = 0; i < n; i++)
cin >> A[i];
HeapSort (A, n);
display (A, n);
}
return 0;
}

堆排序算法时间复杂度：调整堆过程满足递归式T(n)<=T(2n/3)+θ(1)，有master定义可以知道T(n) = O(lgn)，堆排序过程中执行一个循环，调用最大堆调整函数，总的时间复杂度为O(nlgn）。