堆排序分析实现

算法思想

若升序，建大堆，每次选择堆顶元素即最大的数，和最后一位交换，再缩小堆的范围（避免刚排好的最后一个位置被调回去），对剩下的进行向下调整（此时只有根节点不对，左右子树都满足大堆）。反复进行直到堆的范围为0.则数据就有序了。

代码实现思路

堆排序的实现首先是需要将数组调整为一个大堆或者小堆，然后就是循环交换和调整堆的过程。因为在建堆和调整堆过程都用到了将数组的某一部分调整为一个堆，所以抽出为一个adjustArray(int[] nums, int start, int end)函数。

时间复杂度

O(nlogn)。
建堆的时间复杂度近似为O(n*log n)，每次选一个数后进行调整的复杂度也近似为O(n*log n)，时间复杂度忽略系数，结果就近似为O(n*log n)。

空间复杂度

O(1)

稳定性

不稳定。
堆的调整时可能会打乱稳定性。

代码实现

package sort;

/**
 * @作者：dhc
 * @创建时间：8:28 2018/8/15
 * @排序方法：堆排序
 * @时间复杂度：O(nlogn)。建堆的时间复杂度近似为O(n*log n)，每次选一个数后进行调整的复杂度也近似为O(n*log n)，时间复杂度忽略系数，结果就近似为O(n*log n).
 * @空间复杂度：O(1)
 * @稳定性：不稳定
 */
public class HeapSort {
    //堆排序
    public static void heapSort(int[] nums){
        heapArray(nums);
        int tem;
        for(int i = nums.length - 1;i > 0;i--){
            tem = nums[0];
            nums[0] = nums[i];
            nums[i] = tem;
            adjustArray(nums,0,i-1);
        }
    }
    //堆化数组
    public static void heapArray(int[] nums){
        for (int i = nums.length / 2; i >= 0; i--) {
            adjustArray(nums,i,nums.length);
        }
    }
    //对某个节点进行一次从上到下的调整(建小堆的调整)
    public static void adjustArray1(int[] nums, int start, int end){
        int min;
        int k;
        for (int i = start; i < end;) {
            if(2*i+2<=end){
                //这里是和左右子节点比较并的较小者交换，后面得到的是小堆，如果要大堆，则需要和比较后的较大者交换
                min = nums[2*i+1] > nums[2*i+2] ? nums[2*i+2] : nums[2*i+1];
                k = nums[2*i+1] > nums[2*i+2] ? 2*i+2 : 2*i+1;
                if(nums[i] > min){
                    nums[k] = nums[i];
                    nums[i] = min;
                    i = k;
                }else{
                    break;
                }
            }else{
                break;
            }
        }
    }
    //建大堆的调整
    public static void adjustArray(int[] nums, int start, int end){
        int max;
        int k;
        for (int i = start; i < end;) {
            if(2*i+2<=end){
                max = nums[2*i+1] < nums[2*i+2] ? nums[2*i+2] : nums[2*i+1];
                k = nums[2*i+1] < nums[2*i+2] ? 2*i+2 : 2*i+1;
                if(nums[i] < max){
                    nums[k] = nums[i];
                    nums[i] = max;
                    i = k;
                }else{
                    break;
                }
            }else{
                break;
            }
        }
    }

    public static void main(String[] args) {
        int[] nums = new int[]{1,0,5,3,7,9,2,4,5};
        heapSort(nums);
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i]+" ");
        }
    }
}

参考链接

白话经典算法系列之七 堆与堆排序
【数据结构】几种常见的排序算法
稳定排序和不稳定排序