您的位置:首页 > 其它

排序算法一:堆排序

2017-03-22 13:53 351 查看
一、算法介绍

堆排序(Heapsort)是指利用堆积树(堆)这种数据结构所设计的一种排序算法,它是选择排序的一种。可以利用数组的特点快速定位指定索引的元素。堆分为大根堆和小根堆,是完全二叉树。大根堆的要求是每个节点的值都不大于其父节点的值,即A[PARENT[i]]
>= A[i]。在数组的非降序排序中,需要使用的就是大根堆,因为根据大根堆的要求可知,最大的值一定在堆顶。

二、算法说明

     本文以大根堆为例来说明,假设要排序的数组为a,数组大小为n

i的儿子节点为2*i+1 , 2*i+2

       算法主要分为两个部分:

1.建立大根堆,然而建立的大根堆只能保证本身的特性(每个节点的值都不大于其父节点的值),并没有办法保证自身按照层次遍历的元素是有序的。

从a[n/2-1](从结尾开始第一个有儿子的节点)到根节点开始调节数组(完全二叉树),形成一个大根堆

2.大根堆能保证根节点一定是整个树当中最大的,因此排序就可以这么来安排:

将a[0]与a[n-1]进行交换,然后将a[0]到a[n-2]重新进行关于大根堆的调整

将a[0]与a[n-2]进行交换,然后将a[0]到a[n-3]重新进行关于大根堆的调整

。。。重复这个过程

第一次交换的过程中,取出数组第一大的数放在最后

第二次交换的过程中,取出数组第二大的数放在最后

。。。循环之后就完成了排序的过程

三、复杂度

堆排序的时间复杂度,主要在初始化堆过程和每次选取最大数后重新建堆的过程;

          初始化建堆过程时间:O(n)

        推算过程:

        首先要理解怎么计算这个堆化过程所消耗的时间,可以直接画图去理解;

        假设高度为k,则从倒数第二层右边的节点开始,这一层的节点都要执行子节点比较然后交换(如果顺序是对的就不用交换);倒数第三层呢,则会选择其子节点进行比较和交换,如果没交换就可以不用再执行下去了。如果交换了,那么又要选择一支子树进行比较和交换;

        那么总的时间计算为:s = 2^( i - 1 )  *  ( k - i );其中 i 表示第几层,2^( i - 1) 表示该层上有多少个元素,( k - i) 表示子树上要比较的次数,如果在最差的条件下,就是比较次数后还要交换;因为这个是常数,所以提出来后可以忽略;

        S = 2^(k-2) * 1 + 2^(k-3)*2.....+2*(k-2)+2^(0)*(k-1)  ===> 因为叶子层不用交换,所以i从 k-1 开始到 1;

        这个等式求解,我想高中已经会了:等式左右乘上2,然后和原来的等式相减,就变成了:

        S = 2^(k - 1) + 2^(k - 2) + 2^(k - 3) ..... + 2 - (k-1)

        除最后一项外,就是一个等比数列了,直接用求和公式:S = {  a1[ 1-  (q^n) ] }  / (1-q);

        S = 2^k -k -1;又因为k为完全二叉树的深度,所以 (2^k) <=  n < (2^k  -1 ),总之可以认为:k = logn (实际计算得到应该是 log(n+1) < k <= logn );

        综上所述得到:S = n - longn -1,所以时间复杂度为:O(n)

        更改堆元素后重建堆时间:O(nlogn)

        推算过程:

       1、循环  n -1 次,每次都是从根节点往下循环查找,所以每一次时间是 logn,总时间:logn(n-1) = nlogn  - logn ;

    

       综上所述:堆排序的时间复杂度为:O(nlogn)

空间复杂度

        因为堆排序是就地排序,空间复杂度为常数:O(1)

四、示例代码

如果还是不怎么懂的同学,代码run一下 通过输出的树状结构更容易理解

public class StackSort {

public static void main(String[] args) {
int[] a = { 26, 5, 77, 1, 61, 11, 59, 15, 48, 19 };
Sort(a);
}
//堆排需方法
public static void Sort(int[] a) {
int n = a.length;//取得数组总长度,及堆最大的序号
int temp = 0;

Display(a, "Before sort : ");
//这是建堆的过程,一次从倒数第二层的根节点开始调整堆,即数组下标为i/2开始,一直到顶层根节点,这样就建好堆了。。
for (int i = n / 2; i > 0; i--) {
Adjust(a, i - 1, n);//从倒数第二层的最后一个根节点开始调整堆
Display(a, "建立大根堆 : ");
}
System.out.println("---------------------------------------");
for (int i = n - 2; i >= 0; i--) {//这是堆排序的具体算法,思想是每次取出堆的最顶层根节点,即数组下标为0,然后与最后一个节点即i+1交换,这样对于大根堆而言,最大值总是在后面。。循环过后就能排序了。。
temp = a[i + 1];//取出最后一个元素
a[i + 1] = a[0];//取出第一个元素,即顶层根节点
a[0] = temp;//交换位置

Adjust(a, 0, i + 1);//调整堆
Display(a, "重建立大根堆 : ");
}

Display(a, "After sort : ");
}
/**
* 调整堆的方法
* 每次调用的目的就是调节传入的a[i]值 使得它在整个堆中处于正确的位置
* @param a 要调整的数组,即堆
* @param i 调整的根节点,即起始位置
* @param n 要调整的终止位置
*/
public static void Adjust(int[] a, int i, int n) {
int j = 0;
int temp = 0;

temp = a[i]; //取出根节点
j = 2 * i + 1; //左孩子节点

while (j <= n - 1) {
if (j < n - 1 && a[j] < a[j + 1])//比较左右孩子,取出较大的孩子
j++;

if (temp >= a[j]) //如果根节点大于孩子节点则退出循环,不用调整
break;

a[(j - 1) / 2] = a[j];//较大的孩子节点值赋值给根节点

j = 2 * j + 1;//继续寻找左孩子
}

a[(j - 1) / 2] = temp;//将根节点赋值给最后一个空出来的节点
}

//以图形形式表现二叉树
public static void Display(int[] a, String str){
System.out.println(str);
int h;//树的高度
h = (int) Math.ceil(Math.log((double)a.length)/Math.log((double)2));
int count = 0;//当前打印行
int num = 0;

for(int i = 0 ; i < a.length ; i++){

//如果i为每一层的最后一个 则换行并且打印下一层的开头
if(i == Math.pow(2,count) - 1 ){
System.out.print("\n");
num = (int)Math.pow(2,h-count-1);
for(int j = 0 ; j < num-1 ; j++){

System.out.printf("%3s",".");//每行开头
}
++count;
}

System.out.printf("%3s",a[i]);
num = (int)Math.pow(2,h-count+1);
for(int j = 0 ; j < num-1 ; j++){
System.out.printf("%3s",".");//字符间
}
}
System.out.print("\n");
}
}

代码内容来自 http://blog.csdn.net/lufeng20/article/details/7481427 http://blog.sina.com.cn/s/blog_4441270b0102wmvg.html
整理而成
时间复杂度 http://blog.csdn.net/yuzhihui_no1/article/details/44258297
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: