归并排序

我们经常遇到这样一种情景：学习和理解了一种算法，也写出了demo程序，可真正须要时。却写不出完整的代码。

出现这样的问题的解决办法可能是我们仍旧没有透彻地理解那个算法。以归并排序为例。算法的发明必然经历了长期的不断推演、修正的过程。

而我们学习时却是直接理解终于的算法，而没有经历那个推演、修正的过程，所以对它的理解就不深刻，也忽略了一些细节。本文尝试揣測归并排序算法的发明过程，以加深对它理解。

算法的任务

将乱序的8张纸牌依照从小到大的顺序依次放到桌面上。

最初的想法

1. 假设仅仅有 1 张纸牌，直接放在桌子上就好；
2. 假设有 2 张纸牌，左手拿1张，右手拿1张；把小的先放到桌子上，再把还有一张放置于其后；
3. 假设有 3 张纸牌：
   3.1 对前2张纸牌运行#2操作
   3.2 左手拿起排好序的前2张牌，右手拿起第3张牌
   3.3 选左手第一张和右手第一张中小的放到桌上…，假设右手没有牌了。直接将左手剩余的牌放到桌上。
4. 假设有 4 张纸牌：
   4.1 对前2张纸牌运行#2操作，对后2张牌运行#2操作
   4.2 左手拿起排好序的前2张牌，右手拿起排好序的后2张牌
   4.3 选左手第一张和右手第一张中小的放到桌上…，假设左（右）手没有牌了。直接将左手剩余的牌放到桌上。

5. 假设有 5 张纸牌：
   5.1 对前3张纸牌运行#3操作，对后2张牌运行#2操作
   5.2 左手拿起排好序的前3张牌，右手拿起排好序的后2张牌
   5.3 选左手第一张和右手第一张中小的放到桌上…。假设左（右）手没有牌了，直接将左手剩余的牌放到桌上。

推演

对8张牌排序的做法是：

• 将8张牌对半分
  
  • 将前4张牌对半分
    
    • 将前2张牌对半分
    • 合并前2张牌
    • 将后2张牌对半分
    • 后前后2张牌
  • 合并前4张牌
  • 将后4张牌对半分
    
    • 将前2张牌对半分
    • 合并前2张牌
    • 将后2张牌对半分
    • 后前后2张牌
  • 合并后4张牌
• 合并8张牌

总结

要对N个数进行排序，就递归地将N个数二分，直到每部分仅仅有一个数。而后递归地合并每一个部分。合并两个数后，这两个数有序。合并四个数时，这四个数有序；合并八个数时，这八个数有序……合并 N 个数时，排序完毕。

代码实现

import java.util.Arrays;
import java.util.Random;

public class MergeSort {

    private static int[] aux;

    public static void sort(int[] a) {
        aux = new int[a.length];
        sort(a, 0, a.length - 1);
    }

    private static void sort(int[] a, int start, int end) {
        if (start >= end) {
            return;
        }
        final int mid = (start + end) >>> 1;
        sort(a, start, mid);
        sort(a, mid + 1, end);
        merge(a, start, mid, end);
    }

    private static void merge(int[] a, int start, int mid, int end) {
        for (int i = start; i <= end; i++) {
            aux[i] = a[i];
        }
        int i = start;
        int j = mid + 1;
        for (int k = start; k <= end; k++) {
            if (i > mid) {
                a[k] = aux[j++];
            } else if (j > end) {
                a[k] = aux[i++];
            } else if (aux[i] > a[j]) {
                a[k] = aux[j++];
            } else {
                a[k] = aux[i++];
            }
        }
    }

    public static void main(String[] args) {
        final int N = 10;
        final Random random = new Random(System.currentTimeMillis());
        final int[] a = new int[N];
        for (int i = 0; i < N; i++) {
            a[i] = random.nextInt(N << 1);
        }
        System.out.println(Arrays.toString(a));
        sort(a);
        System.out.println(Arrays.toString(a));
    }
}

非递归实现：

import java.util.Arrays;
import java.util.Random;

public class MergeSort {

    private static int[] aux;

    public static void sort(int[] a) {
        aux = new int[a.length];
        for (int size = 1; size < a.length; size = size << 1) {
            for (int start = 0; start < a.length - size; start += size + size) {
                final int mid = start + size - 1;
                final int end = Math.min(mid + size, a.length - 1);
                merge(a, start, mid, end);
            }
        }
    }

    private static void merge(int[] a, int start, int mid, int end) {
        for (int i = start; i <= end; i++) {
            aux[i] = a[i];
        }
        int i = start;
        int j = mid + 1;
        for (int k = start; k <= end; k++) {
            if (i > mid) {
                a[k] = aux[j++];
            } else if (j > end) {
                a[k] = aux[i++];
            } else if (aux[i] > a[j]) {
                a[k] = aux[j++];
            } else {
                a[k] = aux[i++];
            }
        }
    }

    public static void main(String[] args) {
        final int N = 10000;
        final Random random = new Random(System.currentTimeMillis());
        final int[] a = new int[N];
        for (int i = 0; i < N; i++) {
            a[i] = random.nextInt(N << 1);
        }
        System.out.println(Arrays.toString(a));
        sort(a);
        String str = Arrays.toString(a);
        System.out.println(str);
        Arrays.sort(a);
        System.out.println(str.equals(Arrays.toString(a)));
    }
}