排序算法C#实现之归并排序详解

【任务目标】

将一组无序数组变为有序（文中暂定为：数组=向量）

【归并排序原理】

先考虑两个有序向量如何合并成为一个新的有序向量：

                  

我们可以认为任务目标想获得的有序向量是由有序向量A和B组成，其中有序向量A又是由两个有序向量A1和A2组成，对B、A1、A2继续往下分，直到向量中元素个数为1，此时，该向量自然是有序的。（这就是在递归）

（这就是分治策略，将一个问题分为两个子问题去求解）

显然易见，元素个数为n的无序向量最终可分为n个元素个数为1的有序向量，将这n个有序向量两两合并，则每次合并出来的向量必然是有序的，形成了n/2个元素数量为2的有序向量，再将这些有序向量合并，以此类推，最终形成元素个数为n的有序向量。

                                    

【归并排序原理概括】

通过反复的递归调用将获得的有序向量合并成为新的有序向量以形成最终的有序向量

【代码实现】

using System;
using System.Collections.Generic;
using System.Diagnostics.Eventing.Reader;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace mergeSort
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] A = new int[30];
            Random ra = new Random();
            for (int i = 0; i < 30; i++)
            {
                A[i] = ra.Next(200);
            }
            Program ps = new Program();
            ps.MergeSort(A,0,A.Length);
            Console.WriteLine("排序结果:");
            foreach (int a in A)
            {
                Console.Write(a + " ");
            }

            Console.ReadKey();

        }


        public void MergeSort(int[] A,int lo,int hi)//左开右闭区间[lo,hi)
        {
            if(hi-lo<2) return;//递归基，即递归退出的条件，只有一个元素
            int middle = (lo+hi) >> 1;
            MergeSort(A,lo,middle);
            MergeSort(A,middle,hi);
            MergeSortedArray(ref A,lo,hi);
        }

        public void MergeSortedArray(ref int[] A,int lo,int hi)
        {    
            //将无序数组中待合并的元素复制出来        
            int[] temp=new int[hi-lo];
            int i = lo;
            int j;
            for (j = 0; j < temp.Length; j++)
            {
                temp[j] = A[i++];
            }           
            j =0;
           
            //获取temp的中间位置
            int k = temp.Length >> 1;
            int middle = temp.Length >> 1;
            //比较前半部分和后半部分，即比较两个有序向量
            //将小的元素赋值给A的对应位置处
            while (j< middle&& k<temp.Length)
            {
                if (temp[j] <= temp[k])//用<=保证相同元素在排序前后的次序不会改变，不用<
                    A[lo++] = temp[j++];
                else
                {
                    A[lo++] = temp[k++];
                }

            }
            while (j< middle)
            {
                A[lo++] = temp[j++];
            }
            while (k< temp.Length)
            {
                A[lo++] = temp[k++];
            }
        }
    }
}

【实现结果】

【考虑其他情况】

【元素已经有序或接近有序】例如，对A={0,1,2,3,4,5,6,7,8,9}和A={3,1,2,0,4,5,6,7,8,9}，如果我们能做出数组有序的判断，就可提前退出排序算法的执行，提高效率。

归并排序可以做出数组有序的判断吗？

不可以，所以即使在最好的情况下，仍然需要完整的执行一遍算法。

【有多个相同的元素】排序前后相同元素的相对次序不会改变

【归并排序与冒泡排序的重要区别】

对于A={1,2,3,4,5,6,7,8,9}这样一个数组

冒泡排序的比较顺序是：1和2比，2和3比，3和4比······；一趟比较下来，可以判断数组是否有序；第二趟比较仍是1和2比，2和3比，3和4比······全部是单对单比较 

归并排序的比较顺序是：1和2比，3和4比，5和6比······，一趟比较下来，不能判断数组是否有序（2和3没比过，4和5 没比过）；第二趟比较是1、2作为整体和3、4比较，5、6作为整体和7、8比较······是划分区域整体比较

【参考】

[1]邓俊辉.数据结构（C++语言版）第三版[M]

【相关链接】

排序算法C#实现之冒泡排序详解

排序算法C#实现之插入排序详解

排序算法C#实现之选择排序详解