算法篇之归并排序

**归并排序是建立在归并操作上采用分治法的一种排序算法。**

归并操作

将2个有序数列进行归并操作。比较2数列第一个数的大小，取小的放入合并数列并删除该数，直至一个数列为空，则将另一数列一次添加至合并数列。

MemeryArray(int[] a, int[] b,int[] c) {
        //两个数组归并操作
        int len;
        int i, j, k;
        i = j = k = 0;
        while (i < a.length && j < b.length) {
            if (a[i] < b[j])
                c[k++] = a[i++];
            else
                c[k++] = a[j++];
        }
        while (i < a.length)
            c[k++] = c[i++];
        while (j < b.length)
            c[k++] = c[j++];
    }

归并数列的时间复杂度为O(n)。
对数组归并排序思路：递归的  每次将数组分为2组  直至各组为1个元素时，这些数组有序，然后再合并数组。

    5434762362
    54347   62362
    54  347   62  362
    5  4  3  47  6  2  3  62
    5  4  3  4  7  6  2  3  6  2 
    5  4  3  47  6  2  3  26
    45  347  26  236
    34457  22366
    223344567   

上面是一个数组进行归并排序得分解步骤。

实现代码

调用：sex是排序得数组，tmp为中间数组

mergeSort(sex, 0, sex.length-1,tmp);

static void  MemeryArray(int[] a, int first, int mid, int last, int[] tmp) {
            int i = first;
            int j = mid+1;
            int m = mid;
            int n = last;
            int k = 0;
            while ( i <= m && j <= n )
            {
                if(a[i] <= a[j])
                    tmp[k++] = a[i++];
                else
                    tmp[k++] = a[j++];
            }
            while (i <= m)
                tmp[k++] = a[i++];
            while ( j <= n)
                tmp[k++] = a[j++];

        /**
         * 复制归并数组
         */
        for (i = 0; i < k; i++)
        {
            a[first+i] = tmp[i];
        }
    }
    static void  mergeSort(int[] a, int first, int last, int[] b)
    {
        if(first < last) {
            int mid = (first+last)/2;
            mergeSort(a, first, mid, b);
            mergeSort(a, mid+1, last, b);
            MemeryArray(a, first, mid, last, b);
        }
    }

测试:创建随机数数组，排序成功。

效率：数组个数         时间(ms)
      10              1          0          1
      100             0          0          1
      1000            8          2          1
      10000           3          20        3
      100000          21        25        24

可以看

出，随着数组的增大，排序时间增加不大。定义时间复杂度N*logn。