原理：采用分治策略，将整个数组划分成小的数组进行排序，之后再进行合并，通常结合递归来实现

适用于大数据排序 

时间复杂度：Θ（nlgn）

C#实现：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AlgorithmTest
{
    class MergeSort
    {
        public void _MergeSort ( int[] arr, int start, int end)
        {
            if (start >= end)
                return;
          
            int middle = start + ((end - start) >>1);
            _MergeSort(arr, start, middle);
            _MergeSort(arr, middle+1, end);
            _MergeDataInArray(arr, start, middle, end);
        }

        private void _MergeDataInArray ( int[] arr, int start, int middle, int end )
        {
            int leftCount = middle - start + 1;
            int rightCount = end - middle;
            int[] leftArr = new int[leftCount];
            int[] rightArr = new int[rightCount];

            int i = 0;
            int j = 0;
            for (i = start; i <= middle; i++)
            {
                leftArr[i-start] = arr[i];
            }
            for (j = middle + 1; j <= end; j++)
            {
                rightArr[j-middle-1] = arr[j];
            }

            i = 0;
            j = 0;
            int k;
            for (k = start; k <= end; k++)
            {
                if (i >= leftCount)
                {
                    for (int a = j; a < rightCount; a++)
                    {
                        arr[k] = rightArr[a];
                        k++;
                    }
                    break;
                }
                if (j >= rightCount)
                {
                    for (int a = i; a < leftCount; a++)
                    {
                        arr[k] = leftArr[a];
                        k++;
                    }
                    break;
                }
                if (leftArr[i] <= rightArr[j])
                {
                    arr[k] = leftArr[i];
                    i++;
                }
                else
                {
                    arr[k] = rightArr[j];
                    j++;
                }
            }
        }
    }
}