C# 歸並排序 實現代碼

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Sort
{
    class MergeSorter
    {
        /// <summary>
        /// 歸並排序之歸：歸並排序入口 
        /// Updated by Lihua at 05/06/2009
        /// </summary>
        /// <param name="data">無序數組</param>
        /// <returns>有序數組</returns>
         public static int[] Sort(int[] data)
        {
            //若data為null，或只剩下1 or 0個元素，返回，不排序
            if (null == data || data.Length <= 1)
            {
                return data;
            }
            //取數組中間下標
            int middle = data.Length >> 1;
            //初始化臨時數組let,right，並定義result作為最終有序數組，若數組元素奇數個，將把多余的那元素空間預留在right臨時數組
            int[] left = new int[middle];
            int[] right =  new int[data.Length - middle];
            int[] result = new int[data.Length];
            for (int i = 0; i < data.Length; i++)
            {
                if (i < middle)
                {
                    left[i] = data[i];
                }
                else
                {
                    right[i-middle] = data[i]; //此處i-middle，讓我省掉定義一個j，性能有所提高
                }
            }
            left = Sort(left);//遞歸左數組
            right = Sort(right);//遞歸右數組
            result = Merge(left, right);//開始排序
            return result;
        }
        /// <summary>
        /// 歸並排序之並:排序在這一步
        /// </summary>
        /// <param name="a">左數組</param>
        /// <param name="b">右數組</param>
        /// <returns>合並左右數組排序後返回</returns>
         private static int[] Merge(int[] a, int[] b)
         {
            //定義結果數組，用來存儲最終結果
            int[] result = new int[a.Length + b.Length];
            int i = 0, j = 0, k = 0;
            while (i < a.Length && j < b.Length)
            {
                if (a[i] < b[j])//左數組中元素小於右數組中元素
                {
                    result[k++] = a[i++];//將小的那個放到結果數組
                }
                else//左數組中元素大於右數組中元素
                {
                    result[k++] = b[j++];//將小的那個放到結果數組
                }
            }
            while (i < a.Length)//這裡其實是還有左元素，但沒有右元素 
            {
                result[k++] = a[i++];
            }
            while (j < b.Length)//有右元素，無左元素
            {
                result[k++] = b[j++];
            }
            return result;//返回結果數組
        }
    }
}

歸並排序：

歸並（Merge）排序法是將兩個（或兩個以上）有序表合並成一個新的有序表，即把待排序序列分為若干個子序列，每個子序列是有序的。然後再把有序子序列合並為整體有序序列。該算法是采用分治法（Divide and Conquer）的一個非常典型的應用。

將已有序的子序列合並，得到完全有序的序列；即先使每個子序列有序，再使子序列段間有序。若將兩個有序表合並成一個有序表，稱為2-路歸並。

假設我們有一個沒有排好序的序列，那麼首先我們使用分割的辦法將這個序列分割成一個一個已經排好序的子序列，然後再利用歸並的方法將一個個的子序列合並成排序好的序列。分割和歸並的過程可以看下面的圖例。

 從上圖可以看出，我們首先把一個未排序的序列從中間分割成2部分，再把2部分分成4部分，依次分割下去，直到分割成一個一個的數據，再把這些數據兩兩歸並到一起，使之有序，不停的歸並，最後成為一個排好序的序列。

如何把兩個已經排序好的子序列歸並成一個排好序的序列呢？可以參看下面的方法。

假設我們有兩個已經排序好的子序列。

序列A：1  23  34  65

序列B：2  13  14  87

那麼可以按照下面的步驟將它們歸並到一個序列中。

（1）首先設定一個新的數列C[8]。
（2）A[0]和B[0]比較，A[0] = 1，B[0] = 2，A[0] < B[0]，那麼C[0] = 1
（3）A[1]和B[0]比較，A[1] = 23，B[0] = 2，A[1] > B[0]，那麼C[1] = 2
（4）A[1]和B[1]比較，A[1] = 23，B[1] = 13，A[1] > B[1]，那麼C[2] = 13
（5）A[1]和B[2]比較，A[1] = 23，B[2] = 14，A[1] > B[2]，那麼C[3] = 14
（6）A[1]和B[3]比較，A[1] = 23，B[3] = 87，A[1] < B[3]，那麼C[4] = 23
（7）A[2]和B[3]比較，A[2] = 34，B[3] = 87，A[2] < B[3]，那麼C[5] = 34
（8）A[3]和B[3]比較，A[3] = 65，B[3] = 87，A[3] < B[3]，那麼C[6] = 65
（9）最後將B[3]復制到C中，那麼C[7] = 87。歸並完成。