java ~ 堆排序

最近看了很多算法，发现堆排序居然是解题的基础，虽然看堆排序的图解我能看懂，但是让我自己去实现，发现写不出来，顾在此总结前辈的经验，供自己学习之用。

堆排序是一种树形选择排序方法，它的特点是：在排序的过程中，将array[0，...，n-1]看成是一颗完全二叉树的顺序存储结构，利用完全二叉树中双亲节点和孩子结点之间的内在关系，在当前无序区中选择关键字最大（最小）的元素。

1. 若array[0，...，n-1]表示一颗完全二叉树的顺序存储模式，则双亲节点指针和孩子结点指针之间的内在关系如下：

　　任意一节点指针 i：父节点：i==0 ? null : (i-1)/2

　　　　　　　　　　  左孩子：2*i + 1

　　　　　　　　　　  右孩子：2*i + 2

2. 堆的定义：n个关键字序列array[0，...，n-1]，当且仅当满足下列要求：(0 <= i <= (n-1)/2)

　　　　　　① array[i] <= array[2*i + 1] 且 array[i] <= array[2*i + 2]； 称为小根堆；

　　　　　　② array[i] >= array[2*i + 1] 且 array[i] >= array[2*i + 2]； 称为大根堆；

3. 建立大根堆：

　　n个节点的完全二叉树array[0，...，n-1]，最后一个节点n-1是第(n-1-1)/2个节点的孩子。对第(n-1-1)/2个节点为根的子树调整，使该子树称为堆。

　　对于大根堆，调整方法为：若【根节点的关键字】小于【左右子女中关键字较大者】，则交换。

　　之后向前依次对各节点（(n-2)/2 - 1）~ 0为根的子树进行调整，看该节点值是否大于其左右子节点的值，若不是，将左右子节点中较大值与之交换，交换后可能会破坏下一级堆，于是继续采用上述方法构建下一级的堆，直到以该节点为根的子树构成堆为止。

　　反复利用上述调整堆的方法建堆，直到根节点。

4.堆排序：（大根堆）

　　①将存放在array[0，...，n-1]中的n个元素建成初始堆；

　　②将堆顶元素与堆底元素进行交换，则序列的最大值即已放到正确的位置；这就是为什么堆排序属于选择排序，每次都会产生一个最大或最小的元素。

　　③但此时堆被破坏，将堆顶元素向下调整使其继续保持大根堆的性质，再重复第②③步，直到堆中仅剩下一个元素为止。

堆排序算法的性能分析：

　　空间复杂度:o(1)；

　　时间复杂度:建堆：o(n)，每次调整o(log n)，故最好、最坏、平均情况下：o(n*logn);

　　稳定性：不稳定

算法实现：

如《插入排序(Insertsort)之Java实现》一样，先实现一个数组工具类。代码如下:

package sortTest;

/**
 *
 * @author zhengchao
 */

public class ArrayUtils {  
      
    //先实现一个数组工具类，打印数组
    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 exchangeElements(int[] array, int index1, int index2) {  
        int temp = array[index1];  
        array[index1] = array[index2];  
        array[index2] = temp;  
    }  
}  

堆排序中最重要的算法就是maxHeap，该函数假设一个元素的两个子节点都满足最大堆的性质(左右子树都是最大堆)，只有根元素可能违反最大堆性质，那么把该元素以及左右子节点的最大元素找出来，如果该元素已经最大，那么整棵树都是最大堆，程序退出，否则交换跟元素与最大元素的位置，继续调用maxHeap原最大元素所在的子树。该算法是分治法的典型应用。具体代码如下:

package sortTest;

/**
 *
 * @author zhengchao
 */
public class HeapSort {  
    
    public static void main(String[] args) {
        
        int[] array = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, -1, -2, -3,1 ,0,-12};  

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

        heapSort(array);  

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

    public static void heapSort(int[] array) {  
        if (array == null || array.length <= 1) {  
            return;  
        }  

        //建立大根堆
        buildMaxHeap(array);  

        for (int i = array.length - 1; i >= 1; i--) {  
            //每次将顶部的元素与length - 1，length - 2.....的位置的元素交换，这样末尾的元素都是有序的了
            ArrayUtils.exchangeElements(array, 0, i);  

            //顶部元素交换后，破坏了堆的结构，重新调整
            maxHeap(array, i, 0);  
        }  
    }  

    //建立大根堆
    private static void buildMaxHeap(int[] array) {  
        if (array == null || array.length <= 1) {  
            return;  
        }  
        //这个地方有人可能有疑问：为什么从array.length / 2开始，你需要深刻理解二叉树的结构，并且此算法是：取每个父节点和其对应的两个子节点比，
        int half = array.length / 2;  
        for (int i = half; i >= 0; i--) { 
            
            maxHeap(array, array.length, i);  
        }  
    }  

    //当前节点和其两个子节点A,B比较，若A,B中较大数比如是array[A]大于当前节点的数，交换当前节点与array[A]。
    private static void maxHeap(int[] array, int heapSize, int 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) {  
            ArrayUtils.exchangeElements(array, index, largest);  

            maxHeap(array, heapSize, largest);  
        }  
    }  
}  

输出结果：

run:
Before heap sort:
{9, 8, 7, 6, 5, 4, 3, 2, 1, 0, -1, -2, -3, 1, 0, -12}
After heap sort:
{-12, -3, -2, -1, 0, 0, 1, 1, 2, 3, 4, 5, 6, 7, 8, 9}
成功构建 (总时间: 0 秒)