常见排序算法-----堆排序

    // 堆排序，升序用最大堆，降序用最小堆
    /*
     * 思路： 将数组构建成一个最大堆，从最后一个非叶子节点开始，将它和它的左右子节点中最大的节点相比较
     * 如果子节点大则进行交换，再找倒数第二个非叶子节点，同理。 当到倒数第三个叶子节点时，若发生交换
     * 则还应判断交换过后有没有对交换过的子节点发生影响，若有影响应进行调整。
     * 
     * 自底向上建立堆，自顶向下调整堆
     */

    public static void main(String[] args) {
        HeapSort hs = new HeapSort();
        int[] arr = new int[] { 1, 4, 56, 2, 4, 6, 8, 9 };
        hs.heapSort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

    public void heapSort(int[] arr) {

        // 找到最后一个非叶子节点开始遍历,建立最大堆
        for (int i = arr.length - 2 >> 2; i >= 0; i--) {
            adjustHeap(arr, i, arr.length);

        }

        for (int i = arr.length - 1; i > 0; i--) {
            // 此时已经建立好最大堆，最大值在最上方，将其与最后一个元素进行交换，即将最大的元素排除，寻找剩余元素中的最大值
            swap(arr, 0, i);
            // 交换后重新调整堆结构
            adjustHeap(arr, 0, i);
        }

    }

    public void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    /**
     * 调整是建立在 已经建立好最大堆的基础上
     * 
     * @param arr
     * @param i
     * @param length
     */
    public void adjustHeap(int[] arr, int i, int length) {

        int temp = arr[i];
        for (int j = 2 * i + 1; j < length; j = j * 2 + 1) {// 从i节点的左子节点开始
            if (j + 1 < length && arr[j] < arr[j + 1]) { // 如果存在右子节点，且右子节点大于左子节点
                j++; // 如果是最小堆比较的是最小值 即条件改为 arr[j]>arr[j+1] j++
            }
            if (arr[j] > temp) { // 如果最大的子节点大于父节点，交换（此处不需要交换直接赋值即可） //如果arr[j]
                                    // <temp 进行交换
                arr[i] = arr[j];
                i = j;
            } else {
                break; // 如果不大于说明不会对后面产生影响直接跳出循环
            }
            // 确定i最后所在的位置 将值赋予该位置
            arr[i] = temp;
        }

    }

 堆排序是一种不稳定排序，其中构建初始堆经推导复杂度为O(n)，在交换并重建堆的过程中，需交换n-1次，而重建堆的过程中，根据完全二叉树的性质，[log2(n-1),log2(n-2)...1]逐步递减，近似为nlogn

详情  http://www.cnblogs.com/chengxiao/p/6129630.html