《算法导论》学习摘要chapter-6——堆排序

       本章堆排序内容是《算法导论》教材第二部分《排序与顺序统计量》的第一讲。

       堆排序,这是一种O(nlgn)时间的原址排序算法。它使用了一种被称为堆的数据结构,堆还可以用来实现优先级队列。

1、堆的概念

        数组R[1...n]中,n个关键字序列k1,k2,…,kn,当且仅当该序列满足如下性质(简称为堆性质,以大根堆为例):

  • ki >= k(2i)且ki >= k(2i+1)(1≤i≤ n/2)大根堆则换成>=号。相当于完全二叉树的非叶子结点,K(2i)则是左子节点,k(2i+1)是右子节点
         若将此序列所存储的向量R[1..n]看做是一棵完全二叉树的存储结构,则堆实质上是满足如下性质的完全二叉树:树中任一非叶子结点的关键字均不大于(或不小于)其左右孩子(若存在)结点的关键字。

       二叉堆是一个数组,它可以被看成是一个近似的完全二叉树。树上的每一个结点对应数组中的一个元素。除了最底层外,该树是完全充满的,而且是从左到右填充。表示堆的数组A包括两个属性:A.length表示数组元素的个数;A.heap_size表示数组A有具有堆结构的元素个数。有:0=<A.heap_size=<A.length。A[1]是树的根节点。

        通常给定节点i,我们很容易得到可以根据其在数组中的位置求出该节点的父亲节点、左右孩子节点:

  • PARENT(i) = i/2              //对位置i整除2即可得到当前结点的父结点
  • LEFT(i)  = 2*i                 //对位置i乘2即可得到当期结点的左子结点
  • RIGHT(i) = 2*i+1。      //对位置i乘2再加1,即可得到当期结点的右子结点
         在堆排序好的实现中,这三个函数通常以“宏”或者“内联函数”的方式来实现,比如:
#define PARENT(i)  i/2
#define LEFT(i)    i*2
#define RIGHT(i)   i*2+1
                                      
                                 
                                                   图1  a)二叉树,每个结点圆圈内部的数字是它所存储的数据           b)数组形式展现的一个最大堆。

          根据节点数值满足的条件,可以将分为最大堆和最小堆,最大堆和最小堆除了需要满足堆的性质外还要满足:

    1. 最大堆的特性是:除了根节点以外的每个节点i,有A[PARENT(i)] >= A[i];
    2. 最小堆的特性是:除了根节点以外的每个节点i,有A[PARENT(i)] >=A[i]。
        在堆排序算法中,我们优先选择最大堆。最小堆通常用于构造优先队列。
  把堆看成一个棵树,有如下的特性:

  1. 含有n个元素的堆的高度是lgn;
  2. 堆结构上的基本操作的运行时间与树高成正比,即时间复杂度为:O(nlgn);
  3. 当用数组表示存储了n个元素的堆时,最后一个非叶子节点是:n/2;叶子节点的下标是:n/2+1,n/2+2,……,n;
  4. 在最大堆中,最大元素该子树的根上;在最小堆中,最小元素在该子树的根上。

2、维护堆的性质

        这里讲的维护堆的性质,主要是指维护堆当前节点的值都要大于左子节点值和右子节点值。当堆中数据变动时,通过维护函数能够调整树的结构中元素的位置,以使数组还能继续满足堆的性质。

       这里我们构造一个函数:max_heapify()用来维护最大堆性质的重要过程。在调用max_heapify()的时候,我们假定根节点为LEFT(i)和RIGHT(i)的二叉树都是最大堆。max_heapify()就是通过让A[i]的值在最大值中“下沉”,从而使得以下标i为根节点的子树重新满足最大堆的性质。

                                   

                                                                                     图 2 max_heapify()函数调整i=2位置元素的执行过程


         从上图中可以看出,A[2]违背了最大堆的性质,因为它的值不大于它的孩子,所以需要进行调整。根据教材中max_heapify()的伪代码的代码结构,我进行了C++实现的递归实现,函数max_heapify()的返回值为void:

//维护堆的性质:即使得结点i出左右子树的值小于该节点的值
void max_heapify(int *arr, int length, int i)
{
	int left, right, largest;
	int temp;
	left = LEFT(i);
	right = RIGHT(i);

	if (left <= length && arr[left] > arr[i])
		largest = left;
	else
		largest = i;
	if (right <= length && arr[right] > arr[largest])
		largest = right;
	if (i != largest)
	{
		temp = arr[i];
		arr[i] = arr[largest];
		arr[largest] = temp;

		max_heapify(arr, length, largest);
	}
}
         max_heapify()函数的时间代价包括:

  1. 调整A[LEFT(i)]和A[RIGHT(i)]的关系的时间代价:O(1);
  2. 一课棵以i为根节点的子树上运行max_heapify()的时间代价。
       对一个树高为h的结点而言,max_heapify()函数的时间复杂度为:O(h)

3、建堆

        建堆主要是利用自底向上的方法利用max_heapify()把一个大小为n=A.length的数组A[1.....n ]转换为最大堆。对于叶子节点可以看成是只包含一个元素的堆。
        建堆伪代码:
build_max_heap(A)
1    A.heap_size=A.length
2    for i = A.length/2  downto 1
3         max_heapify(A,i)
        C++代码实现:
//创建堆
void build_max_heap(int *arr, int length)
{
	int i;
	for (i = length / 2; i > 0; i--)
	{
		max_heapify(arr, length, i);
	}
}
         证明build_max_heap()的正确性:

初始化:第一次迭代时:i=length/2,其他节点length/2 +1,length/2 +2,......n都是叶结点。因此节点i=1,......length/2,都是平凡最大堆的根节点。

保持:在for循环中,i的值依次递减,依次建立节点length/2-1,...... ,1的堆结构。

终止:当i=0时,退出for循环。

       每次调用max_heapify()的时间复杂度是O(lgn),build_max_heap()需要O(n)次这样的调用。因此build_max_heap()总的时间复杂度是:O(nlgn)。
下图是创建堆的过程图:
                        
                                                                                            图3 build_max_heap()操作示意图

4、堆排序算法

 在掌握了max_heapify()函数和build_max_heap()函数的功能后,已经具备了掌握堆排序算法的基础。
 堆排序算法过程:
  1. 利用build_max_heap()将数组A[,1......n]建成最大堆,其中n=A.length;
  2. 交换A[1]和A[length]的值,使最大元素在堆的最后位置;
  3. heap_size = heap_size - 1;  //使堆元素个数减1,即排除最大位置元素到堆外;
  4. 调用max_heapify()调整数组A[,1.....heap_size]的结构使之构成新的结构;
  5. 重复执行步骤2,——步骤4,知道i=1为止。
伪代码:
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++代码实现:
//堆排序
void heap_sort(int *arr, int length)
{
	int i, temp;
	build_max_heap(arr, length);
	i = length;

	while (i > 1)
	{
		temp = arr[i];
		arr[i] = arr[1];
		arr[1] = temp;
		i--;

		max_heapify(arr, i, 1);
	}
}
下图显示了HEAPSORT(A)伪代码第2~第5行for循环第一次迭代开始前最大堆的情况和每一次迭代后最大堆的情况:
                           《算法导论》学习摘要chapter-6——堆排序_第1张图片
                                                                                              图4  HEAPSOER的运行过程



5、一个简单的例子

        依据本章的知识点,编写的堆排序例子:

#include <iostream>
using namespace std;

#define PARENT(i)  i/2
#define LEFT(i)    i*2
#define RIGHT(i)   i*2+1

//维护堆的性质:即使得结点i出左右子树的值小于该节点的值
void max_heapify(int *arr, int length, int i)
{
	int left, right, largest;
	int temp;
	left = LEFT(i);
	right = RIGHT(i);

	if (left <= length && arr[left] > arr[i])
		largest = left;
	else
		largest = i;
	if (right <= length && arr[right] > arr[largest])
		largest = right;
	if (i != largest)
	{
		temp = arr[i];
		arr[i] = arr[largest];
		arr[largest] = temp;

		max_heapify(arr, length, largest);
	}
}

//创建堆
void build_max_heap(int *arr, int length)
{
	int i;
	for (i = length / 2; i > 0; i--)
	{
		max_heapify(arr, length, i);
	}
}

//堆排序
void heap_sort(int *arr, int length)
{
	int i, temp;
	build_max_heap(arr, length);
	i = length;

	while (i > 1)
	{
		temp = arr[i];
		arr[i] = arr[1];
		arr[1] = temp;
		i--;

		max_heapify(arr, i, 1);
	}
}

int main()
{
	int arr[11] = {NULL, 13, 45, 32, 5, 21, 0, 23, 78, 90, 12};
	cout << "----------------堆排序--------------------" << endl;
	cout << "排序前:";
	for (int i = 1; i < 11; i++)
		cout << arr[i] << "  ";
	cout << endl;
	
	heap_sort(arr, 10);

	cout << "排序后:";
	for (int i = 1; i < 11; i++)
		cout << arr[i] << "  ";
	cout << endl;

	system("pause");
	return 0;
}
程序运行结果:


你可能感兴趣的:(《算法导论》学习摘要chapter-6——堆排序)