Java堆排序

       “堆” 这个词最初是在堆排序中提出的，但后来就逐渐指“废料手机存储区”，就像Java的堆一样，但这里的堆指的是排序。

         （二叉）堆数据结构是一种数组对象，可以被视为一棵完全二叉树，树中每个节点与数组中存放该节点值的那个元素对应，树的每一层都是填满的，最后一层可能除外，堆中有两个属性：length[A]是数组中的元素个数，heap_size[A]是存放在A中的堆的元素个数。虽然A[1...length[] ]中都可以含有有效值，A[heap_size[A]]之后的元素都不属于相应的堆，heap_size[A] =<length[A]。

         二叉堆有两种：最大堆和最小堆。最大堆满足如下：A[parent(i)] => A[i];

        MAX_HEAPIFY：保持最大堆的关键运行时间O（n lgn），最大堆只是对以该元素为根进行性质排序，即他的左右节点都不能比他大

       BUILD_MAX_HEA：以线性时间运行，可以在无序的输入数组基础上构造出最大堆

       HEAPSORT：对数组原地进行排序

  如下的类构造出堆排序：

package com.yj.MAX_HEAPIFY;

public class HeapIfy {
    
    private int[] IntArray; //数组
    private int heap_size;  //堆个数
    
    /**
     * 初始化
     * @param IntArray
     */
    public HeapIfy(int [] IntArray){
        
        this.IntArray = IntArray;
        this.heap_size = this.IntArray.length -1;
    }
    
    /**
     * 最大堆
     * @param A 数组
     * @param i 需要排序的下标
     */
    public void MAX_HEAPIFY(int [] A, int i){
        int l = LEFT(i);
        int r = RIGHT(i);
        int largest = 0;
        if(l <= heap_size && A[l] > A[i]){
            largest = l;
        }
        else{
            largest = i;
        }
        
        if(r <= heap_size && A[r] > A[largest]){
            largest = r;
        }
        
        if(largest != i){
            int tmp = A[i];
            A[i] = A[largest];
            A[largest] = tmp;
            
            MAX_HEAPIFY(A, largest);
        }
    }
    
    /**
     * 建堆
     * @param A
     */
    public void BUILD_MAX_HEAP(int[] A){
        int tmp =heap_size/2;
        for(int i = tmp; i !=1 ; i--){
            MAX_HEAPIFY(A, i);
        }
    }
    
    /**
     * 堆排序实现
     * @param A
     */
    public void HEAPSORT(int[] A){
        
        BUILD_MAX_HEAP(A);
        int tmp = 0;
        for(int i = A.length-1 ; i >= 2;i-- ){
            tmp = A[1];
            A[1] = A[i];
            A[i] = tmp;
            heap_size = heap_size - 1;
            MAX_HEAPIFY(A, 1);
        }
    }
    
    /**
     * 左节点的下标 计算
     * @param i 当前节点下标
     * @return 左节点的下标
     */
    public int LEFT(int i){
        
        return 2*i;
    }
    
    /**
     * 右节点下标计算
     * @param i 当前节点下标
     * @return  右节点下标
     */
    public int RIGHT(int i){
        
        return 2*i + 1;
    }
    
    /**
     * 返回排序号的字符串
     */
    public String toString(){
        String result = "";
        for(int i = 0;i < IntArray.length ; i++){
            result += IntArray[i] + "  ";
        }
        
        return result;
    }
}

实现如下:

package com.yj.MAX_HEAPIFY;

public class TestAlgorithms {

    /**
     * @param args
     */
    public static void main(String[] args) {
        int [] array = {0,16,4,10,14,7,9,3,2,8,1};
        HeapIfy test = new HeapIfy(array);
        //test.BUILD_MAX_HEAP(array);
        test.HEAPSORT(array);
        System.out.println(test.toString());
    }

}

结果输出：

0  1  2  3  4  7  8  9  10  14  16 

堆排序总体性能不行，

转载于:https://www.cnblogs.com/YJ7777777YQ/archive/2013/04/13/3019466.html