算法与数据结构——排序（七）归并排序

      归并算法其实理解起来很容易，我们以前在学习C++的时候，肯定遇到过这样一道题目，给两个有序的列表，请把他们合并成一个列表，并且有序。相信叫大家写一个函数实现这个功能并不难。但是我们当时怎么没有想到，用这个思想，可以发明出一种排序的算法出来呢，它就是我们要学习的归并排序。

      归并排序的原理就是，把一个序列拆分成两个小的序列，把这两个 小的序列排好序好，然后再把它们合并起来。对于每个小的序列，我们又可以进行拆分成更小的两个序列，把更小的两个序列排序好后，合并起来。对于更小的序列，我们又可以进行拆分，一直这样拆分，直到拆分到每个序列里面只有一个数的时候，这个时候，就把这个数当作一个列表，跟另外一个列表实现合并，并有序。

      比如我们要排序的序列有10个数，我们可以把这10个数当成10个序列，对每两个序列进行排序并合并成一个序列，这时候，就有了5个序列，然后再把这一个序列里面的两两排序合并，一直到最后合并成了一个序列，那么这个序列也就变成了有序的了。

        上面的就是归并排序的基本原理示意图.最重要的一步就是给你两个有序的列表，把它合并成一个有序的列表，这个方法实现如下：

/// <summary>
/// 把两个有序的序列A和B合并到一个有序列temp里面
/// </summary>
/// <param name="sortListA">有序序列A</param>
/// <param name="sortListB">有序序列B</param>
/// <param name="tempList">有序序列Temp</param>
public void Merge(List<int> sortListA, List<int> sortListB, List<int> tempList)
{
    int countB = 0;
    int countA = 0;
    //1.以某个序列为原始序列，把它的每一个数，与另外的一个序列做比较
    for (int i = 0; i < sortListA.Count; i++)
    {
        //1.1循环遍历序列B的每一个序列（因为B序列是有序列的，所以第一个元素是最小的）
        for (int j = countB; j < sortListB.Count; j++)
        {
            //1.2如果A序列中的某个元素比B中的小，就把A中的这个元素加到temp中去
            if (sortListA[i] < sortListB[j])
            {
                tempList.Add(sortListA[i]);
                countA++;//记录加到temp中去的A序列中元素的数量
                break;
            }
                //1.2否则把B中的元素加到temp中去
            else
            {
                tempList.Add(sortListB[j]);
                countB++;//记录加到temp中去的B序列中元素的数量
            }
        }
    }//注意，此for循环结束后，一定有一个序列中的元素全部加到了temp中去了。

    //如果此处不相等，代表B中的元素还没有加完，那么把B中剩下的元素加入到Temp中去
    if (countB != sortListB.Count)
    {
        for (int k = countB; k < sortListB.Count; k++)
        {
            tempList.Add(sortListB[k]);
        }
    }
    //否则的话，代表A中的元素还没有加完，那么把A中剩下的元素加入到Temp中去
    else
    {
        for (int k = countA; k < sortListA.Count; k++)
        {
            tempList.Add(sortListA[k]);
        }
    }

}

      递归调用的方法如下：

public void MSort(List<int > sortList, List<int > resultList,int start,int end)
{
    List<int> tempList1 = new List<int>();
    List<int> tempList2 = new List<int>();
    int mid = (start + end) / 2;

    if (start == end)
    {
        resultList.Add(sortList[start]);
    }
    else
    {
        MSort(sortList,  tempList1, start, mid);//递归调用，把SortList里面，第start到mid之间的数，进行归并，结果放在tempList1里面
        MSort(sortList,  tempList2, mid+1, end);//递归调用，把SortList里面，第mid+1到end之间的数，进行归并，结果放在tempList2里面
        //resultList = Merge(tempList1, tempList2);//不能这样调用，
        Merge(tempList1, tempList2, resultList);//把TempList1和TempList2中的数合并到resultList中去
    }

}

      最后实现的排序方法是：

public List<int> SortByMerge(List<int> sortList)
{
    List<int> resultList=new List<int>();
    MSort(sortList, resultList, 0, sortList.Count - 1);
    return resultList;
}

最后我们来看看归并排序的时间复杂度，由完全二叉树的深度可以知道，归并排序需要进行[log₂n次]，每趟排序还需要把序列中的每一个元素归并到另外一个序列中去，耗费时间复杂度是O(n)，所以总的时间复杂度是O(nlog₂n).