Java堆排序

    /**
     * 确保parent最大
     * 
     * @param array
     * @param parentIndex 父节点
     * @param endIndex  最大节点
     */
    private static void maxHeapify(int[] array, int parentIndex, int endIndex){
        int rightIndex = (parentIndex+1)<<1;
        int leftIndex = rightIndex - 1;
        int largestIndex = parentIndex;
        
        if(rightIndex <= endIndex && 
                rightIndex > 0 && array[rightIndex] > array[largestIndex]){
            largestIndex = rightIndex;
        }
        
        if(leftIndex <= endIndex && 
                leftIndex > 0 && array[leftIndex] > array[largestIndex]){
            largestIndex = leftIndex;
        }
        
        if(largestIndex != parentIndex){
            swap(array, largestIndex, parentIndex);
        }
    }
    
    private static void buildMaxHeap(int[] array, int endIndex){
        for(int i=(endIndex-1)>>1; i>=0; i--){
            maxHeapify(array, i, endIndex);
        }
    }
    
    private static void swap(int[] array, int a, int b){
        int temp = array[a];
        array[a] = array[b];
        array[b] = temp;
    }
    
    private static void heapSort(int[] array){
        if(array == null || array.length <= 1){
            return;
        }
        
        for(int i=array.length-1;i>0; i--){
            //将[0,i]之间的子数组构建最大堆
            buildMaxHeap(array, i);
            swap(array, 0, i);
        }
    }
    
    public static void main(String[] args){
        int size = 15;
        int[] array = new int[size];
              
        for(int i=0;i<size; i++){
            array[i] = (int) (100 * Math.random());
        }
        
        System.out.println("排序前：" + Arrays.toString(array));
        heapSort(array);
        System.out.println("排序后：" + Arrays.toString(array));
    }