033、归并排序（labuladong）

归并排序

基于labuladong的算法网站，归并排序详解及应用

1、算法思路

所有的递归算法的本质都是：遍历一颗递归树，然后在节点（前中后序位置）上执行代码。

归并排序的代码框架：

// 定义：排序 nums[lo..hi]
void sort(int[] nums, int lo, int hi) {
    if (lo == hi) {
        return;
    }
    int mid = (lo + hi) / 2;
    // 利用定义，排序 nums[lo..mid]
    sort(nums, lo, mid);
    // 利用定义，排序 nums[mid+1..hi]
    sort(nums, mid + 1, hi);

    /****** 后序位置 ******/
    // 此时两部分子数组已经被排好序
    // 合并两个有序数组，使 nums[lo..hi] 有序
    merge(nums, lo, mid, hi);
    /*********************/
}

// 将有序数组 nums[lo..mid] 和有序数组 nums[mid+1..hi]
// 合并为有序数组 nums[lo..hi]
void merge(int[] nums, int lo, int mid, int hi);

归并排序就是先把左半边数组排好序，然后把右半边数组排好序，再将两个数组合并，和后序遍历数组的框架很相似。

2、代码实现及分析

力扣第912题，排序数组

[912]排序数组

//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    public int[] sortArray(int[] nums) {
        sort(nums, 0, nums.length - 1);
        return nums;
    }

    // 将数组left到right位置上的元素进行从小到大的排序，使用归并排序
    void sort(int[] nums, int left, int right) {
        // base case
        if (left == right) {
            return;
        }
        int mid = left + (right - left) / 2;
        sort(nums, left, mid);
        sort(nums, mid + 1, right);
        merge(nums, left, mid, right);
    }

    // 将排序好的数组合并
    void merge(int[] nums, int left, int mid, int right) {
        // 创建一个新的数组
        int[] array = new int[right - left + 1];
        int p1 = left, p2 = mid + 1, index = 0;
        while (p1 <= mid && p2 <= right) {
            if (nums[p1] <= nums[p2]) {
                array[index++] = nums[p1++];
            } else {
                array[index++] = nums[p2++];
            }
        }
        while (p1 <= mid) {
            array[index++] = nums[p1++];
        }
        while (p2 <= right) {
            array[index++] = nums[p2++];
        }
        index = 0;
        // 将新数组排完序的元素放入旧数组中
        for (; index < array.length; index++) {
            nums[index + left] = array[index];
        }
    }
}

3、其他应用

（1）数组中的逆序对

力扣剑指Offer第51题，数组中的逆序对

[剑指 Offer 51]数组中的逆序对

class Solution {
    public int reversePairs(int[] nums) {
        // 记录数组的长度
        int len = nums.length;
        if (len < 2) {
            return 0;
        }
        // 辅助数组
        int[] temp = new int[len];
        return reversePairs(nums, 0, len - 1, temp);
    }

    // 计算该数组元素逆序对的个数
    int reversePairs(int[] nums, int left, int right, int[] temp) {
        // base case
        if (left == right) {
            return 0;
        }
        int mid = left + (right - left) / 2;
        // 计算左边数组中的逆序对个数，并让nums数组左边有序
        int leftPairs = reversePairs(nums, left, mid, temp);
        // 计算右边数组中逆序对得到个数，并让nums数组右边有序
        int rightPais = reversePairs(nums, mid + 1, right, temp);
        // 优化(如果第一个有序数组的最后一个元素比第二个有序数组的第一个元素还要小，就不需要进行归并)
        if (nums[mid] <= nums[mid + 1]) {
            return leftPairs + rightPais;
        }
        // 将数组左边和右边两个有序数组进行归并，计算此时的逆序对个数
        int mergePairs = merge(nums, left, mid, right, temp);
        return mergePairs + leftPairs + rightPais;
    }

    // 归并排序时候计算逆序对的个数
    int merge(int[] nums, int left, int mid, int right, int[] temp) {
        int count = 0;
        for (int index = left; index <= right; index++) {
            temp[index] = nums[index];
        }
        int i = left, j = mid + 1;
        for (int k = left; k <= right; k++) {
            if (i == mid + 1) {
                nums[k] = temp[j++];
            } else if (j == right + 1) {
                nums[k] = temp[i++];
            } else if (temp[i] > temp[j]) {
                count += mid - i + 1;
                nums[k] = temp[j++];
            } else if (temp[i] <= temp[j]) {
                nums[k] = temp[i++];
            }
        }
        return count;
    }
}

（2）计算右侧小于当前元素的个数

力扣第315题，计算右侧小于当前元素的个数

原始数组不变，对下标数组进行排序；比较的时候到原始数组里看数值，记录结果的时候用下标数组的值。

 [315]计算右侧小于当前元素的个数

class Solution {
    public List<Integer> countSmaller(int[] nums) {
        int len = nums.length;
        List<Integer> res = new ArrayList<>(len);
        // 创建索引数组
        int[] indexs = new int[len];
        for (int i = 0; i < len; i++) {
            indexs[i] = i;// 进行归并排序的时候是进行索引数组的排序
        }
        // 临时数组
        int[] temp = new int[len];
        // 记录结果的数组
        int[] ans = new int[len];// 不用进行动态扩容
        reversePair(nums, 0, len - 1, indexs, temp, ans);
        // 将结果数组中的结果放入链表中
        for (int i = 0; i < len; i++) {
            res.add(ans[i]);
        }
        return res;
    }

    /**
     * @param nums：原始数组
     * @param left：原始数组的left位置
     * @param right：原始数组的right位置
     * @param indexs：索引数组，按照nums元素值从小到大进行排序
     * @param temp：辅助数组
     * @param ans：结果数组
     */
    void reversePair(int[] nums, int left, int right, int[] indexs, int[] temp, int[] ans) {
        // base case
        if (left == right) {
            return;
        }
        // 左侧有序
        int mid = left + (right - left) / 2;
        reversePair(nums, left, mid, indexs, temp, ans);
        // 右侧有序
        reversePair(nums, mid + 1, right, indexs, temp, ans);
        // 优化
        if (nums[indexs[mid]] <= nums[indexs[mid + 1]]) {
            return;
        }
        // 归并
        merge(nums, left, mid, right, indexs, temp, ans);
    }

    // 归并
    void merge(int[] nums, int left, int mid, int right, int[] indexs, int[] temp, int[] ans) {
        // 将索引数组下标拷贝到临时数组中
        for (int i = left; i <= right; i++) {
            temp[i] = indexs[i];
        }
        // 比较元素大小
        int i = left, j = mid + 1;
        for (int k = left; k <= right; k++) {
            if (i > mid) {
                indexs[k] = temp[j++];
            } else if (j > right) {
                indexs[k] = temp[i++];
                ans[indexs[k]] += right - mid;
            } else if (nums[temp[i]] > nums[temp[j]]) {
                indexs[k] = temp[j++];
            } else {
                // 每个数后面有多少个数比它小
                indexs[k] = temp[i++];
                ans[indexs[k]] += (j - mid - 1);
            }
        }
    }
}

（3）翻转对

力扣第493题，翻转对；重点是先计数后归并

[493]翻转对

class Solution {
    public int reversePairs(int[] nums) {
        int len = nums.length;
        // 如果数组的长度小于2，那么不存在重要翻转对
        if (len < 2) {
            return 0;
        }
        // 创建辅助数组
        int[] temp = new int[len];
        return reverse(nums, 0, len - 1, temp);
    }

    int reverse(int[] nums, int left, int right, int[] temp) {
        if (left == right) {
            return 0;
        }
        int mid = left + (right - left) / 2;
        int leftPairs = reverse(nums, left, mid, temp);
        int rightPairs = reverse(nums, mid + 1, right, temp);
        // 优化
/*        if (nums[mid] / 2 < nums[mid + 1]) {
            return leftPairs + rightPairs;
        }*/
        int mergePairs = merge(nums, left, mid, right, temp);
        return mergePairs + leftPairs + rightPairs;
    }

    int merge(int[] nums, int left, int mid, int right, int[] temp) {
        // 将元素拷贝到辅助数组中
        for (int i = left; i <= right; i++) {
            temp[i] = nums[i];
        }
        // 指针
        int i = left, j = mid + 1;
        int count = 0;
        // 先计数
        while (i <= mid && j <= right) {
            if ((long) nums[i] > 2 * (long) nums[j]) {
                count += (mid + 1 - i);
                j++;
            } else {
                i++;
            }
        }
        i = left;
        j = mid + 1;
        // 后排序
        for (int k = left; k <= right; k++) {
            if (i > mid) {
                nums[k] = temp[j++];
            } else if (j > right) {
                nums[k] = temp[i++];
            } else if (temp[i] <= temp[j]) {
                nums[k] = temp[i++];
            } else {
                nums[k] = temp[j++];
            }
        }
        // 返回
        return count;
    }
}