码迷,mamicode.com
首页 > 其他好文 > 详细

堆排序

时间:2014-07-28 15:08:53      阅读:248      评论:0      收藏:0      [点我收藏+]

标签:style   blog   http   java   color   strong   文件   2014   

堆排序是一种选择排序,其时间复杂度为O(nlogn)

堆的定义                                                                                   

n个元素的序列{k1,k2,…,kn}当且仅当满足下列关系之一时,称之为堆。

情形1:ki <= k2i 且ki <= k2i+1 最小化堆小顶堆

情形2:ki >= k2i 且ki >= k2i+1化堆大顶堆

其中i=1,2,…,n/2向下取整;

bubuko.com,布布扣

若将和此序列对应的一维数组(即以一维数组作此序列的存储结构)看成是一个完全二叉树,则堆的含义表明,完全二叉树中所有非终端结点的值均不大于(或不小于)其左、右孩子结点的值

由此,若序列{k1,k2,…,kn}是堆,则堆顶元素(或完全二叉树的根)必为序列中n个元素的最小值(或最大值)。

例如,下列两个序列为堆,对应的完全二叉树如图:

bubuko.com,布布扣

若在输出堆顶的最小值之后,使得剩余n-1个元素的序列重又建成一个堆,则得到n个元素的次小值。如此反复执行,便能得到一个有序序列,这个过程称之为堆排序

堆排序(Heap Sort)只需要一个记录元素大小的辅助空间(供交换用),每个待排序的记录仅占有一个存储空间。

堆的存储                                                                                  

一般用数组来表示堆,若根结点存在序号0处, i结点的父结点下标就为(i-1)/2。i结点的左右子结点下标分别为2*i+1和2*i+2。

(注:如果根结点是从1开始,则左右孩子结点分别是2i和2i+1。)

如第0个结点左右子结点下标分别为1和2。

如最大化堆如下:

bubuko.com,布布扣

左图为其存储结构,右图为其逻辑结构。

堆排序的实现                                                                            

实现堆排序需要解决两个问题:

1.如何由一个无序序列建成一个堆?

2.如何在输出堆顶元素之后,调整剩余元素成为一个新的堆?

先考虑第二个问题,一般在输出堆顶元素之后,视为将这个元素排除,然后用表中最后一个元素填补它的位置,自上向下进行调整:首先将堆顶元素和它的左右子树的根结点进行比较,把最小的元素交换到堆顶;然后顺着被破坏的路径一路调整下去,直至叶子结点,就得到新的堆。

我们称这个自堆顶至叶子的调整过程为“筛选”

从无序序列建立堆的过程就是一个反复“筛选”的过程。

  • 构造初始堆

初始化堆的时候是对所有的非叶子结点进行筛选。

最后一个非终端元素的下标是[n/2]向下取整,所以筛选只需要从第[n/2]向下取整个元素开始,从后往前进行调整。

比如,给定一个数组,首先根据该数组元素构造一个完全二叉树。

然后从最后一个非叶子结点开始,每次都是从父结点、左孩子、右孩子中进行比较交换,交换可能会引起孩子结点不满足堆的性质,所以每次交换之后需要重新对被交换的孩子结点进行调整。

  • 进行堆排序

有了初始堆之后就可以进行排序了。

堆排序是一种选择排序。建立的初始堆为初始的无序区。

排序开始,首先输出堆顶元素(因为它是最值),将堆顶元素和最后一个元素交换,这样,第n个位置(即最后一个位置)作为有序区,前n-1个位置仍是无序区,对无序区进行调整,得到堆之后,再交换堆顶和最后一个元素,这样有序区长度变为2。。。

断进行此操作,将剩下的元素重新调整为堆,然后输出堆顶元素到有序区。每次交换都导致无序区-1,有序区+1。不断重复此过程直到有序区长度增长为n-1,排序完成。

  • 堆排序实例

bubuko.com,布布扣

上图已经排好了最大那个值 下面见图排其他的元素:

bubuko.com,布布扣

由排序过程可见,若想得到升序,则建立大顶堆,若想得到降序,则建立小顶堆

代码                                                                                           

public class  Heap
{
    public void heap_sort(int[] arrays,int e){
        if(e>0){
            init_sort(arrays,e);//初始化堆,找出最大的放在堆顶
        //    snp(arrays);
            arrays[0]=arrays[e]+arrays[0];
            arrays[e]=arrays[0]-arrays[e];
            arrays[0]=arrays[0]-arrays[e];
        //    snp(arrays);
            heap_sort(arrays, e-1);
        }else{
            snp(arrays);
        }
    }

    public void snp(int[] arrays){
        for(int i=0;i<arrays.length;i++){
            System.out.print(arrays[i]+" ");
        }
        System.out.println();
    }

    public void init_sort(int[] arrays,int e){        
        int m=(e+1)/2;    
        for(int i=0;i<m;i++){
            boolean flag=build_heap(arrays,e,i);
            //如果孩子之间有交换,就要重新开始
            if(flag){
                i=-1;
            }
            
        }
        
            
    }
    //返回一个标记,如果有根与孩子交换就要重新从顶根开始查找不满足最大堆树结构
    public boolean build_heap(int arrays[],int e,int i){
        int l_child=2*i+1;//左孩子
        int r_child=2*i+2;//右孩子
        if(r_child>e){           //判断是否有右孩子,没有的话直接比较,小于交换
            if(arrays[i]<arrays[l_child]){
                arrays[i]=arrays[i]+arrays[l_child];
                arrays[l_child]=arrays[i]-arrays[l_child];
                arrays[i]=arrays[i]-arrays[l_child];
                return true;
            }else{
                    return false;
                }
        }
        //在根与两个孩子之间找出最大的那个值进行交换
        if(arrays[i]<arrays[l_child]){
            if(arrays[l_child]>arrays[r_child]){
                //交换根与左孩子的值
                arrays[i]=arrays[i]+arrays[l_child];
                arrays[l_child]=arrays[i]-arrays[l_child];
                arrays[i]=arrays[i]-arrays[l_child];
                return true;
            }else{
                //交换根与右孩子的值
                arrays[i]=arrays[i]+arrays[r_child];
                arrays[r_child]=arrays[i]-arrays[r_child];
                arrays[i]=arrays[i]-arrays[r_child];
                return true;
            }
        }else if(arrays[i]<arrays[r_child]){
                //交换根与右孩子的值
                arrays[i]=arrays[i]+arrays[r_child];
                arrays[r_child]=arrays[i]-arrays[r_child];
                arrays[i]=arrays[i]-arrays[r_child];
                return true;
        }
        return false;
            
    }
    public static void main(String[] args) 
    {
        Heap h=new Heap();
        int [] a={17,8,45,84,2,94};
        h.heap_sort(a,a.length-1);
    }
}

运行打印过程由下,这个结果可以对着上面的树来看,容易理解:

---------- java ----------
94 45 84 8 2 17 
17 45 84 8 2 94 
84 45 17 8 2 94 
2 45 17 8 84 94 
45 8 17 2 84 94 
2 8 17 45 84 94 
17 8 2 45 84 94 
2 8 17 45 84 94 
8 2 17 45 84 94 
2 8 17 45 84 94 

我是天王盖地虎的分割线                                                               

堆排序方法对记录数较少的文件并不值得提倡,但对n较大的文件还是很有效的。因为其运行时间主要耗费在建初始堆和调整建新堆时进行的反复“筛选”上。

堆排序在最坏的情况下,其时间复杂度也为O(nlogn)。相对于快速排序来说,这是堆排序的最大优点。此外,堆排序仅需一个记录大小的供交换用的辅助存储空间。

 

 

 

参考:http://www.cnblogs.com/mengdd/archive/2012/11/30/2796845.html

http://www.cnblogs.com/hexiaochun/archive/2012/09/04/2671076.html

堆排序,布布扣,bubuko.com

堆排序

标签:style   blog   http   java   color   strong   文件   2014   

原文地址:http://www.cnblogs.com/yydcdut/p/3863099.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!