排序与分治

本文内容：

• 排序算法
• 分治思想
• 题目实战

冒泡排序

每一轮都把最小（大）值，冒泡到最右边
每二轮都把第二小（大）值，冒泡到最右边
…

	public static void bubbleSort(int[] arr) {
        int len = arr.length;
        boolean flag = true;
        
        for (int i = 0; i < len - 1 && flag; i++) {
            flag = false;
            for (int j = 0; j < len - 1 - i; j++) {
                if(arr[j] > arr[j+1]){
                    swap(arr[j], arr[j+1]);
                    flag = true;
                }
            }
        }
    }

复杂度 $O(n^2)$、稳定排序算法

插入排序

第一个元素当成一个有序数组A，将后面的元素分别有序插入A

	public static void selectSort(int[] arr) {
        int len = arr.length;
        int cur, j;
        for (int i = 1; i < len; i++) {
            cur = arr[i];
            for (j = i - 1; j >= 0 && arr[j] > cur ; j--) {
                arr[j + 1] = arr[j];
            }
            arr[j + 1] = cur;
        }
    }

复杂度 $O(n^2)$、稳定排序算法

归并排序

把数组从中间划分成两个子数组
一直递归地把子数组划分成更小的子数组，直到子数组里面只有一个元素

    public static void mergeSort(int[] arr, int lo, int hi) {
        if(lo >= hi) return;
        int mid = lo + (hi - lo) / 2;
        mergeSort(arr, lo, mid);
        mergeSort(arr, mid + 1, hi);
        merge(arr, lo, mid, hi);
    }

    public static void merge(int[] arr, int lo, int mid, int hi) {
        int[] copy = arr.clone();
        int k = lo, i = lo, j = mid + 1;

        while(k <= hi){
            if(i > mid){
                arr[k++] = copy[j++];
            }else if (j > hi){
                arr[k++] = copy[i++];
            }else if(copy[j] < copy[i]){
                arr[k++] = copy[j++];
            }else {
                arr[k++] = copy[i++];
            }
        }
    }

$$T(n)=2\ast T(n/2)+O(n)$$

复杂度 $O(nlogn)$、稳定排序算法

快速排序

先选定一个元素，然后将全部小于它的元素放在它左边，将全部大于它的元素放在它右边。
将左边数组中，再重复步骤1
将右边的数组中，再重复步骤2

	public static void quickSort(int[] arr, int lo, int hi) {
        if(lo >= hi) return;
        int k = partition(arr, lo, hi);
        quickSort(arr, lo, k - 1);
        quickSort(arr, k + 1, hi);
    }

    public static int partition(int[] arr, int lo, int hi) {
        int rand = (int)(Math.random()*(hi - lo) + lo); // 随机生成一个标准值的下标
        swap(arr, rand, hi); // 交换最后一个元素与标准值，此时hi是标准值下标
        int i = lo, j = lo;
        for ( ; j < hi; j++) {
            if(arr[j] <= arr[hi]){
                swap(arr, i++, j);
            }
        }
        swap(arr, i, j);
        return i;
    }

拓扑排序

# TODO

分治思想

分治、把复杂问题拆解成若干个子问题去求解

题目实战

• leetcode-215 数组中的第K个最大元素
• leetcode-147 对链表进行插入排序
• leetcode-241 分治算法

其他阅读

• B站-Chengzhenbo 算法设计与分析Python
• B站-算法竞赛_陈锋 分治算法