C#排序算法——二路归并法

　　在阅读此博文前，请先阅读我的博文“Ｃ＃排序算法——基类设计 “，以了解基类的结构。
　　在编写代码前，我们先来了解二路归并法的排序过程：
　　假设有一个IList<T>型的集合list(集合的元素为list[0]到list[n-1], n = list.Count)。
　　第1步:将list平均分为两个子集：左子集list[0]:list[middle]和右子集list[middle + 1]:list[n - 1](middle = n / 2)。
　　第2步：分别对左子集和右子集用二路归并法进行排序。
　　第3步，将排序后的左子集和右子集合并，构造出有序集合list.
　　很显然，二路归并法使用了递归调用。根据上面的算法，我们开始编码了：

1. using  System;
2. using  System.Collections.Generic;
3. using  System.Text;
5. namespace  CYB.DataStruct.Sorting
6. {
7.      /// <summary>
8.      /// 作者 : cyb
9.      /// 发表时间 : 2008-9-8
10.      /// qq : 13101908
11.      /// e-mail : hustcyb@gmail.com
12.      /// </summary>
13.      public   class  MergeSorter : Sorter
14.     {
15.          public   override   void  Sort<T>(IList<T> list, CompareDelegate<T> compare)
16.         {
17.              base .Sort(list, compare);
19.              this .Sort(list, 0, list.Count - 1, compare);
20.         }
22.          private   void  Merge<T>(IList<T> list,  int  start,  int  middle,  int  end, CompareDelegate<T> compare)
23.         {
24.             T[] array =  new  T[end - start + 1];   //存储集合元素的临时数组
25.              int  index = 0;       //指示arry中位置的游标
26.              int  left = start;    //指示左子集位置的游标  
27.              int  right = middle + 1;      //指示右子集位置的游标
28.              while  (left <= middle && right <= end)
29.             {
30.                  if  (compare(list[left], list[right]) < 0)
31.                 {
32.                     array[index++] = list[left++];
33.                 }
34.                  else
35.                 {
36.                     array[index++] = list[right++];
37.                 }
38.             }
40.              //将左子集中剩余元素复制到临时数组中（如果还有的话）
41.              while  (left <= middle)
42.             {
43.                 array[index++] = list[left++];
44.             }
46.              //将右子集中剩余元素复制到临时数组中（如果还有的话）
47.              while  (right <= end)
48.             {
49.                 array[index++] = list[right++];
50.             }
52.              //将有序的临时数组复制到集合中
53.              for  (index = 0; index < array.Length; index++)
54.             {
55.                 list[start + index] = array[index];
56.             }
57.         }
59.          private   void  Sort<T>(IList<T> list,  int  start,  int  end, CompareDelegate<T> compare)
60.         {
61.              if  (start >= end)
62.             {
63.                  return ;      //当集合中的元素少于1个，不作处理
64.             }
66.              //分割集合
67.              int  middle = (start + end) / 2;
68.             Sort(list, start, middle, compare);      //使用二路归并法对左子集排序
69.             Sort(list, middle + 1, end, compare);    //使用二路归并法对右子集排序
70.             
71.              //合并子集
72.             Merge(list, start, middle, end, compare);
73.         }
74.     }
75. }

　　另一种二路归并排序算法是这样的：首先将每两个相邻的大小为1的子序列归并，然后对
上一次归并所得到的大小为2的子序列进行相邻归并，如此反复，直至最后归并到一个序列，
归并过程完成：

1. using  System;
2. using  System.Collections.Generic;
3. using  System.Text;
5. namespace  CYB.DataStruct.Sorting
6. {
7.      /// <summary>
8.      /// 作者 : cyb
9.      /// 发表时间 : 2008-9-8
10.      /// qq : 13101908
11.      /// e-mail : hustcyb@gmail.com
12.      /// </summary>
13.      public   class  MergeSorter : Sorter
14.     {
15.          public   override   void  Sort<T>(IList<T> list, CompareDelegate<T> compare)
16.         {
17.              base .Sort(list, compare);
19.             Sort(list, 1, compare);
20.         }
22.          private   void  Sort<T>(IList<T> list,  int  interval, CompareDelegate<T> compare)
23.         {
24.              if  (interval >= list.Count)
25.             {
26.                  return ;
27.             }
29.              for  ( int  middle = interval - 1; middle < list.Count; middle += 2 * interval)
30.             {
31.                  int  start = middle - (interval - 1);
32.                  int  end = middle + interval;
33.                  if  (end >= list.Count)
34.                 {
35.                     end = list.Count - 1;
36.                 }
38.                 Merge(list, start, middle, end, compare);
39.             }
41.             Sort(list, 2 * interval, compare);
42.         }
44.          private   void  Merge<T>(IList<T> list,  int  start,  int  middle,  int  end, CompareDelegate<T> compare)
45.         {
46.             T[] array =  new  T[end - start + 1];   //存储集合元素的临时数组
47.              int  index = 0;       //指示arry中位置的游标
48.              int  left = start;    //指示左子集位置的游标  
49.              int  right = middle + 1;      //指示右子集位置的游标
50.              while  (left <= middle && right <= end)
51.             {
52.                  if  (compare(list[left], list[right]) < 0)
53.                 {
54.                     array[index++] = list[left++];
55.                 }
56.                  else
57.                 {
58.                     array[index++] = list[right++];
59.                 }
60.             }
62.              //将左子集中剩余元素复制到临时数组中（如果还有的话）
63.              while  (left <= middle)
64.             {
65.                 array[index++] = list[left++];
66.             }
68.              //将右子集中剩余元素复制到临时数组中（如果还有的话）
69.              while  (right <= end)
70.             {
71.                 array[index++] = list[right++];
72.             }
74.              //将有序的临时数组复制到集合中
75.              for  (index = 0; index < array.Length; index++)
76.             {
77.                 list[start + index] = array[index];
78.             }
79.         }
80.     }
81. }