《基础算法之排序》： 4、堆排序——java实现

4、堆排序

题目思路：

对于堆排序，首先要了解堆的概念，堆分为大顶堆和小顶堆。顾名思义，大顶堆的堆顶元素为整个堆的最大值；小顶堆的堆顶元素为整个堆的最小值。
对于本题的堆排序，采用的是大顶堆。堆排序主要分为两部分，建堆和调整堆。
建堆的过程就是遍历要排序的数组中的每一个元素，然后依次放入大顶堆，并比较大小，找到每个元素的位置，大顶堆构建完毕后，此时堆顶为最大值。
调整堆的过程就是，将堆顶的元素弹出堆，并将最后一个元素放到堆顶，此时堆里的元素减少了一个，重新调整堆里面的位置，保证堆顶为整个堆的最大值。

排序复杂度：

时间复杂度：o（n*logn）
空间复杂度：o（1）

排序稳定性：

由于堆排序调整堆时，堆底元素要先变为堆顶元素，然后在调整堆，会发生位置的变化，因此，堆排序为非稳定性排序。

代码实现：

    public static int[] heapSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return arr;
        }
        for (int i = 0; i < arr.length; i++) {
            heapInsert(arr, i);   //依次将每个元素插入到堆中
        }
        int size = arr.length;
        swap(arr,0, --size);  //堆底元素与最后一位交换
        while (size > 0){
            heapify(arr,0,size); // 不断调整大顶堆，弹出并交换堆顶元素
            swap(arr,0,--size);
        }
        return arr;

    }

    private static void heapInsert(int[] arr, int index) {  //构建大顶堆
        while (index != 0) {
            int parent = (index - 1) / 2;
            if (arr[parent] < arr[index]) {   //遍历到当前位置，然后不断向上弹，使堆顶值最大
                swap(arr, parent, index);
                index = parent;
            }else {
                break;
            }
        }
    }

    private static void heapify(int[] arr, int index, int size) { //调整堆
        int left = index * 2 + 1;
        int right = index * 2 + 2;
        int largest = index;   //将当前的堆顶设置为最大值
        while (left < size){   
            if (arr[left] > arr[largest]){
                largest = left;
            }
            if (right < size && arr[right] > arr[largest]){
                largest = right;
            }
            if (largest != index){
                swap(arr,largest,index);
            }else {
                break;
            }
            index = largest;
            left = index * 2 + 1;
            right = index * 2 + 2;

        }
    }

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