用Java实现一个堆排序

堆可以看成是一个完全二叉树，而且非终端节点的值均不大于（不小于）其左右孩子节点的值。堆排序只需要一个记录大小的辅助空间，输出堆顶的值之后需要对堆进行调整建立新堆，找到剩下节点的最大值（最小值），反复执行。

package java_net_test;
//大顶堆
public class Java_HeapSort {

 public static void main(String[] args) {
   int[] array = {-1,16,7,3,20,17,8};  

         System.out.println("Before heap:");  
         printArray(array);  

         heapSort(array);  

         System.out.println("After heap sort:");  
         printArray(array);

 }
 
 
 //printArray函数是将数字打印出来
 
 public static void printArray(int[] array) {  
        System.out.print("{");  
        for (int i = 0; i < array.length; i++) {  
            System.out.print(array[i]);  
            if (i < array.length - 1) {  
                System.out.print(", ");  
            }  
        }  
        System.out.println("}");  
    }  
 
 public static void heapSort(int[] array) {  
        if (array == null || array.length <= 1) {  
            return;  
        }  

        buildMaxHeap(array);  //建堆

        for (int i = array.length - 1; i >= 1; i--) {  
            exchangeElements(array, 0, i);  //将堆顶的元素放在数组的最后的一个位置

            maxHeap(array, i, 0);// 被置换的堆顶需要重新调整一次
        }  
    }  
 
 private static void buildMaxHeap(int[] array) {  
        if (array == null || array.length <= 1) {  
            return;  
        }  

        for (int i = array.length / 2; i >= 0; i--) {  
            maxHeap(array, array.length, i); //从非叶子节点开始调整
        }  
    }  
 
 public static void exchangeElements(int[] array, int index1, int index2) {  
        int temp = array[index1];  
        array[index1] = array[index2];  
        array[index2] = temp;  
    }  

 
 private static void maxHeap(int[] array, int heapSize, int index) {  //实现节点index开始向下调整，保证之前index上的值满足堆
        int left = index * 2 + 1;  
        int right = index * 2 + 2;  

        int largest = index;  
        if (left < heapSize && array[left] > array[index]) {  
            largest = left;  
        }  

        if (right < heapSize && array[right] > array[largest]) {  
            largest = right;  
        }  

        if (index != largest) {  //largest中的值比index大，进行交换
            exchangeElements(array, index, largest);  

            maxHeap(array, heapSize, largest);  //largest是被换掉的位置，对于交换后出现的问题用递归重新检查一遍。该递归的方法比for来比较每个要快
        }  
    }  
 


}