C#实现归并排序

归并排序(Merge Sort)是利用"归并"技术来进行排序。归并是指将若干个已排序的子文件合并成一个有序的文件。归并排序有两种方式：1): 自底向上的方法 2):自顶向下的方法


1.自底向上的方法
自底向上的基本思想是：第1趟归并排序时，将待排序的文件R[1..n]看作是n个长度为1的有序子文件，将这些子文件两两归并，若n为偶数，则得到n/2个长度为2的有序子文件；若n为奇数，则最后一个子文件轮空(不参与归并)。故本趟归并完成后，前n/2 - 1个有序子文件长度为2，但最后一个子文件长度仍为1；第2趟归并则是将第1趟归并所得到的n/2个有序的子文件两两归并，如此反复，直到最后得到一个长度为n的有序文件为止。

上述的每次归并操作，均是将两个有序的子文件合并成一个有序的子文件，故称其为"二路归并排序"。类似地有k(k>2)路归并排序。   

2.自顶向下的方法(本文主要介绍此种方法，下面的文字都是对此种方法的解读)

采用分治法进行自顶向下的算法设计，形式更为简洁。
自顶向下的归并排序：是利用递归和分而治之的技术将数据序列划分成为越来越小的半子表，再对半子表排序，最后再用递归步骤将排好序的半子表合并成为越来越大的有序序列，归并排序包括两个步骤，分别为：

 a.划分子表

 b.合并半子表

分治法的三个步骤
设归并排序的当前区间是R[low..high]，分治法的三个步骤是：
分解：将当前区间一分为二，即求分裂点
求解：递归地对两个子区间R[low..mid]和R[mid+1..high]进行归并排序；

组合：将已排序的两个子区间R[low..mid]和R[mid+1..high]归并为一个有序的区间R[low..high]。

递归的终结条件：子区间长度为1（一个记录自然有序）。

代码如下：

/// <summary>
        /// 归并排序
        /// </summary>
        /// <param name="origin"></param>
        /// <returns></returns>
        public static int[] MergeSort(int[] origin)
        {
            if (origin.Length == 1)
            {
                return origin;
            }
            
            if (origin.Length == 2)
            {
                if (origin[0] > origin[1])
                {
                    var temp = origin[1];
                    origin[1] = origin[0];
                    origin[0] = temp;
                }
                return origin;
            }
            else
            {
                int[] leftArray = new int[origin.Length / 2];
                for (int i = 0; i < origin.Length / 2; i++)
                {
                    leftArray[i] = origin[i];
                }

                int[] rightArray = new int[origin.Length - origin.Length / 2];
                for (int i = 0; i < origin.Length - origin.Length / 2; i++)
                {
                    rightArray[i] = origin[origin.Length / 2 + i];
                }

                var leftSortedArray = MergeSort(leftArray);
                var rightSortedArray = MergeSort(rightArray);
                return mergeArray(leftSortedArray, rightSortedArray);
            }
        }

        private static int[] mergeArray(int[] firstArray, int[] secondArray)
        {
            int length = firstArray.Length + secondArray.Length;
            int[] sort = new int[length];

            int i = 0;
            int j = 0;
            for (int k = 0; k < length; k++)
            {
                if (i >= firstArray.Length)
                {
                    sort[k] = secondArray[j];
                    j++;
                    continue;
                }

                if (j >= secondArray.Length)
                {
                    sort[k] = firstArray[i];
                    i++;
                    continue;
                }

                if (firstArray[i] <= secondArray[j])
                {
                    sort[k] = firstArray[i];
                    i++;
                }
                else
                {
                    sort[k] = secondArray[j];
                    j++;
                }
            }

            return sort;
        }

 对于N个元素的数组来说, 如此划分需要的层数是以2为底N的对数, 每一层中, 每一个元素都要复制到结果数组中, 并复制回来, 所以复制2N次, 那么对于归并排序,它的时间复杂度为O(N*logN), 而比较次数会少得多, 最少需要N/2次,最多为N-1次, 所以平均比较次数在两者之间. 它的主要问题还是在于在内存中需要双倍的空间.