LeetCode入门指南 之 排序

912. 排序数组

给你一个整数数组 nums，请你将该数组升序排列。

归并排序

public class Sort {
    //归并排序
    public static int[] MergeSort(int[] arr) {
        int[] temp = new int[arr.length];
        mergeSort(arr, 0, arr.length - 1, temp);
        return arr;
    }

    private static void mergeSort(int[] arr, int left, int right, int[] temp) {
        if (left >= right) {
            return;
        }

        int mid = (left + right) / 2;
        mergeSort(arr, left, mid, temp);
        mergeSort(arr, mid + 1, right, temp);

        merge(arr, left, mid, right, temp);
    }

    private static void merge(int[] arr, int left, int mid, int right, int[] temp) {
        int i = left, j = mid + 1;
        int k = 0;
        while(i <= mid && j <= right) {
            if (arr[i] < arr[j]) {		//改成 <= 就是稳定的
                temp[k++] = arr[i++];
            } else {
                temp[k++] = arr[j++];
            }
        }

        //如果左边还有剩余
        while(i <= mid) {
            temp[k++] = arr[i++];
        }

        //如果右边还有剩余
        while(j <= right) {
            temp[k++] = arr[j++];
        }

        //将temp中的数据放回arr
        k = 0;
        for (int m = left; m <= right; m++) {
            arr[m] = temp[k++];
        }
    }
}

稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的。稳定性的好处：排序算法如果是稳定的，那么从一个键上排序，然后再从另一个键上排序，第一个键排序的结果可以为第二个键排序所用。推荐阅读：堆排序为什么不稳定_为什么要区分稳定和不稳定排序

时间复杂度：平均 O(nlogn) 最优 O(nlogn) 最差 O(nlogn)

空间复杂度：O(n) = max(O(logn)——递归栈深度, O(n)——临时数组)

是否稳定性算法: 是/否，取决于merge函数的实现。看merge是否会导致两个值相同的元素发生前后顺序的改变，现在的实现是不稳定的。（如：[ 1, 2, 3, 2] 。第一次合并：1和2、3和2合并有[1, 2, 2, 3]；第二次合并：1, 2 和 2, 3合并得[1, 2, 2, 3]，但已经交换了两个2的先后）

快速排序

public class Sort {
    //快速排序
    public static int[] QuickSort(int[] arr) {
        quickSort(arr, 0, arr.length - 1);
        return arr;
    }

    private static void quickSort(int[] arr, int left, int right) {
        if (left >= right) {
            return;
        }

        int mid = partition(arr, left, right);
        quickSort(arr, left, mid - 1);
        quickSort(arr, mid + 1, right);
    }

    private static Random random = new Random(47);

    private static int partition(int[] arr, int left, int right) {
        int rand = left + random.nextInt(right - left + 1);
        swap(arr, left, rand);
        int pivot = arr[left];

        while (left < right) {
            // 右边找一个 小于等于 pivot 的元素
            while (left < right && arr[right] > pivot) {
                right--;
            }

            // 找到了就将右边的元素放到左边
            if (left < right) {
                swap(arr, left, right);
                left++;
            }

            // 左边找一个 大于 pivot 的元素
            while (left < right && arr[left] <= pivot) {
                left++;
            }

            if (left < right) {
                swap(arr, left, right);
                right--;
            }
        }

        //跳出循环时 left = right
        arr[left] = pivot;
        return left;
    }

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

• 归并排序是标准的分治法模板
• 快速排序只有分没有治，因为在分之前就已经做好了要做的事

时间复杂度：平均 O(nlogn) 最优 O(nlogn) 最差O(n²)

空间复杂度：O(logn) —— 递归栈深度

是否稳定排序算法：否 （如：[ 4, 2, 3, 2] -> [2, 2, 3, 4]）这里的 4 - 2 交换，导致原有的 2、2排序被打乱。

堆排序

堆：一种满足堆积性质的完全二叉树，需要满足如下性质：

1. 堆中的某个节点的值总是大于等于或小于等于其父节点的值；

2. 堆总是一颗完全二叉树；

public class Sort {
     //堆排序
     public static void HeapSort(int[] arr) {
         buildMaxHeap(arr);
         for (int i = arr.length - 1; i > 0; i--) {
             swap(arr, 0, i);       //将堆顶元素和最后一个叶子结点交换，最大值放到数组尾部
             heapify(arr, 0, i);    //对前i个元素构建新的大顶堆
         }
     }

     //构建大顶堆(从第一个非叶子结点从右至左，从下至上)
     private static void buildMaxHeap(int[] arr) {
         for (int i = arr.length / 2 - 1; i >= 0; i--) {
            heapify(arr, i, arr.length);
         }
     }

     //以i为根的堆调整(大顶堆)
     private static void heapify(int[]arr, int i, int length) {
        int left = 2*i + 1;
        int right = 2*i + 2;

        int largest = i;  //假设根节点i为最大值

        // 左子结点存在且大于根节点
        if (left < length && arr[left] > arr[largest]) {
            largest = left;
        }

        // 右子结点存在且大于根节点
        if (right < length && arr[right] > arr[largest]) {
            largest = right;
        }

        if (largest != i) {         //说明最大值为其子结点
            swap(arr, largest, i);
            heapify(arr, largest, length);  //交换过后再调整其子结点为根的堆
        }
     }

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

时间复杂度：平均 O(nlogn) 最优 O(nlogn) 最差 O(nlogn)

空间复杂度：O(logn) - 递归堆栈

是否稳定排序算法：否。比如：3 27 36 27（小顶堆），如果堆顶3先输出，则，第三层的27（最后一个27）跑到堆顶，然后堆稳定，继续输出堆顶，是刚才那个27，这样说明后面的27先于第二个位置的27输出，不稳定。

排序结果测试类

public class Test {
    private static final int num = 8000000;
    private static int[] arr = new int[num];

    private static SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH::mm:ss");

    private static void generateArr() {
        //给相同的种子使得每次生成的伪随机数序列相同
        Random random = new Random(47);
        for (int i = 0; i < num; i++) {
            arr[i] = random.nextInt(num);
        }
    }

    private static boolean isOrdered(int[] arr) {
        boolean order = true;
        for (int i = 0; i < arr.length - 1; i++) {
            if (arr[i] > arr[i + 1]) {
                order = false;
                break;
            }
        }
        return order;
    }

    public static void test(SortI sort) {
        generateArr();
        Date startDate = new Date();
        System.out.println("start : " + formatter.format(startDate));

        sort.sort(arr);

        Date endDate = new Date();
        System.out.println("end : " + formatter.format(endDate));
        System.out.println("排序正确性：" + isOrdered(arr));
    }

    public static void main(String[] args) {
        Test.test(Sort::MergeSort);
        Test.test(Sort::QuickSort);
        Test.test(Sort::HeapSort);
    }

}

interface SortI {
    void sort(int[] arr);
}