归并排序算法（C#实现）

归并排序算法（C#实现）
归并排序(Merge Sort)是利⽤"归并"技术来进⾏排序。

归并是指将若⼲个已排序的⼦⽂件合并成⼀个有序的⽂件。

归并排序有两种⽅式：1): ⾃底向上的⽅法 2):⾃顶向下的⽅法
1、⾃底向上的⽅法
（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、⾃顶向下的⽅法(本⽂主要介绍此种⽅法，下⾯的⽂字都是对此种⽅法的解读)
（1）⾃顶向下的基本思想
采⽤分治法进⾏⾃顶向下的算法设计，形式更为简洁。

⾃顶向下的归并排序：是利⽤递归和分⽽治之的技术将数据序列划分成为越来越⼩的半⼦表，再对半⼦表排序，最后再⽤递归步骤将排好序的半⼦表合并成为越来越⼤的有序序列，归并排序包括两个步骤，分别为：
1）划分⼦表
2）合并半⼦表
（1）分治法的三个步骤
设归并排序的当前区间是R[low..high]，分治法的三个步骤是：
①分解：将当前区间⼀分为⼆，即求分裂点
②求解：递归地对两个⼦区间R[low..mid]和R[mid+1..high]进⾏归并排序；
③组合：将已排序的两个⼦区间R[low..mid]和R[mid+1..high]归并为⼀个有序的区间R[low..high]。

递归的终结条件：⼦区间长度为1（⼀个记录⾃然有序）。

如下演⽰递归的整个过程：
递归便是深度遍历（如下由左⾄右进⾏遍历）：假设有这样的⼀列数组{9,8,7,6,5,4,3,2,1}进⾏划分的顺序如下：
{9,8,7,6,5,4,3,2,1} --> {9,8,7,6,5}，{4,3,2,1}
{9,8,7,6,5} --> {9,8,7}，{6,5}
{9,8,7} --> {9,8}，{7}
{9,8} --> {9}，{8}
{6,5} -->{6}，{5}
{4,3,2,1} --> {4,3}，{2,1}
{4,3} -->{4}，{3}
{2,1} -->{2}，{1}
当深度划分到左右数组都只剩1个元素的时候，进⾏上述逆序的合并：
{9}，{8} --> {8,9} 然后和 {7} --> {7,8,9}
{6}，{5} --> {5,6} 然后 {7,8,9}和{5,6} --> {5,6,7,8,9}
{2}，{1} --> {1,2}
{4}，{3} --> {3,4} 然后 {1,2}和 {3,4} --> {1,2,3,4}
最终{5,6,7,8,9}和{1,2,3,4} --> {1,2,3,4,5,6,7,8,9}
具体实现代码如下所⽰：
//归并排序（⽬标数组，⼦表的起始位置，⼦表的终⽌位置）
private static void MergeSortFunction(int[] array, int first, int last)
{
try
{
if (first < last) //⼦表的长度⼤于1，则进⼊下⾯的递归处理
{
int mid = (first + last) / 2; //⼦表划分的位置
MergeSortFunction(array, first, mid); //对划分出来的左侧⼦表进⾏递归划分
MergeSortFunction(array, mid + 1, last); //对划分出来的右侧⼦表进⾏递归划分
MergeSortCore(array, first, mid, last); //对左右⼦表进⾏有序的整合（归并排序的核⼼部分）
}
}
catch (Exception ex)
{ }
}
//归并排序的核⼼部分：将两个有序的左右⼦表（以mid区分），合并成⼀个有序的表
private static void MergeSortCore(int[] array, int first, int mid, int last)
{
try
{
int indexA = first; //左侧⼦表的起始位置
int indexB = mid + 1; //右侧⼦表的起始位置
int[] temp = new int[last + 1]; //声明数组（暂存左右⼦表的所有有序数列）：长度等于左右⼦表的长度之和。

int tempIndex = 0;
while (indexA <= mid && indexB <= last) //进⾏左右⼦表的遍历，如果其中有⼀个⼦表遍历完，则跳出循环
{
if (array[indexA] <= array[indexB]) //此时左⼦表的数 <= 右⼦表的数
{
temp[tempIndex++] = array[indexA++]; //将左⼦表的数放⼊暂存数组中，遍历左⼦表下标++
}
else//此时左⼦表的数 > 右⼦表的数
{
temp[tempIndex++] = array[indexB++]; //将右⼦表的数放⼊暂存数组中，遍历右⼦表下标++
}
}
//有⼀侧⼦表遍历完后，跳出循环，将另外⼀侧⼦表剩下的数⼀次放⼊暂存数组中（有序）
while (indexA <= mid)
{
temp[tempIndex++] = array[indexA++];
}
while (indexB <= last)
{
temp[tempIndex++] = array[indexB++];
}
//将暂存数组中有序的数列写⼊⽬标数组的制定位置，使进⾏归并的数组段有序
tempIndex = 0;
for (int i = first; i <= last; i++)
{
array[i] = temp[tempIndex++];
}
}
catch (Exception ex)
{ }
}
对于N个元素的数组来说, 如此划分需要的层数是以2为底N的对数, 每⼀层中, 每⼀个元素都要复制到结果数组中, 并复制回来, 所以复制2N次, 那么对于归并排序,它的时间复杂度为O(N*logN), ⽽⽐较次数会少得多, 最少需要N/2次,最多为N-1次, 所以平均⽐较次数在两者之间. 它的主要问题还是在于在内存中需要双倍的空间.。