【算法导论 第6章 堆排序】

一、“堆”定义　　

n个关键字序列Kl，K2，…，Kn称为(Heap)，当且仅当该序列满足如下性质(简称为堆性质)：

　　(1)ki<=k(2i)且ki<=k(2i+1)(1≤i≤ n),当然，这是小根堆，大根堆则换成>=号。 //k(i)相当于二叉树的非叶结点，K(2i)则是左孩子，k(2i+1)是右孩子

　　若将此序列所存储的向量R[1..n]看做是一棵 完全二叉树的存储结构，则堆实质上是满足如下性质的完全二叉树：

　　 树中任一非叶结点的关键字均不大于(或不小于)其左右孩子(若存在)结点的关键字。

　　【例】关键字序列(10，15，56，25，30，70)和(70，56，30，25，15，10)分别满足堆性质(1)和(2)，故它们均是堆，其对应的完全二叉树分别如小根堆示例和大根堆示例所示。

　　
大根堆和小根堆：根结点(亦称为堆顶)的关键字是堆里所有结点关键字中最小者的堆称为小根堆，又称最小堆。根结点(亦称为堆顶)的关键字是堆里所有结点关键字中最大者，称为大根堆，又称最大堆。注意：①堆中任一子树亦是堆。②以上讨论的堆实际上是二叉堆(Binary Heap)，类似地可定义k叉堆

二、堆的高度

　　堆可以被看成是一棵树，结点在堆中的高度可以被定义为从本结点到叶子结点的最长简单下降路径上边的数目；定义堆的高度为树根的高度。我们将看到，堆结构上的一些基本操作的运行时间至多是与树的高度成正比，为O（lgn）。

三、堆排序

1. 堆排序分为以下几个过程

AdjustMaxHeap调整堆的过程，始终要保持堆的性质。

BulidMaxHeap建立堆的过程，按照堆的性质进行建立

MaxHeapSort堆排序过程，调用上面两个过程，将一组无序的数据转换为有序的。

2. 调整最大堆的过程，如何保持最大堆的性质。伪代码描述如下：

   

第10步是必须的，因为下标为largest的节点在交换后值是A[i]，以该节点为根的子树有可能违反最大堆的性质。

书中举例子说明如何调整，保持最大堆的性质。

3. 建堆，采用了自底向上的方法。从最后一个根节点开始向上进行建堆，这样才能保证每一步满足最大堆的性质。最后一个根节点对应的父节点是length(A)/2，从length（A）/2开始到根节点1或者是0（C++语言数组下标从0开始）结束。伪代码描述如下：

例子如下所示：

 

4.  用AdjustMaxHeap和 BulidMaxHeap进行堆排序。根据最大堆的性质，根的值是最大，每次可以确定根值的位置，然后将数组的长度减 1，从新调整堆，重复操作，直到树中只有一个节点。伪代码描述如下：

书上给了一个关于最大堆排序过程：

四、堆排序代码（c/c++）

#include <iostream>
using namespace std;
 
// 输出当前堆的排序状况
void PrintArray(int data[], int size)
{
    for (int i=1; i<=size; ++i)
        cout <<data[i]<<"  ";
    cout<<endl;
}
 
// 堆化，保持堆的性质
// 从元素a[i],a[lt],a[rt]中找出最大的，并将其下标保存在largest中。
// 如果a[i]是最大的，则以i为根的子树成已为最大堆，程序结束。
// 否则，i的某个子节点中有最大元素，则交换a[i]，a[largest]从而使i及其子女满足堆性质。
// 下标为largest的结点在交换后的值为a[i],以该结点为根的子树又有可能违反最大堆性质。因而要对该子树递归调用MaxHeapify。
void MaxHeapify(int *a, int i, int size)
{
 int lt = 2*i, rt = 2*i+1;
 int largest;
 if(lt <= size && a[lt] > a[i])
  largest = lt;
 else
  largest = i;
 if(rt <= size && a[rt] > a[largest])
  largest = rt;
 if(largest != i)
 {
  int temp = a[i];
  a[i] = a[largest];
  a[largest] = temp;
  MaxHeapify(a, largest, size);
 }
}
 
// 建堆
// 自底而上地调用MaxHeapify来将一个数组a[1..size]变成一个最大堆
// 注意： [size/2]以后的结点为叶子结点，即已经满足堆的性质
void BuildMaxHeap(int *a, int size)
{
 for(int i=size/2; i>=1; --i)
  MaxHeapify(a, i, size);
}
 
// 堆排序
// 初始调用BuildMaxHeap将a[1..size]变成最大堆
// 因为数组最大元素在a[1]，则可以通过将a[1]与a[size]互换达到正确位置
// 现在新的根元素破坏了最大堆的性质，所以调用MaxHeapify调整，
// 使a[1..size-1]成为最大堆，a[1]又是a[1..size-1]中的最大元素，
// 将a[1]与a[size-1]互换达到正确位置。
// 反复调用Heapify，使整个数组成从小到大排序。
// 注意： 交换只是破坏了以a[1]为根的二叉树最大堆性质，它的左右子二叉树还是具备最大堆性质。
//        这也是为何在BuildMaxHeap时需要遍历size/2到1的结点才能构成最大堆，而这里只需要堆化a[1]即可。
void HeapSort(int *a, int size)
{
 BuildMaxHeap(a, size);
 cout << "此数组对应的最大堆：";
 PrintArray(a, size);
 
 int len = size;
 for(int i=size; i>=2; --i)
 {
  int temp = a[1];
  a[1] = a[i];
  a[i] = temp;
  len--;
  MaxHeapify(a, 1, len);
  cout << "中间过程:";
  PrintArray(a, size);
 }
 
}

// 主函数
void main()
{
 int size;
 int arr[100];
 cout << "Input the num of elements: ";
 cin >> size;
 cout << "Input the elements: ";
 for(int i=1; i<=size; ++i)
  cin >> arr[i];
 cout << endl;
    HeapSort(arr, size);
 cout << "最后结果:";
    PrintArray(arr, size);
}

运行结果：

Input the num of elements: 5
Input the elements: 8 6 4 1 10

此数组对应的最大堆：10  8  4  1  6
中间过程:8  6  4  1  10
中间过程:6  1  4  8  10
中间过程:4  1  6  8  10
中间过程:1  4  6  8  10
最后结果:1  4  6  8  10
Press any key to continue

五、堆的应用举例

从n个数中找出最小的k个数。

#include <iostream>
using namespace std;
 
// 输出当前堆的排序状况
void PrintArray(int data[], int size)
{
    for (int i=1; i<=size; ++i)
        cout <<data[i]<<"  ";
    cout<<endl;
}
 
// 堆化，保持堆的性质
// 从元素a[i],a[lt],a[rt]中找出最大的，并将其下标保存在largest中。
// 如果a[i]是最大的，则以i为根的子树成已为最大堆，程序结束。
// 否则，i的某个子节点中有最大元素，则交换a[i]，a[largest]从而使i及其子女满足堆性质。
// 下标为largest的结点在交换后的值为a[i],以该结点为根的子树又有可能违反最大堆性质。因而要对该子树递归调用MaxHeapify。
void MaxHeapify(int *a, int i, int size)
{
 int lt = 2*i, rt = 2*i+1;
 int largest;
 if(lt <= size && a[lt] > a[i])
  largest = lt;
 else
  largest = i;
 if(rt <= size && a[rt] > a[largest])
  largest = rt;
 if(largest != i)
 {
  int temp = a[i];
  a[i] = a[largest];
  a[largest] = temp;
  MaxHeapify(a, largest, size);
 }
}
 
// 建堆
// 自底而上地调用MaxHeapify来将一个数组a[1..size]变成一个最大堆
// 注意： [size/2]以后的结点为叶子结点，即已经满足堆的性质
void BuildMaxHeap(int *a, int size)
{
 for(int i=size/2; i>=1; --i)
  MaxHeapify(a, i, size);
}
 
// 堆排序
// 初始调用BuildMaxHeap将a[1..size]变成最大堆
// 因为数组最大元素在a[1]，则可以通过将a[1]与a[size]互换达到正确位置
// 现在新的根元素破坏了最大堆的性质，所以调用MaxHeapify调整，
// 使a[1..size-1]成为最大堆，a[1]又是a[1..size-1]中的最大元素，
// 将a[1]与a[size-1]互换达到正确位置。
// 反复调用Heapify，使整个数组成从小到大排序。
// 注意： 交换只是破坏了以a[1]为根的二叉树最大堆性质，它的左右子二叉树还是具备最大堆性质。
//        这也是为何在BuildMaxHeap时需要遍历size/2到1的结点才能构成最大堆，而这里只需要堆化a[1]即可。
void HeapSort(int *a, int size)
{
 BuildMaxHeap(a, size);
 cout << "此数组对应的最大堆：";
 PrintArray(a, size);
 
 int len = size;
 for(int i=size; i>=2; --i)
 {
  int temp = a[1];
  a[1] = a[i];
  a[i] = temp;
  len--;
  MaxHeapify(a, 1, len);
  cout << "中间过程:";
  PrintArray(a, size);
 }
 
}

// 主函数
void main()
{
	int size;
	int k;
	int arr[100];
	cout << "Input the num of elements: n=";
	cin >> size;
	cout << "Input the elements: ";
	for(int i=1; i<=size; ++i)
	   cin >> arr[i];
	cout << "Input k: ";
		cin >> k;
	// 建立拥有k个元素的最大堆
	BuildMaxHeap(arr, k);
	
	for (i=k+1; i<=size; i++)
	{
		// 从第k+1个元素开始，与堆顶即堆中最大元素比较
		// 如果比堆顶小，则将其值赋给堆顶，再对堆进行调整，使其仍是最大堆
		if (arr[i] < arr[1])
		{
			arr[1]=arr[i];
			MaxHeapify(arr, 1, k);
		}
	}
	cout << "最后结果:";
    PrintArray(arr, k);
}

运行结果：

Input the num of elements: n=10
Input the elements: 20 1 8 5 9 4 2 15 13 19
Input k: 4
最后结果:5  2  4  1
Press any key to continue