【摘】堆排序原理及分析
堆排序原理及分析
根结点(亦称为堆顶)的关键字是堆里所有结点关键字中最小者的堆称为小根堆,又称最小堆。
根结点(亦称为堆顶)的关键字是堆里所有结点关键字中最大者,称为大根堆,又称最大堆。
注意:①堆中任一子树亦是堆。②以上讨论的堆实际上是二叉堆(Binary Heap),类似地可定义k叉堆。
//lxl:假设数组的第一个元素为二叉树的根节点,则length/2-1为根节点的左子节点
for (int i = length / 2 - 1; i >= 0; --i) { HeapAdjust(array, i, length); } // 从最后一个元素开始对序列进行调整,不断的缩小调整的范围直到第一个元素
//lxl:
for (int i = length - 1; i > 0; --i) { // 把第一个元素和当前的最后一个元素交换, // 保证当前的最后一个位置的元素都是在现在的这个序列之中最大的
//lxl:
Swap(&array[0], &array); // 不断缩小调整heap的范围,每一次调整完毕保证第一个元素是当前序列的最大值
//lxl: HeapAdjust(array, 0, i); } } 堆排序算法(C++描述) #define MAX 100//数据元素的最大个数 typedef struct { int r[MAX]; int length; }SqList;//定义一个线性表用于存放数据元素 void HeapAdjust(SqList &L,int s,int m) {//已知L.r[s...m]中记录除L.r[s]外均满足堆的定义,本函数用于使L.r[s...m]成为一个大顶堆 int j; int e=L.r[s]; for(j=2*s;j<=m;j*=2) { if(j<M&&L.R[J]<L.R[J+1]) ++j; if(e>=L.r[j]) break; L.r[s]=L.r[j]; s=j; } L.r[s]=e; } void HeapSort(SqList &L) {//对顺序表L进行堆排序 int i,e; for(i=L.length/2;i>0;i--) HeapAdjust(L,i,L.length); for(i=L.length;i>1;i--) {//将大顶堆的顶记录和最后一个记录相互交换 e=L.r[1]; L.r[1]=L.r; L.r=e; HeapAdjust(L,1,i-1); } } 因为构造初始堆必须使用到调整堆的操作,先讨论Heapify的实现,再讨论如何构造初始堆(即BuildHeap的实现)Heapify函数思想方法 每趟排序开始前R[l..i]是以R[1]为根的堆,在R[1]与R交换后,新的无序区R[1..i-1]中只有R[1]的值发生了变化,故除R[1]可能违反堆性质外,其余任何结点为根的子树均是堆。因此,当被调整区间是R[low..high]时,只须调整以R[low]为根的树即可。 "筛选法"调整堆 R[low]的左、右子树(若存在)均已是堆,这两棵子树的根R[2low]和R[2low+1]分别是各自子树中关键字最大的结点。若R[low].key不小于这两个孩子结点的关键字,则R[low]未违反堆[性质,以R[low]为根的树已是堆,无须调整;否则必须将R[low]和它的两个孩子结点中关键字较大者进行交换,即R[low]与R[large](R[large].key=max(R[2low].key,R[2low+1].key))交换。交换后又可能使结点R[large]违反堆性质,同样由于该结点的两棵子树(若存在)仍然是堆,故可重复上述的调整过程,对以R[large]为根的树进行调整。此过程直至当前被调整的结点已满足性质,或者该结点已是叶子为止。上述过程就象过筛子一样,把较小的关键字逐层筛下去,而将较大的关键字逐层选上来。因此,有人将此方法称为"筛选法"。
本文摘自:http://bk.baidu.com/view/427107.htm
起源
1991年计算机先驱奖获得者、斯坦福大学计算机科学系教授罗伯特·弗洛伊德(Robert W.Floyd)和威廉姆斯(J.Williams)在1964年共同发明了著名的堆排序算法( Heap Sort )“堆”定义
n个关键字序列Kl,K2,…,Kn称为(Heap),当且仅当该序列满足如下性质(简称为堆性质): (1) ki≤K2i且ki≤K2i+1 或(2)Ki≥K2i且ki≥K2i+1(1≤i≤ n) //ki相当于二叉树的非叶结点,K2i则是左孩子,k2i+1是右孩子 若将此序列所存储的向量R[1..n]看做是一棵完全二叉树的存储结构,则堆实质上是满足如下性质的完全二叉树:树中任一非叶结点的关键字均不大于(或不小于)其左右孩子(若存在)结点的关键字。 (即如果按照线性存储该树,可得到一个不下降序列或不上升序列) 【例】关键字序列(10,15,56,25,30,70)和(70,56,30,25,15,10)分别满足堆性质(1)和(2),故它们均是堆,其对应的完全二叉树分别如小根堆示例和大根堆示例所示。 大根堆和小根堆:根结点(亦称为堆顶)的关键字是堆里所有结点关键字中最小者的堆称为小根堆,又称最小堆。
根结点(亦称为堆顶)的关键字是堆里所有结点关键字中最大者,称为大根堆,又称最大堆。
注意:①堆中任一子树亦是堆。②以上讨论的堆实际上是二叉堆(Binary Heap),类似地可定义k叉堆。
堆的高度
堆可以被看成是一棵树,结点在堆中的高度可以被定义为从本结点到叶子结点的最长简单下降路径上边的数目;定义堆的高度为树根的高度。我们将看到,堆结构上的一些基本操作的运行时间至多是与树的高度成正比,为O(lgn)。堆排序
堆排序利用了大根堆(或小根堆)堆顶记录的关键字最大(或最小)这一特征,使得在当前无序区中选取最大(或最小)关键字的记录变得简单。 (1)用大根堆排序的基本思想 ① 先将初始文件R[1..n]建成一个大根堆,此堆为初始的无序区 ② 再将关键字最大的记录R[1](即堆顶)和无序区的最后一个记录R[n]交换,由此得到新的无序区R[1..n-1]和有序区R[n],且满足R[1..n-1].keys≤R[n].key ③由于交换后新的根R[1]可能违反堆性质,故应将当前无序区R[1..n-1]调整为堆。然后再次将R[1..n-1]中关键字最大的记录R[1]和该区间的最后一个记录R[n-1]交换,由此得到新的无序区R[1..n-2]和有序区R[n-1..n],且仍满足关系R[1..n-2].keys≤R[n-1..n].keys,同样要将R[1..n-2]调整为堆。 …… 直到无序区只有一个元素为止。 (2)大根堆排序算法的基本操作: ① 初始化操作:将R[1..n]构造为初始堆; ② 每一趟排序的基本操作:将当前无序区的堆顶记录R[1]和该区间的最后一个记录交换,然后将新的无序区调整为堆(亦称重建堆)。 注意: ①只需做n-1趟排序,选出较大的n-1个关键字即可以使得文件递增有序。 ②用小根堆排序与利用大根堆类似,只不过其排序结果是递减有序的。堆排序和直接选择排序相反:在任何时刻堆排序中无序区总是在有序区之前,且有序区是在原向量的尾部由后往前逐步扩大至整个向量为止特点
堆排序(HeapSort)是一树形选择排序。堆排序的特点是:在排序过程中,将R[l..n]看成是一棵完全二叉树的顺序存储结构,利用完全二叉树中双亲结点和孩子结点之间的内在关系(参见二叉树的顺序存储结构),在当前无序区中选择关键字最大(或最小)的记录堆排序与直接选择排序的区别
直接选择排序中,为了从R[1..n]中选出关键字最小的记录,必须进行n-1次比较,然后在R[2..n]中选出关键字最小的记录,又需要做n-2次比较。事实上,后面的n-2次比较中,有许多比较可能在前面的n-1次比较中已经做过,但由于前一趟排序时未保留这些比较结果,所以后一趟排序时又重复执行了这些比较操作。 堆排序可通过树形结构保存部分比较结果,可减少比较次数。算法分析
堆[排序的时间,主要由建立初始]堆和反复重建堆这两部分的时间开销构成,它们均是通过调用Heapify实现的。 堆排序的最坏时间复杂度为O(nlog2n)。堆序的平均性能较接近于最坏性能。 由于建初始堆所需的比较次数较多,所以堆排序不适宜于记录数较少的文件。 堆排序是就地排序,辅助空间为O(1), 它是不稳定的排序方法。算法描述
堆排序算法(C描述)
// array是待调整的堆数组,i是待调整的数组元素的位置,length是数组的长度 void HeapAdjust(int array[], int i, int nLength)//本函数功能是:根据数组array构建大根堆 { int nChild; int nTemp; for (nTemp = array[i]; 2 * i + 1 < nLength; i = nChild) { // 子结点的位置=2*(父结点位置)+ 1 nChild = 2 * i + 1; // 得到子结点中较大的结点 if (nChild != nLength - 1 && array[nChild + 1] > array[nChild]) ++nChild; // 如果较大的子结点大于父结点那么把较大的子结点往上移动,替换它的父结点 if (nTemp < array[nChild]) { nTemp= array[nChild]; } else // 否则退出循环 { break; } } // 最后把需要调整的元素值放到合适的位置 array[nChild]= nTemp; } // 堆排序算法 void HeapSort(int array[], int length) { // 调整序列的前半部分元素,调整完之后第一个元素是序列的最大的元素//lxl:假设数组的第一个元素为二叉树的根节点,则length/2-1为根节点的左子节点
for (int i = length / 2 - 1; i >= 0; --i) { HeapAdjust(array, i, length); } // 从最后一个元素开始对序列进行调整,不断的缩小调整的范围直到第一个元素
//lxl:
for (int i = length - 1; i > 0; --i) { // 把第一个元素和当前的最后一个元素交换, // 保证当前的最后一个位置的元素都是在现在的这个序列之中最大的
//lxl:
Swap(&array[0], &array); // 不断缩小调整heap的范围,每一次调整完毕保证第一个元素是当前序列的最大值
//lxl: HeapAdjust(array, 0, i); } } 堆排序算法(C++描述) #define MAX 100//数据元素的最大个数 typedef struct { int r[MAX]; int length; }SqList;//定义一个线性表用于存放数据元素 void HeapAdjust(SqList &L,int s,int m) {//已知L.r[s...m]中记录除L.r[s]外均满足堆的定义,本函数用于使L.r[s...m]成为一个大顶堆 int j; int e=L.r[s]; for(j=2*s;j<=m;j*=2) { if(j<M&&L.R[J]<L.R[J+1]) ++j; if(e>=L.r[j]) break; L.r[s]=L.r[j]; s=j; } L.r[s]=e; } void HeapSort(SqList &L) {//对顺序表L进行堆排序 int i,e; for(i=L.length/2;i>0;i--) HeapAdjust(L,i,L.length); for(i=L.length;i>1;i--) {//将大顶堆的顶记录和最后一个记录相互交换 e=L.r[1]; L.r[1]=L.r; L.r=e; HeapAdjust(L,1,i-1); } } 因为构造初始堆必须使用到调整堆的操作,先讨论Heapify的实现,再讨论如何构造初始堆(即BuildHeap的实现)Heapify函数思想方法 每趟排序开始前R[l..i]是以R[1]为根的堆,在R[1]与R交换后,新的无序区R[1..i-1]中只有R[1]的值发生了变化,故除R[1]可能违反堆性质外,其余任何结点为根的子树均是堆。因此,当被调整区间是R[low..high]时,只须调整以R[low]为根的树即可。 "筛选法"调整堆 R[low]的左、右子树(若存在)均已是堆,这两棵子树的根R[2low]和R[2low+1]分别是各自子树中关键字最大的结点。若R[low].key不小于这两个孩子结点的关键字,则R[low]未违反堆[性质,以R[low]为根的树已是堆,无须调整;否则必须将R[low]和它的两个孩子结点中关键字较大者进行交换,即R[low]与R[large](R[large].key=max(R[2low].key,R[2low+1].key))交换。交换后又可能使结点R[large]违反堆性质,同样由于该结点的两棵子树(若存在)仍然是堆,故可重复上述的调整过程,对以R[large]为根的树进行调整。此过程直至当前被调整的结点已满足性质,或者该结点已是叶子为止。上述过程就象过筛子一样,把较小的关键字逐层筛下去,而将较大的关键字逐层选上来。因此,有人将此方法称为"筛选法"。
BuildHeap的实现
要将初始文件R[l..n]调整为一个大根堆,就必须将它所对应的完全二叉树中以每一结点为根的子树都调整为堆。 显然只有一个结点的树是堆,而在完全二叉树中,所有序号大于n/2的结点都是叶子,因此以这些结点为根的子树均已是堆。这样,我们只需依次将以序号为n/2,…,1的结点作为根的子树都调整为堆即可。Heapify函数算法实例
#include #include inline int LEFT(int i); inline int RIGHT(int i); inline int PARENT(int i); void MAX_HEAPIFY(int A[],int heap_size,int i); void BUILD_MAX_HEAP(int A[],int heap_size); void HEAPSORT(int A[],int heap_size); void output(int A[],int size); int main() { FILE *fin; int m,size,i; fin = fopen("array.in","r"); int* a; fscanf(fin," %d",&size); a = (int *)malloc(size + 1); a[0]=size; for(i = 1;i <= size; i++ ) { fscanf(fin," %d",&m); a= m; } HEAPSORT(a,a[0]); printf("$$$$$$$$$$The Result$$$$$$$$\n"); output(a,a[0]); free(a); return 0; } inline int LEFT(int i) { return 2 * i; } inline int RIGHT(int i) { return 2 * i + 1; } inline int PARENT(int i) { return i / 2; } void MAX_HEAPIFY(int A[],int heap_size,int i) { int temp,largest,l,r; largest = i; l = LEFT(i); r = RIGHT(i); if ((l <= heap_size) && (A[l] > A[largest])) largest = l; if ((r<= heap_size) && (A[r] > A[largest])) largest = r; if (largest != i) { temp = A[largest]; A[largest] = A; A= temp; MAX_HEAPIFY(A[],heap_size,largest); } } void BUILD_MAX_HEAP(int A[],int heap_size) { int i; for (i = heap_size / 2;i >= 1;i--) MAX_HEAPIFY(A,heap_size,i); } void HEAPSORT(int A[],int heap_size) { int i; BUILD_MAX_HEAP(A,heap_size); for (i = heap_size;i >= 2; i--) { int temp; temp = A[1]; A[1] = A; A= temp; MAX_HEAPIFY(A,i-1,1); } } void output(int A[],int size) { int i = 1; FILE *out = fopen("result.in","w+"); for (; i <= size; i++) { printf("%d ",A); fprintf(out,"%d ",A); } printf("\n"); }C#描述
#region 堆 /// 建成大堆 void HeapAdjust(int[] arr, int i, int length) { int child = 2 * i + 1; //左节点 int temp = arr[i]; //中间变量保存当前根节点 while (child < length) { //如果有右节点,判断是否大于左节点 if (child < length - 1 && arr[child] < arr[child + 1]) child++; //双亲节点大于子节点 if (temp >= arr[child]) break; //不需调整,结束调整 arr[i] = arr[child]; //双亲结点值设置为大的子节点值 i = child; child = 2 * i + 1; } arr[i] = temp; } public void Heap(int[] arr) { //第一次创建大堆 for (int i = arr.Length / 2 - 1; i >= 0; i--) { HeapAdjust(arr, i, arr.Length); } //元素位置调换 for (int i = arr.Length - 1; i > 0; i--) { //堆顶与当前堆的最后一个堆元素交换位置 int tmp = arr[0]; arr[0] = arr[i]; arr[i] = tmp; //将剩下的无序堆部分重新建堆处理 HeapAdjust(arr, 0, i); foreach (int v in arr) { Console.Write(v.ToString() + " "); } Console.WriteLine(""); } } #endregion堆排序的JAVA实现
public class Test { public static int[] Heap = { 10, 32, 1, 9, 5, 7, 12, 0, 4, 3 }; // 预设数据数组 public static void main(String args[]) { int i; // 循环计数变量 int Index = Heap.length; // 数据索引变量 System.out.print("排序前: "); for (i = 1; i < Index - 1; i++) System.out.printf("%3s", Heap); System.out.println(""); HeapSort(Index - 2); // 堆排序 System.out.print("排序后: "); for (i = 1; i < Index - 1; i++) System.out.printf("%3s", Heap); System.out.println(""); } /** * 建立堆 */ public static void CreateHeap(int Root, int Index) { int i, j; // 循环计数变量 int Temp; // 暂存变量 int Finish; // 判断堆是否建立完成 j = 2 * Root; // 子节点的Index Temp = Heap[Root]; // 暂存Heap的Root 值 Finish = 0; // 预设堆建立尚未完成 while (j <= Index && Finish == 0) { if (j < Index) // 找最大的子节点 if (Heap[j] < Heap[j + 1]) j++; if (Temp >= Heap[j]) Finish = 1; // 堆建立完成 else { Heap[j / 2] = Heap[j]; // 父节点 = 目前节点 j = 2 * j; } } Heap[j / 2] = Temp; // 父节点 = Root值 } public static void HeapSort(int Index) { int i, j, Temp; // 将二叉树转成Heap for (i = (Index / 2); i >= 1; i--) CreateHeap(i, Index); // 开始进行堆排序 for (i = Index - 1; i >= 1; i--) { Temp = Heap; // Heap的Root值和最后一个值交换 Heap = Heap[1]; Heap[1] = Temp; CreateHeap(1, i); // 对其余数值重建堆 System.out.print("排序中: "); for (j = 1; j <= Index; j++) System.out.printf("%3s",Heap[j]); System.out.println(""); } } }本文摘自:http://bk.baidu.com/view/427107.htm
posted on 2010-08-10 10:35 LeeXiaoLiang 阅读(492) 评论(0) 编辑 收藏 举报