排序算法杂谈（三） —— 归并排序的非递归实现

1. 递归

在众多排序算法中，归并排序（Merge Sort）和快速排序（Quick Sort）都是时间复杂度为 O(nlog2n) 的高效排序。

这两种排序有一种共性，就是运用到了递归的思想。

在程序设计中，递归是一个很有用的性质，用递归写出来的算法，一般来说都很简洁明了，易于理解。

例如归并排序：

public final class MergeSort extends BasicMergeSort {

    @Override
    public void sort(int[] array) {
        sort(array, 0, array.length - 1);
    }

    private void sort(int[] array, int left, int right) {
        if (left < right) {
            int mid = ArrayHelper.getMiddle(left, right);
            sort(array, left, mid);
            sort(array, mid + 1, right);
            mergeSolution.merge(array, left, right);
        }
    }
}

其中，mergeSolution.merge() 是将两个有序数组合并成一个有序数组的接口，详细内容可以参见：

https://www.cnblogs.com/jing-an-feng-shao/p/9038915.html

然而，漂亮的代码与高效的代码往往是相冲的。递归存在一个很致命的缺点。

众所周知，Java 程序中的数据，存放在堆栈（Stack）空间中，堆栈具有访问效率高，速度快的优点，但同时其分配的空间往往是有限的。

在递归过程中，会把上层的数据不断地压入堆栈空间中。如果递归地深度过大，在达到递归的结束条件之前，堆栈中的数据已经溢出，那么就会导致程序崩溃。

StackOverFlow 这个异常，相信读者见到的次数不在少数。

2. 递归转循环

所以，在这种情况下，往往就需要将递归结构转化为循环结构去解决问题。

那么，怎么进行转化呢？这时候就要从递归的本质出发。

递归是什么？它是 数据的传递 + 数据的压栈。

所以解决了怎么传递数据的问题和怎么数据压栈的问题，就能将递归转化为循环，那么自然而然地想到了：

• 记录传递的数据 -> 利用自定义对象 Record 记录传递的数据。
• 利用堆栈的结构 -> 利用程序手动将 Stack<Record> 进行压栈的操作。

最后，通过迭代自定义的堆栈内数据，达到递归地效果。

3. 归并排序的非递归实现

首先需要明确的一点，是归并排序在递归地过程中传递什么数据？

显然是两个子数组的左、中、右节点，其中中节点时刻已通过计算得出的，可有可无。

那么我们现在就可以设计对象 Record（为方便使用，这里记录了中节点）：

    private static class Record {
        int left;
        int mid;
        int right;

        private Record(int left, int mid, int right) {
            this.left = left;
            this.mid = mid;
            this.right = right;
        }
    }

其次，如何将 Record 显示地入栈？

假设现在我们正在进行长度为 8 的数组排序，那么显然，我们最终希望堆栈中的数据是这样的（方便起见，这里的 Record 不计中节点）：

这样的堆栈结构，自上而下进行合并，就是我们期望的归并排序的合并顺序。

这样的结构是不是很眼熟？

没错，看到这个图，我们很自然地会想到 汉诺塔（Tower of Hanoi）。

那么又是很自然地，除了目标堆栈，还需要申请另外 2 个辅助空间去完成压栈工作。

方便起见，这里的辅助空间也使用堆栈结构。

所以现在就有了：初始堆栈 stack1，目标堆栈 stack2，中转堆栈 stack3。

1. 将原始数组压入 stack1。
2. 将 stack1 中的数据全部取出，放入 stack3。
3. 依次取出 stack3 中的 Record，压入 stack2；同时判断 left < mid，若是，将 Record(left, mid) 压入 stack1；判断 mid+1 < right，若是，将 Record(mid+1, right) 压入stack1。
4. 若 stack1 中仍有数据，循环步骤 2、3。
5. 若 stack1 已经清空，表明 stack2 已经满足上图结构，即全部数据已经压入 stack2 中，循环归并 stack2 中的记录，直至 stack2 清空。

于是，有如下代码：

public class MergeSortLoop extends BasicMergeSort {

    private static final Stack<Record> stack1 = new Stack();
    private static final Stack<Record> stack2 = new Stack();
    private static final Stack<Record> stack3 = new Stack();

    @Override
    public void sort(int[] array) {
        int left = 0;
        int right = array.length - 1;
        pushStack(stack1, left, right);
        while (!stack1.isEmpty()) {
            popAll(stack1, stack3);
            while (!stack3.isEmpty()) {
                Record record = stack3.pop();
                stack2.push(record);
                if (record.left < record.mid) {
                    pushStack(stack1, record.left, record.mid);
                }
                if (record.mid + 1 < record.right) {
                    pushStack(stack1, record.mid + 1, record.right);
                }
            }
        }
        while (!stack2.isEmpty()) {
            Record toBeMerged = stack2.pop();
            mergeSolution.merge(array, toBeMerged.left, toBeMerged.right);
        }
    }


    private void popAll(Stack<Record> source, Stack<Record> target) {
        while (!source.isEmpty()) {
            target.push(source.pop());
        }
    }

    private void pushStack(Stack<Record> stack, int left, int right) {
        Record record = new Record(left, ArrayHelper.getMiddle(left, right), right);
        stack.push(record);
    }

    private static class Record {
        int left;
        int mid;
        int right;

        private Record(int left, int mid, int right) {
            this.left = left;
            this.mid = mid;
            this.right = right;
        }
    }
}

4. 另一种堆栈模型

将递归结构转为循环结构，核心思想就是构建堆栈模型。

之前写到的这种 类-汉诺塔 堆栈模型，其结构非常漂亮，但是构造效率却相对较低（其中需要用到 2 个额外的辅助空间，更多的入栈-出栈操作）。

其实，仔细回想归并排序的递归过程，并不是依从这种 类-汉诺塔 堆栈模型的顺序去递归的，其递归过程类似以下堆栈模型：

 

构造这种堆栈结构，只需要初始堆栈 stack1，目标堆栈 stack2。

1. 将原始数组压入 stack1。
2. 取出 stack1 栈顶数据，放入 stack2。
3. 根据取出的数据 record，判断 left < mid，若是，将 Record(left, mid) 压入 stack1；判断 mid+1 < right，若是，将 Record(mid+1, right) 压入stack1。
4. 若 stack1 中仍有数据，循环步骤 2、3。
5. 若 stack1 已经清空，表明 stack2 已经满足上图结构，即全部数据已经压入 stack2 中，循环归并 stack2 中的记录，直至 stack2 清空。

与之前的过程相比，唯一的变化就在于第 2 步，只需要取出栈顶数据，而不是堆栈 stack1 中的所有数据。