47-原地堆排序

目录

1.概述

2.思路

3.代码实现

4.对比冒泡排序

4.1.冒泡排序

4.2.判断数组中元素是否有序排列（小->大）

4.3.测试比较堆排序、冒泡排序、快速排序的算法的用时，体会算法的魅力

---

1.概述

• 原地堆排序是一个稳定的排序算法。
• 时间复杂度为O(nlogn)——O(n) 【heapify建堆时间复杂度】+ O(nlogn) 【外层for循环O(n) * 内层siftDown操作O(logn)】= O(nlogn)。
• 空间复杂度为O(1)——未新建数组。

2.思路

1. 将任意数组heapify——调整为最大堆。
2. 此时整个数组中最大元素就在堆顶，排序后这个元素应处在数组末尾，则swap(0, arr.length - 1)，此时最大值处在正确位置。
3. 按此过程迭代到最后一个元素时，整个数组已经有序。（从小到大）

注：之前siftDown下沉操作是在整个数组上进行的，现在的下沉操作是，每当有一个元素交换最终位置时，下沉就不能再考虑该元素。

图解：

3.代码实现

public class SevenSort {
   /**
     * 将任意数进行原地堆排序
     * @param arr
     */
    public void heapSort(int[] arr) {
        //将任意数组调整为最大堆，从最后一个非叶子节点开始
        for (int i = (arr.length - 1 - 1) / 2; i >= 0 ; i--) {
             siftDown(arr, i, arr.length);
        }
        //依次将堆顶元素和最后位置元素交换
        //最开始:待排序数组[0...arr.length - 1],已排序数组[];
        //交换第一个元素之后:待排序数组[0...arr.length - 2],已排序数组[arr.length - 1];
        //交换第二个元素之后:待排序数组[0...arr.length - 3],已排序数组[arr.length - 2,arr.length - 1];
        //此处终止条件不用写i = 0,当整个待排序数组就剩一个元素时，整个数组已经有序
        for (int i = arr.length - 1; i >0; i--) {
            swap(arr, 0, i);
            siftDown(arr, 0, i);
        }
    }

    /**
     * 元素下沉操作
     * @param arr
     * @param i
     * @param n 当前arr中有效的元素个数
     */
    private void siftDown(int[] arr, int i, int n) {
        //仍然存在子树
        while((2 * i + 1) < n) {
            int j = 2 * i + 1;
            //右孩子存在且大于左子树值
            if (j + 1 < n && arr[j + 1] > arr[j]) {
                j = j + 1;
            }
            //j对应的下标就是左右子树的最大值
            if(arr[i] >= arr[j]) {
                break;
            } else {
                swap(arr,i,j);
                i = j;
            }
        }
    }

    /**
     * 交换操作
     * @param arr
     * @param i
     * @param j
     */
    private void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

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

4.对比冒泡排序

4.1.冒泡排序

/**
 * 将任意数组进行冒泡排序
 * @param arr
 */
public static void bubbleSort(int[] arr) {
    //最外层表示要比较的趟数,此处-1是因为，整个待排序数组剩一个元素时，整个数组已经有序
    for (int i = 0; i < arr.length - 1; i++) {
        boolean isSwaped = false;
        //此处-1是为了防止越界
        for (int j = 0; j < arr.length - i - 1; j++) {
             if(arr[j] > arr[j + 1]){
                 isSwaped = true;
                 swap(arr, j, j + 1);
             }
        }
        if(!isSwaped){
            //内层循环没有元素交换，整个数组有序
            break;
        }
    }
}

4.2.判断数组中元素是否有序排列（小->大）

/**
 * 判断数组中元素是否有序排列（小->大）
 * @param arr
 * @return
 */
public static boolean isSorted(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        if(arr[i] > arr[i + 1]) {
            return false;
        }
    }
    return true;
}

4.3.测试比较堆排序、冒泡排序、快速排序的算法的用时，体会算法的魅力

public static void main(String[] args) {
    SevenSort sort = new SevenSort();

    //测试3种算法在相同数量级上的元素的排序性能
    int n = 100000;
    int[] data1 = new int[n]; //冒泡耗时极长
    int[] data2;
    int[] data3;

    Random random = new Random();

    for (int i = 0; i < data1.length; i++) {
        data1[i] = random.nextInt(Integer.MAX_VALUE);
    }

    //此时data2和data3就是data1的一个深拷贝
    data2 = Arrays.copyOf(data1,n);
    data3 = Arrays.copyOf(data1,n);

    //bubbleSort 最慢
    long start = System.nanoTime(); //System.nanoTime() -> 获取当前系统时间，单位为纳秒 1ms = 100w ns
    long end;
    sort.bubbleSort(data1);
    if(isSorted(data1)){
        end = System.nanoTime();
        System.out.println("bubble Sort 共耗时：" + (end - start) / 1000000 + "ms");
    }

    //heapSort 中
    start = System.nanoTime();
    sort.heapSort(data2);
    if(isSorted(data2)){
        end = System.nanoTime();
        System.out.println("heap Sort 共耗时：" + (end - start) / 1000000 + "ms");
    }

    //quickSort 最快
    start = System.nanoTime();
    Arrays.sort(data3);  //默认使用jdk内置的双轴快速排序/归并排序
    if(isSorted(data3)){
        end = System.nanoTime();
        System.out.println("quick sort 共耗时：" + (end - start) / 1000000 + "ms");
    }
}