算法学习笔记（九）

一、堆排序

回忆二叉堆的特性：
1.最大堆的堆顶是整个堆中的最大元素
2.最小堆的堆顶是整个堆中的最小元素
以最小堆为例，如果删除一个最小堆的堆顶（并不是完全删除，而是跟末尾的节点交换位置），经过自我调整，第2小的元素就会交换上来，成为最大堆的新堆顶。

根据二叉堆的特性，每一次删除旧堆顶，调整后的新堆顶都是大小仅次于旧堆顶的节点，那么反复删除堆顶，反复调整二叉堆，所得到的集合就会成为一个有序集合。

由此可以归纳出堆排序算法的步骤。
1.把无序数组构建成二叉堆，需要从小到大排序，则构建成最大堆；需要从大到小排序，则构建成最小堆。

2.循环删除堆顶元素，替换到二叉堆的末尾，调整堆产生新的堆顶。
代码如下：

public class downSort {
    /**
     * 下沉调整
     * @param array 待调整的堆
     * @param parentIndex 要下沉的父节点
     * @param length 堆的大小
     */
    public static void downAdjust(int[] array,int parentIndex,int length){
        //temp保存父节点值，用于最后的赋值
        int temp = array[parentIndex];
        int childIndex = 2*parentIndex+1;
        while (childIndex<length){
            //如果有右孩子，且右孩子大于左孩子的值，则定位到右孩子
            if (childIndex+1<length &&array[childIndex+1]>array[childIndex]){
                childIndex++;
            }
            //如果父节点大于任何一个孩子的值，则直接跳出
            if (temp>=array[childIndex]){
                break;
            }
                //无须交换，单项赋值即可
              array[parentIndex] = array[childIndex];
             parentIndex=childIndex;
            childIndex=2*childIndex+1;

            }
        array[parentIndex]=temp;
        }

    /**
     * 堆排序升序
     * @param array
     */
        public static void heapSort(int[] array){
        //1，把无序数组构建成最大堆
            for (int i = (array.length-2)/2; i >=0 ; i--) {
                downAdjust(array,i,array.length);
            }
            System.out.println(Arrays.toString(array));
            //2.循环删除堆顶元素，移到集合尾部，调整堆产生新的堆顶
            for (int i = array.length-1; i >0 ; i--) {
                //最后1个元素和第一个元素交换
                int temp = array[i];
                array[i] = array[0];
                array[0] = temp;
                //下沉调整最大堆
                downAdjust(array,0,i);
            }
        }

    public static void main(String[] args) {
        int[] arr = new int[]{1,3,2,6,5,7,8,9,10,0};
        heapSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

结果：

二叉堆的节点下沉调整是堆排序算法的基础，这个调节操作本身的时间复杂度是O（logn）
堆排序的算法步骤：
1.把无序数组构建成二叉堆
2.循环删除堆顶的元素，并将该元素移到集合尾部，调整堆产生新的堆顶。
第一步把无序数组构建成二叉堆，这一步的时间复杂度是o(n)。
第二步需要进行n-1次循环。每次循环调用一次downAdjust方法，所以第2步的计算规模是（n-1）*logn,时间复杂度是 O（nlogn）.

两个步骤是并列关系，所以整体的时间复杂度是O（nlogn）.

额，是不是挺简单的，只要了解最大堆和最小堆的特性。堆排序就是对堆顶进行操作，最后形成了一个有序的数组。

先消化消化。。慢慢累积。