归并排序算法-稳定的排序算法

归并排序

归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。

一次归并操作的工作原理如下：

第一步：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
第二步：设定两个指针，最初位置分别为两个已经排序序列的起始位置
第三步：比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
重复步骤3直到某一指针超出序列尾
将另一序列剩下的所有元素直接复制到合并序列尾

递归法代码

package algorithm;

import java.util.Arrays;

/**
 * Created by obite on 15/11/11.
 * E-Mail:zhanlanstar@163.com
 */
 
public class TestMergeSort2 {

    public static void main(String[] args) {
//        int[] nums = IntStream.range(0, 20).map(item -> RandomUtils.nextInt(0, 100)).toArray();
        int[] nums = new int[]{9, 8, 7, 6, 5, 4, 3, 2, 10};
        int[] result = new int[nums.length];
        System.out.println("Origin:" + Arrays.toString(nums));
        new MergeSort().sort(nums, result, 0, nums.length - 1);
        System.out.println("Result:" + Arrays.toString(result));
    }

    /**
     * 归并排序
     * <p/>
     * 一次归并操作的工作原理如下：
     * 第一步：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
     * 第二步：设定两个指针，最初位置分别为两个已经排序序列的起始位置
     * 第三步：比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
     * 重复步骤3直到某一指针超出序列尾
     * 将另一序列剩下的所有元素直接复制到合并序列尾
     * <p/>
     * 归并排序把数组分为只包含一个数字的组，然后一次次归并成最终结果。
     * <p/>
     * 这个是递归版本的，更容易理解一些。
     */
    static class MergeSort {

        /**
         * @param origin 原始数组，也是最终排序正确排序的数组
         * @param result 辅助数组，也是最终排序正确排序的数组
         * @param start  起始位置，开始是0
         * @param end    结束位置，开始是数组长度-1，即最后一个下标
         */
        public void sort(int[] origin, int[] result, int start, int end) {
            //浪费了我几乎昨天一个下午，再加上今天上午的时间的一个算法。归并排序，原因只是因为我少写了一个括号。
            //运算符的优先级：+ - 为4，* / % 为3，<< >> 为5，所以写成 int half = start + (end - start) >>> 1;是错的。
            int half = start + ((end - start) >>> 1);
            if (start >= end) {
                return;
            }

            // 递归排序子序列1和子序列2
            sort(origin, result, start, half);
            sort(origin, result, half + 1, end);

            // 归并每次排序后的两个子串
            merge(origin, result, start, half + 1, end);
        }

        /**
         * @param origin 是原始数组，每次合并后会把b的结果复制到a中
         * @param result 辅助作用，也是最终的结果集。
         * @param start  是第一个待合并子数组的起始位置。
         * @param half   是第二个子数组的结束位置。
         * @param end    第二个子数组的起始位置，也是当前已经排序到的位置
         */
        public void merge(int[] origin, int[] result, int start, int half, int end) {
            // 归并两个排序结果
            int i = start, j = half, k = start;
            while (i < half && j <= end) {
                result[k++] = origin[i] <= origin[j] ? origin[i++] : origin[j++];
            }

            // 剩下的元素，直接写入（只会有一个数组会有剩下的元素）
            while (i < half) {
                result[k++] = origin[i++];
            }
            while (j <= end) {
                result[k++] = origin[j++];
            }

            // 这里把新合并的结果写入到原始数组中，必须写入
            for (int x = start; x < k; x++) {
                origin[x] = result[x];
            }
            display(origin, result, start, k);
        }

        /**
         * 展示结果，并无其他用处
         */
        public void display(int[] origin, int[] result, int start, int end) {
            System.out.println(String.format("{%s},{%s},{%s}",
                    displayArrayToString(Arrays.copyOfRange(origin, 0, start)),// 先前已排序
                    displayArrayToString(Arrays.copyOfRange(result, start, end)),// 当前排序
                    displayArrayToString(Arrays.copyOfRange(origin, end, origin.length))));// 未排序
        }

        public String displayArrayToString(int[] array) {
            String s = Arrays.toString(array);
            return s.substring(1, s.length() - 1);
        }
    }
}

递归法排序演算（程序输出）

Origin:[9, 8, 7, 6, 5, 4, 3, 2, 10]
{},{8, 9},{7, 6, 5, 4, 3, 2, 10}
{},{7, 8, 9},{6, 5, 4, 3, 2, 10}
{7, 8, 9},{5, 6},{4, 3, 2, 10}
{},{5, 6, 7, 8, 9},{4, 3, 2, 10}
{5, 6, 7, 8, 9},{3, 4},{2, 10}
{5, 6, 7, 8, 9, 3, 4},{2, 10},{}
{5, 6, 7, 8, 9},{2, 3, 4, 10},{}
{},{2, 3, 4, 5, 6, 7, 8, 9, 10},{}
Result:[2, 3, 4, 5, 6, 7, 8, 9, 10]

容易理解的版本

上述写法是原始算法的版本，由于是在同一个数组中操作，不易理解，这里通过创建多个数组产生更容易理解的版本，但是会浪费一些空间，仅供参考。

public class TestMergeSort {

    public static void main(String[] args) {
        int[] nums = IntStream.range(0, 20).map(item -> RandomUtils.nextInt(0, 100)).toArray();
//        int[] nums = new int[]{9, 8, 7, 6, 5, 4, 3, 2, 10};
        int[] newNums = mergeSort(nums, 0, nums.length - 1);
        System.out.println(Arrays.toString(newNums));
    }

    /**
     * 这个写法很好理解，但会浪费比较多空间，产生了很多int[]数组
     */
    public static int[] mergeSort(int[] nums, int l, int h) {
        if (l == h)
            return new int[]{nums[l]};

        int mid = l + (h - l) / 2;
        int[] leftArr = mergeSort(nums, l, mid); //左有序数组
        int[] rightArr = mergeSort(nums, mid + 1, h); //右有序数组
        int[] newNum = new int[leftArr.length + rightArr.length]; //新有序数组

        // 归并两个排序结果
        int m = 0, i = 0, j = 0;
        while (i < leftArr.length && j < rightArr.length) {
            newNum[m++] = leftArr[i] < rightArr[j] ? leftArr[i++] : rightArr[j++];
        }
        // 剩下的元素，直接写入（只会有一个数组会有剩下的元素）
        while (i < leftArr.length)
            newNum[m++] = leftArr[i++];
        while (j < rightArr.length)
            newNum[m++] = rightArr[j++];
        return newNum;
    }
}