算法之堆排序
2014-03-13 22:44
148 查看
前序:
(二叉)堆数据结构是一种数组对象,它可以被视为一棵完全二叉树。树中每个节点与数组中存放该节点值的那个元素对应。
树的每一层都是填满的,最后一层除外。
树的根为a[1] (在这里是从1开始的,也可以从0开始),给定了某个节点的下标i,其父节点为i/2,左二子为2*i,右儿子为2*i+1。
二叉堆满足二个特性:
1.父结点的键值总是大于或等于(小于或等于)任何一个子节点的键值。
2.每个结点的左子树和右子树都是一个二叉堆(最大堆或最小堆)。
当父结点的键值总是大于或等于任何一个子节点的键值时为最大堆。
当父结点的键值总是小于或等于任何一个子节点的键值时为最小堆。
保持堆的性质:
MaxHeap是对最大堆进行操作的最重要的子程序。
以i为根的子树:
在算法每一步中,从a[i], a[Left(i)], a[Right(i)]找出最大值,并将其下标存在LargestIndex中。如果a[i]是最大的,则以i为根的子树已是最大堆,程序结束。
否则i的某个子结点中有最大元素则交换a[i],a[LargetIndex],从而使i及子女满足堆性质。下标为LargestIndex的结点在交换后的值为a[i],以该结点为根的子树又有可能违反最大堆的性质,因而又要对该子树递归调用MaxHeap,重新使子树平衡。
[cpp]
view plaincopy
//调整以index为根的子树
//n:堆中元素个数
int MaxHeap(int a[],int index,int n){
int LargestIndex = index;
//左子节点
int LeftIndex = 2*index;
//右子节点
int RightIndex = 2*index+1;
if(LeftIndex <= n && a[LeftIndex] > a[LargestIndex]){
LargestIndex = LeftIndex;
}
if(RightIndex <= n && a[RightIndex] > a[LargestIndex]){
LargestIndex = RightIndex;
}
//如果a[index]是最大的,则以index为根的子树已是最大堆否则index的子节点有最大元素
//则交换a[index],a[LargetIndex],从而使index及子女满足堆性质
int temp;
if(LargestIndex != index){
//交换a[index],a[LargetIndex]
temp = a[index];
a[index] = a[LargestIndex];
a[LargestIndex] = temp;
//重新调整以LargestIndex为根的子树
MaxHeap(a,LargestIndex,n);
}
return 0;
}
建堆:
我们可以自底向上的用MaxHeap来将一个数组a[1-n]变成一个最大堆,子数组a[n/2+1,........n]中的元素是树中的叶子,因此每个都可以看做只含一个元素的堆,满足最大堆的要求,不用调整。所以只需调整以a[n/2........1]中元素为根的子树使之成为最大堆。
[cpp]
view plaincopy
//建堆:将一个数组a[1-n]变成一个最大堆
int BuildMaxHeap(int a[],int n){
int i;
//子数组a[(n/2+1,n/2+2......n)]中的元素都是树中的叶子
for(i = n/2;i >= 1;i--){
//调整以i为根节点的树使之成为最大堆
MaxHeap(a,i,n);
}
return 0;
}
a数组
初始堆:
自底向上从最后一个非叶节点开始调整:
(a) (b) (c)
(d)
每次调整都是从父节点、左孩子节点、右孩子节点三者中选择最大者跟父节点进行交换(交换之后可能造成被交换的孩子节点不满足堆的性质,因此每次交换之后要重新对被交换的孩子节点进行调整)。
堆排序:
开始时,堆排序先用BuildMaxHeap将输入数组a[1-n]构造成一个最大堆。又因为数组中最大元素在根a[1],则可以通过它与a
交换来达到最终的正确位置。
现在,如果从堆中”去掉“结点n(不是真的删除,而是通过修改堆的元素个数n),可以很容易的将a[1-(n-1)]建成最大堆。原来根的子女依旧是最大堆,二新交换的根元素很有可能违背最大堆的性质。这时调用MaxHeap重新调整一下。在a[1-(n-1)]中构造出最大堆。堆排序不断重复这一过程,堆的大小由n-1一直降到2.从而完成排序的功能
[cpp]
view plaincopy
//堆排序
int HeapSort(int a[],int n){
int temp;
//BulidMaxHeap将输入数组构造一个最大堆
BuildMaxHeap(a,n);
//数组中最大元素在根a[1],则可以通过它与a
交换来达到最终的正确位置
for(int i = n;i >= 2;i--){
//交换
temp = a[i];
a[i] = a[1];
a[1] = temp;
//a[i]已达到正确位置,从堆中去掉
n--;
//重新调整,保持最大堆的性质
MaxHeap(a,1,n);
}
return 0;
}
(a) (b) (c)
(d)
(e) (f) (g)
(h) (i) (j)
(k)
红色为排序后的结果;
代码:
[cpp]
view plaincopy
#include<stdio.h>
#include<stdlib.h>
//调整堆
int MaxHeap(int a[],int index,int n){
int LargestIndex = index;
//左子节点
int LeftIndex = 2*index;
//右子节点
int RightIndex = 2*index+1;
if(LeftIndex <= n && a[LeftIndex] > a[LargestIndex]){
LargestIndex = LeftIndex;
}
if(RightIndex <= n && a[RightIndex] > a[LargestIndex]){
LargestIndex = RightIndex;
}
//如果a[index]是最大的,则以index为根的子树已是最大堆否则index的子节点有最大元素
//则交换a[index],a[LargetIndex],从而使index及子女满足堆性质
int temp;
if(LargestIndex != index){
//交换a[index],a[LargetIndex]
temp = a[index];
a[index] = a[LargestIndex];
a[LargestIndex] = temp;
//重新调整以LargestIndex为根的子树
MaxHeap(a,LargestIndex,n);
}
return 0;
}
//建堆:将一个数组a[1-n]变成一个最大堆
int BuildMaxHeap(int a[],int n){
int i;
//子数组a[(n/2+1,n/2+2......n)]中的元素都是树中的叶子
for(i = n/2;i >= 1;i--){
//调整以i为根节点的树使之成为最大堆
MaxHeap(a,i,n);
}
return 0;
}
//堆排序
int HeapSort(int a[],int n){
int temp;
//BulidMaxHeap将输入数组构造一个最大堆
BuildMaxHeap(a,n);
//数组中最大元素在根a[1],则可以通过它与a
交换来达到最终的正确位置
for(int i = n;i >= 2;i--){
//交换
temp = a[i];
a[i] = a[1];
a[1] = temp;
//a[i]已达到正确位置,从堆中去掉
n--;
//重新调整,保持最大堆的性质
MaxHeap(a,1,n);
}
return 0;
}
int main(){
int n = 6;
//a[0]不用,堆的根结点是从1开始的
int a[] = {0,3,17,8,7,16,20};
HeapSort(a,n);
for(int i = 1;i <= n;i++){
printf("%d ",a[i]);
}
return 0;
}
Forward from http://blog.csdn.net/sjf0115/article/details/8610201
(二叉)堆数据结构是一种数组对象,它可以被视为一棵完全二叉树。树中每个节点与数组中存放该节点值的那个元素对应。
树的每一层都是填满的,最后一层除外。
树的根为a[1] (在这里是从1开始的,也可以从0开始),给定了某个节点的下标i,其父节点为i/2,左二子为2*i,右儿子为2*i+1。
二叉堆满足二个特性:
1.父结点的键值总是大于或等于(小于或等于)任何一个子节点的键值。
2.每个结点的左子树和右子树都是一个二叉堆(最大堆或最小堆)。
当父结点的键值总是大于或等于任何一个子节点的键值时为最大堆。
当父结点的键值总是小于或等于任何一个子节点的键值时为最小堆。
保持堆的性质:
MaxHeap是对最大堆进行操作的最重要的子程序。
以i为根的子树:
在算法每一步中,从a[i], a[Left(i)], a[Right(i)]找出最大值,并将其下标存在LargestIndex中。如果a[i]是最大的,则以i为根的子树已是最大堆,程序结束。
否则i的某个子结点中有最大元素则交换a[i],a[LargetIndex],从而使i及子女满足堆性质。下标为LargestIndex的结点在交换后的值为a[i],以该结点为根的子树又有可能违反最大堆的性质,因而又要对该子树递归调用MaxHeap,重新使子树平衡。
[cpp]
view plaincopy
//调整以index为根的子树
//n:堆中元素个数
int MaxHeap(int a[],int index,int n){
int LargestIndex = index;
//左子节点
int LeftIndex = 2*index;
//右子节点
int RightIndex = 2*index+1;
if(LeftIndex <= n && a[LeftIndex] > a[LargestIndex]){
LargestIndex = LeftIndex;
}
if(RightIndex <= n && a[RightIndex] > a[LargestIndex]){
LargestIndex = RightIndex;
}
//如果a[index]是最大的,则以index为根的子树已是最大堆否则index的子节点有最大元素
//则交换a[index],a[LargetIndex],从而使index及子女满足堆性质
int temp;
if(LargestIndex != index){
//交换a[index],a[LargetIndex]
temp = a[index];
a[index] = a[LargestIndex];
a[LargestIndex] = temp;
//重新调整以LargestIndex为根的子树
MaxHeap(a,LargestIndex,n);
}
return 0;
}
建堆:
我们可以自底向上的用MaxHeap来将一个数组a[1-n]变成一个最大堆,子数组a[n/2+1,........n]中的元素是树中的叶子,因此每个都可以看做只含一个元素的堆,满足最大堆的要求,不用调整。所以只需调整以a[n/2........1]中元素为根的子树使之成为最大堆。
[cpp]
view plaincopy
//建堆:将一个数组a[1-n]变成一个最大堆
int BuildMaxHeap(int a[],int n){
int i;
//子数组a[(n/2+1,n/2+2......n)]中的元素都是树中的叶子
for(i = n/2;i >= 1;i--){
//调整以i为根节点的树使之成为最大堆
MaxHeap(a,i,n);
}
return 0;
}
a数组
16 | 7 | 3 | 20 | 17 | 8 |
自底向上从最后一个非叶节点开始调整:
(a) (b) (c)
(d)
每次调整都是从父节点、左孩子节点、右孩子节点三者中选择最大者跟父节点进行交换(交换之后可能造成被交换的孩子节点不满足堆的性质,因此每次交换之后要重新对被交换的孩子节点进行调整)。
堆排序:
开始时,堆排序先用BuildMaxHeap将输入数组a[1-n]构造成一个最大堆。又因为数组中最大元素在根a[1],则可以通过它与a
交换来达到最终的正确位置。
现在,如果从堆中”去掉“结点n(不是真的删除,而是通过修改堆的元素个数n),可以很容易的将a[1-(n-1)]建成最大堆。原来根的子女依旧是最大堆,二新交换的根元素很有可能违背最大堆的性质。这时调用MaxHeap重新调整一下。在a[1-(n-1)]中构造出最大堆。堆排序不断重复这一过程,堆的大小由n-1一直降到2.从而完成排序的功能
[cpp]
view plaincopy
//堆排序
int HeapSort(int a[],int n){
int temp;
//BulidMaxHeap将输入数组构造一个最大堆
BuildMaxHeap(a,n);
//数组中最大元素在根a[1],则可以通过它与a
交换来达到最终的正确位置
for(int i = n;i >= 2;i--){
//交换
temp = a[i];
a[i] = a[1];
a[1] = temp;
//a[i]已达到正确位置,从堆中去掉
n--;
//重新调整,保持最大堆的性质
MaxHeap(a,1,n);
}
return 0;
}
(a) (b) (c)
(d)
(e) (f) (g)
(h) (i) (j)
(k)
红色为排序后的结果;
代码:
[cpp]
view plaincopy
#include<stdio.h>
#include<stdlib.h>
//调整堆
int MaxHeap(int a[],int index,int n){
int LargestIndex = index;
//左子节点
int LeftIndex = 2*index;
//右子节点
int RightIndex = 2*index+1;
if(LeftIndex <= n && a[LeftIndex] > a[LargestIndex]){
LargestIndex = LeftIndex;
}
if(RightIndex <= n && a[RightIndex] > a[LargestIndex]){
LargestIndex = RightIndex;
}
//如果a[index]是最大的,则以index为根的子树已是最大堆否则index的子节点有最大元素
//则交换a[index],a[LargetIndex],从而使index及子女满足堆性质
int temp;
if(LargestIndex != index){
//交换a[index],a[LargetIndex]
temp = a[index];
a[index] = a[LargestIndex];
a[LargestIndex] = temp;
//重新调整以LargestIndex为根的子树
MaxHeap(a,LargestIndex,n);
}
return 0;
}
//建堆:将一个数组a[1-n]变成一个最大堆
int BuildMaxHeap(int a[],int n){
int i;
//子数组a[(n/2+1,n/2+2......n)]中的元素都是树中的叶子
for(i = n/2;i >= 1;i--){
//调整以i为根节点的树使之成为最大堆
MaxHeap(a,i,n);
}
return 0;
}
//堆排序
int HeapSort(int a[],int n){
int temp;
//BulidMaxHeap将输入数组构造一个最大堆
BuildMaxHeap(a,n);
//数组中最大元素在根a[1],则可以通过它与a
交换来达到最终的正确位置
for(int i = n;i >= 2;i--){
//交换
temp = a[i];
a[i] = a[1];
a[1] = temp;
//a[i]已达到正确位置,从堆中去掉
n--;
//重新调整,保持最大堆的性质
MaxHeap(a,1,n);
}
return 0;
}
int main(){
int n = 6;
//a[0]不用,堆的根结点是从1开始的
int a[] = {0,3,17,8,7,16,20};
HeapSort(a,n);
for(int i = 1;i <= n;i++){
printf("%d ",a[i]);
}
return 0;
}
Forward from http://blog.csdn.net/sjf0115/article/details/8610201
相关文章推荐
- 第十五周项目一 - 验证算法之快速、直接选择、堆排序
- 算法学习之一:堆排序
- 算法举例说明————堆排序
- 算法----堆排序(heap sort)
- 算法导论复习(3) 堆排序
- 【算法】堆和堆排序
- 算法笔记之堆排序
- 第16周项目1 验证算法(6)堆排序
- 第十六周项目1-验证算法(6)堆排序
- Java常用排序算法之堆排序
- 【数据结构与算法】堆排序
- 算法初级02——荷兰国旗问题、随机快速排序、堆排序
- 【算法学习】排序算法-堆排序
- [算法导论]第六章《堆排序》
- 算法:堆排序(Heap Sort)
- 【更新】排序算法比较:插入排序,冒泡排序,归并排序,堆排序,快速排序,计数排序,基数排序,桶排序
- 【算法】排序 (一):插入排序&希尔排序&选择排序&堆排序(C++实现)
- 【每日算法】堆排序
- 几种改良的排序,堆排序,希尔排序,快速排序--堆排序篇(改良的选择排序算法)
- 白话经典算法系列之七 堆与堆排序