归并排序与逆数对

归并排序与逆数对

一）分治法

分而治之，大化小。

步骤：

1. 分解；
2. 递归解决子问题；
3. 合并；

详情见：百度百科

二）归并排序

图源自：图解排序算法（四）之归并排序

步骤见图：

1. 分解：递归分解数组，左半部分和右半部分
2. 解决：递归
3. 合并：合并左半部分和右半部分，都局部有序。

Java实现：

public class Merge {
    private static int[] init(int len) {
        int[] data = new int[len];
        Random random = new Random();
        for (int i = 0; i < len; ++i) {
            data[i] = random.nextInt(100);
        }
        return data;
    }

    public static void sort(int[] data) {
        // temp: 减少递归数组创建
        int[] temp = new int[data.length];
        System.arraycopy(data, 0, temp, 0, data.length);
        sort(data, 0, data.length - 1, temp);
    }
    
    private static void sort(int[] data, int low, int high, int[] temp) {
        if (low >= high) {
            return;
        }

        int mid = (low + high) >>> 1;
        sort(data, low, mid, temp);
        sort(data, mid + 1, high, temp);
        merge(data, low, mid, high, temp);
    }
    
    private static void merge(int[] data, int low, int mid, int high, int[] temp) {
        int indexLeft = low;
        int indexRight = mid + 1;
        int index = low;
        while (indexLeft <= mid && indexRight <= high) {
            if (data[indexLeft] < data[indexRight]) {
                temp[index++] = data[indexLeft++];
            } else {
                temp[index++] = data[indexRight++];
            }
        }
        int dataIndex = indexLeft <= mid ? indexLeft : indexRight;
        int dataEnd = indexLeft <= mid ? mid : high;
        while (dataIndex <= dataEnd) {
            temp[index++] = data[dataIndex++];
        }

        for (int i = low; i <= high; i++) {
            data[i] = temp[i];
        }
    }

    public static void main(String[] args) {
        int[] data = init(20);
        sort(data);
        System.out.println(Arrays.toString(data));
    }
}

三）逆数对

给定一个数组序列：[3,5,4,2,1]。[0,3]=<3,2>成为逆数对，左边的值>右边的值。即索引小的值大。

Java实现：关键是在merge阶段统计，有序序列L1和序列L2，归并时，出现符合逆序对L1.a1 > L2.a2，则L1.a1后面的元素都大于L2.a2，则他们都是逆序对，累加其个数。

public class ReversePairs {
    public static void main(String[] args) {
        int[] nums = {4, 5, 6, 7};
        int res = new ReversePairs().reversePairs(nums);
        System.out.println(res);
    }

    public int reversePairs(int[] nums) {
        // temp: 减少递归数组创建
        int[] temp = new int[nums.length];
        return sort(nums, 0, nums.length - 1, temp);
    }

    private static int sort(int[] data, int low, int high, int[] temp) {
        if (low >= high) {
            return 0;
        }

        int mid = (low + high) >>> 1;
        int n1 = sort(data, low, mid, temp);
        int n2 = sort(data, mid + 1, high, temp);
        int n3 = merge(data, low, mid, high, temp);
        return n1 + n2 + n3;
    }
    private static int merge(int[] data, int low, int mid, int high, int[] temp) {
        int indexLeft = low;
        int indexRight = mid + 1;
        int index = low;
        int count = 0;
        while (indexLeft <= mid && indexRight <= high) {
            if (data[indexLeft] <= data[indexRight]) {
                temp[index++] = data[indexLeft++];
            } else {
                temp[index++] = data[indexRight++];
                count += mid - indexLeft + 1;
            }
        }
        int dataIndex = indexLeft <= mid ? indexLeft : indexRight;
        int dataEnd = indexLeft <= mid ? mid : high;
        while (dataIndex <= dataEnd) {
            temp[index++] = data[dataIndex++];
        }

        for (int i = low; i <= high; i++) {
            data[i] = temp[i];
        }

        return count;
    }
}