算法篇之归并排序

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

归并操作

将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。