【算法基础】1.2 归并排序

本文主要讲解归并排序及其思路的相关应用。

归并排序

题目描述

给定你一个长度为 n 的整数数列。

请你使用归并排序对这个数列按照从小到大进行排序。

并将排好序的数列按顺序输出。

912. 排序数组 https://leetcode.cn/problems/sort-an-array/

数据范围
1≤n≤100000

解法

每次递归将当前数组分成两部分，分别对两部分进行归并排序。
将归并排序的结果合并成答案。

class Solution {
    public int[] sortArray(int[] nums) {
        int n = nums.length;
        mergeSort(nums, 0, n - 1);
        return nums;
    }

    public void mergeSort(int[] nums, int l, int r) {
        if (l >= r) return;
        int mid = l + r >> 1;
        mergeSort(nums, l, mid);
        mergeSort(nums, mid + 1, r);

        int[] tmp = new int[r - l + 1];
        int i = l, j = mid + 1, k = 0;
        while (i <= mid && j <= r) {
            if (nums[i] <= nums[j]) tmp[k++] = nums[i++];  // 归并排序是稳定的
            else tmp[k++] = nums[j++];
        }
        while (i <= mid) tmp[k++] = nums[i++];
        while (j <= mid) tmp[k++] = nums[j++];

        for (i = 0; i < k; ++i) nums[l + i] = tmp[i];	// 将排好序的tmp赋到原数组中
    }
}

讲解

mergeSort 和 快排不同的是，先递归排序，然后进行后续的操作。（即先分开，再归并，合二为一）

e.g.

由于左边和右边的子数组都排好了，所以递归排序之后的操作相当于是合并两个排序好的数组，这里使用双指针算法即可。使用两个指针从头遍历两个数组，哪个小取哪个放入结果。

逆序对的数量（归并排序的思路）

剑指 Offer 51. 数组中的逆序对 https://leetcode.cn/problems/shu-zu-zhong-de-ni-xu-dui-lcof/

题目描述

给定一个长度为 n 的整数数列，请你计算数列中的逆序对的数量。

逆序对的定义如下：对于数列的第 i 个和第 j 个元素，如果满足 i<j 且 a[i]>a[j]，则其为一个逆序对；否则不是。

数据范围
1 ≤ n ≤ 100000，
数列中的元素的取值范围 [1,109]。

解法

class Solution {
    public int reversePairs(int[] nums) {
        int n = nums.length;
        return mergeSort(nums, 0, n - 1);
    }

    public int mergeSort(int[] nums, int l, int r) {
        if (l >= r) return 0;
        int mid = l + r >> 1;
        int res = mergeSort(nums, l, mid) + mergeSort(nums, mid + 1, r);
        int[] tmp = new int[r - l + 1];
        int i = l, j = mid + 1, k = 0;
        while (i <= mid && j <= r) {
            if (nums[i] <= nums[j]) tmp[k++] = nums[i++];
            else {
                tmp[k++] = nums[j++];
                res += mid - i + 1;		// 注意加的数量是 mid - i + 1 而不是 1
            }
        }
        while (i <= mid) tmp[k++] = nums[i++];
        while (j <= r) tmp[k++] = nums[j++];
        for (i = 0; i < k; ++i) nums[l + i] = tmp[i];
        return res;
    }
}

可以看出和归并排序的代码几乎一模一样。

讲解

在归并排序中，我们讲到，在递归排序后的操作实际上就是将两个排序好的数组进行排序的过程。那么，当前一个数组中的数字 i 大于后一个数组中的数字 j 时，说明前一个数组中该数字 i 以及之后的数字都会比第二个数组中的数字 j 大，一共可以组成 mid - i + 1个逆序对。

注意！为什么是 mid - i + 1而不是 j - mid⭐⭐⭐

因为在比较左右两个数组的时候是从小到大比较的。

Q：为什么先放小的时候不能按 j - mid 来计算？
A：因为先放小的时候，当 j 更小的时候才会计算贡献 j - mid，但是它计算过一次之后会执行 j++ ，因此 当前 j 不能再和 之后的 i 进行匹配了，会少计算贡献。
而使用 i 来计算贡献 mid - i + 1 就不会出现这个问题。

修改后AC的代码

先把大的放进去就可以保证，对于每个当前的 j 贡献 j - mid 了。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[] a = new int[n];
        for (int i = 0; i < n; ++i) a[i] = scanner.nextInt();
        System.out.println(mergeSort(a, 0, n - 1));
    }

    public static long mergeSort(int[] a, int l, int r) {
        if (l >= r) return 0;
        int mid = l + r >> 1;
        long res = mergeSort(a, l, mid) + mergeSort(a, mid + 1, r);
        int[] t = new int[r - l + 1];
        int i = mid, j = r, k = r - l;
        while (i >= l && j >= mid + 1) {
            // 先把大的放进去
            if (a[j] >= a[i]) t[k--] = a[j--];
            else {
                res += j - mid;
                t[k--] = a[i--];
            }
        }
        while (i >= l) t[k--] = a[i--];
        while (j >= mid + 1) t[k--] = a[j--];
        for (i = 0; i < r - l + 1; ++i) a[l + i] = t[i];
        return res;
    }
}

---

时间复杂度

时间复杂度是O(NlogN)
一共有logN层，每次的复杂度是N，因此一共是NlogN。