堆排序法

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

堆排序是一种利用完全二叉树来解决问题的高效算法，合法的最大堆树要满足一个条件就是每一个结点值都要大于或等于它的孩子结点值。在一个数组中那专业法表示为：

arrays[i]>=arrays[2*i+1] && arrays[i]>=arrays[2*i+2]; 最小堆类似，只要改为冒最小值即可。

堆排序树的构造过程找最大值过程由下图，数组arrays[0....n]为：17,8,45,84,2,94，刚找到最大值后把最大值即94放在数组的最后面arrays[n],

然后进入递归把arrays[0...n-1]再进入下面图这个过程，只是把排好序的最大值不放入到这个过程中，就这样把值一个个的冒出来。

，找到最大值后把这个最大值放到数组的最后面，进入下一个递归。

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

最后两步还有几个过程没画出来，最后两个图好像没有变化，但这里面还要排好几次，原因就是最后第二个图是不满足堆排序树的要调整后再把最大的值放到到后面。再次回到递归里面。

全代码实现由下：

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 

输出完成 (耗时 0 秒) - 正常终止