归并排序

我们常常遇到这样一种情景：学习和理解了一种算法，也写出了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)));
    }
}