生活日用算法——归并排序的java实现

最近在看sort在1.7下的源码，发现在排序元素少于32的时候，使用的是Meger sort优化版——TimSort。本着溯本求源的精神，我先去看了下归并排序在JAVA的实现，虽然一直以来对归并排序的原理清楚的，但不曾自己写过。网上找了别人实现好的代码，然后自己理解后填上了注释，记录如下以供日后回顾（此代码的尾递归理论上可以转为迭代，以减少空间使用，防止栈的溢出）

 

首先，这里有一个基础的merge算法，实现对两个有序数组的合并。

/**
     * 将两个有序数组合并为一个（递增）  此处略微取巧，两个有序数组分别为a[beginFrist,beginSecond)与[beginSecond,endSecond]
     * @param a              指定数组A
     * @param beginFrist     第一个有序数组的开始位置
     * @param beginSecond    第一个有序数组的结束位置（第二个有序数组的开始位置）
     * @param endSecond      第二个有序数组的结束为止
     */
    private static void merge(int[] a, int beginFrist, int beginSecond, int endSecond) {
        //建立一个中间数组，用于存放这两个有序数组合并后的有序数组数据
        int[] tmp = new int[endSecond - beginFrist + 1];
        //初始化各中间变量
        int tempFristLocation = beginFrist, tempSecondLocation= beginSecond, tempLocation = 0;
        //遍历两个数组，并排序，知道一个数组被全部遍历为止。
        while (tempFristLocation < beginSecond && tempSecondLocation <= endSecond) {
            if (a[tempFristLocation] <= a[tempSecondLocation]) {
                tmp[tempLocation] = a[tempFristLocation];   
                tempFristLocation++;
            } else {
                tmp[tempLocation] = a[tempSecondLocation];
                tempSecondLocation++;
            }
            tempLocation++;
        }
        //把另一个为被完全遍历的数组剩余部分加在temp最后，因为两个数组本身有序，所以剩余部分一定比现有部分大。
        while (tempFristLocation < beginSecond) {
            tmp[tempLocation] = a[tempFristLocation];
            tempFristLocation++;
            tempLocation++;
        }
        while (tempSecondLocation <= endSecond) {
            tmp[tempLocation] = a[tempSecondLocation];
            tempSecondLocation++;
            tempLocation++;
        }
        //复制temp到给的数组a
        System.arraycopy(tmp, 0, a, beginFrist, tmp.length);
    }

 

归并主算法如下：

    /**
     * 归并主算法，此处使用了尾递归，理论上可转换为迭代
     * @param a        需排序数组
     * @param len      每个堆内的元素个数
     */
    public static void mergeSort(int[] a, int len) {
        //初始化数据
        int size = a.length,s;
        //取到中间位置，此处<<的位运算可理解为*2
        int mid = size / (len << 1);
        // 归并到只剩一个有序集合的时候结束算法
        if (mid == 0)
            return;
        //进行一趟归并排序
        for (int i = 0; i < mid; ++i) {
            //s为第一个有序数组的开始位置
            s = i * 2 * len;
            //调用归并排序
            merge(a, s, s + len, (len << 1) + s - 1);
        }
        /* 此处由于len一定为2的N次幂，所以对size与((len << 1) - 1)进行与运算，只要不为0即可代表size不是len的倍数，即len不能被zise整除
                            也就是说， mid次归并后还有部分数据没有得到归并处理*/
        int c = size & ((len << 1) - 1);

        //将剩下的数和最后一个有序集合归并
        if (c != 0)
            merge(a, size - c - 2 * len, size - c, size - 1);
        //　-------递归执行下一趟归并排序------//
        mergeSort(a,  2 * len);
    }

 

测试方法如下：

    public static void main(String[] args) {
        Random random = new Random();
        int[] a = new int[8];
        for (int i = 0; i < a.length; i++) {
            a[i]=random.nextInt(100);
        }
        mergeSort(a,  1);
        for (int i = 0; i < a.length; ++i) {
            System.out.print(a[i] + "　");
        }
    }