算法 - 归并排序（C#）

分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击人工智能教程

/*
 * MergeSort.cs - by Chimomo
 * 
 * 归并排序是建立在归并操作上的排序算法，该算法是分而治之策略（Divide and Conquer）的一个非常典型的应用。
 * 
 * 归并操作的基本原理：
 * 1、申请空间，使其大小为两个已排序序列之和，该空间用来存放归并后的序列。
 * 2、设置两个指针，最初位置分别为两个已排序序列的起始位置。
 * 3、比较两个指针所指向的元素，选择相对较小的元素放入归并序列，并移动指针到下一位置。
 * 4、重复步骤3直到某一指针超出序列尾部。
 * 5、将另一序列剩下的所有元素直接复制到归并序列尾部。
 * 
 * 归并排序的基本原理（假设序列共有n个元素）：
 * 1、将序列每相邻两个元素进行归并操作（Merge），形成Floor(n/2)个序列，排序后每个序列包含两个元素。
 * 2、将上述序列再次归并，形成Floor(n/4)个序列，每个序列包含四个元素。
 * 3、重复步骤2，直到所有元素排序完毕。
 * 
 * 归并排序速度仅次于快速排序，是一种稳定的排序算法，一般应用于对总体无序、但是各子项相对有序的序列。
 */

using System;

namespace MergeSort
{
    public class MergeSortApp
    {
        private static int _round = 1;

        /// <summary>
        /// 二路归并：将两个有序序列归并成一个有序序列。
        /// </summary>
        /// <param name="a">待归并序列。</param>
        /// <param name="s1">第一个有序序列的起始下标。</param>
        /// <param name="s2">第二个有序序列的起始下标。</param>
        /// <param name="e2">第二个有序序列的结束下标。</param>
        private static void Merge(int[] a, int s1, int s2, int e2)
        {
            // 申请空间，使其大小为两个已排序序列之和，该空间用来存放归并后的序列。
            int[] tmp = new int[e2 - s1 + 1];

            // 设置两个指针，最初位置分别为两个已排序序列的起始位置。
            int i = s1, j = s2, k = 0;

            // 重复做以下操作，直到某一指针超出序列尾部：比较两个指针所指向的元素，选择相对较小的元素放入归并序列，并移动指针到下一位置。
            while (i < s2 && j <= e2)
            {
                if (a[i] <= a[j])
                {
                    tmp[k++] = a[i++];
                }
                else
                {
                    tmp[k++] = a[j++];
                }
            }

            // 将另一序列剩下的所有元素直接复制到归并序列尾部。
            while (i < s2)
            {
                tmp[k++] = a[i++];
            }

            while (j <= e2)
            {
                tmp[k++] = a[j++];
            }

            Array.Copy(tmp, 0, a, s1, tmp.Length);
        }

        /// <summary>
        /// 归并排序算法。
        /// </summary>
        /// <param name="a">待排序序列。</param>
        /// <param name="length">每次要归并的有序集合的长度。</param>
        public static void MergeSort(int[] a, int length)
        {
            // 待排序序列长度。
            int size = a.Length;

            // 一趟归并排序所需归并操作的次数。
            int mid = size / (length << 1);

            // 二路归并操作中待归并序列末尾处未被归并的元素个数。
            int c = size & ((length << 1) - 1);

            // 归并到只剩一个有序序列的时候结束算法。
            if (mid == 0)
            {
                return;
            }

            // 进行一趟归并排序。
            for (int i = 0; i < mid; ++i)
            {
                Merge(a, i * 2 * length, (i * 2 + 1) * length, (length << 1) + i * 2 * length - 1);
            }

            // 将剩下的元素和倒数一个有序集合归并。
            if (c != 0)
            {
                Merge(a, size - c - 2 * length, size - c, size - 1);
            }

            Console.Write("Round {0}: ", _round);
            foreach (int i in a)
            {
                Console.Write(i + " ");
            }

            Console.WriteLine();
            _round++;

            // 递归执行下一趟归并排序。
            MergeSort(a, 2 * length);
        }
    }
}

/*
 * MergeSortTest.cs - by Chimomo
 */

using System;

namespace MergeSort
{
    static class Program
    {
        static void Main()
        {
            int[] a = {1, 6, 4, 2, 8, 7, 9, 3, 10, 5};
            Console.WriteLine("Before Merge Sort:");
            foreach (int i in a)
            {
                Console.Write(i + " ");
            }

            Console.WriteLine("\r\n");

            Console.WriteLine("In Merge Sort:");
            MergeSortApp.MergeSort(a, 1);

            Console.WriteLine("\r\nAfter Merge Sort:");
            foreach (var i in a)
            {
                Console.Write(i + " ");
            }
        }
    }
}

// Output:
/*
Before Merge Sort:
1 6 4 2 8 7 9 3 10 5

In Merge Sort:
Round 1: 1 6 2 4 7 8 3 9 5 10
Round 2: 1 2 4 6 3 5 7 8 9 10
Round 3: 1 2 3 4 5 6 7 8 9 10

After Merge Sort:
1 2 3 4 5 6 7 8 9 10
*/