算法和数据结构～各位排序算法的介绍与实现(C#)

排序是指将元素集合按照规定的顺序排列。通常有两种排序方法，升序排列和降序排列。例如，对整数集{5,2,7,1}进行升序排列，结果为{1,2,5,7}，对其进行降序排列结果为{7,5,2,1}。总的来说，排序的目的是使数据能够以更有意义的形式表现出来。虽然排序最显著的应用是排列数据以显示它，但它往往可以用来解决其他的问题，特别是作为某些已成型算法的一部分。
      总的来说，排序算法分为两大类：比较排序和线性时间排序。比较排序依赖于比较和交换来将元素移动到正确的位置上。令人惊讶的是，并不是所有的排序算法都依赖于比较。对于那些确实依赖于比较来进行排序的算法来说，它们的运行时间往往不可能小于O（nlg n）。对于线性时间排序，从它的名字就可以看出，它的运行时间往往与它处理的数据元素个数成正比，即为O（n）。遗憾的是，线性时间排序依赖于数据集合中的某些特征，所以我们并不是在所有的场合都能够使用它。某些排序算法只使用数据本身的存储空间来处理和输出数据（这些称为就地排序），而有一些则需要额外的空间来处理和输出数据（虽然可能最终结果还是会拷贝到原始的内存空间中）。

    /// <summary>
    /// 排序算法
    /// 作者：仓储大叔
    /// 代码来源：部分自写，部分网上摘录，都经过测试可以放心使用
    /// </summary>
    public class SortHelper
    {
        #region Public Methods
        /// <summary>
        /// 插入排序
        /// </summary>
        public static void InsertSort(List<int> list)
        {

            /*
             * 复杂度 O（n^2）
             * 插入排序从根本上来说，就是每次从未排序的数据集中取出一个元素，插入已排好序的数据集中。在以下所展示的实现中，两个数据集都存放在data中，data是一块连接的存储区域。最初，data包含size个无序元素。随着issort的运行，data逐渐被有序数据集所取代，直到issort返回（此时，data已经是一个有序数据集）。虽然实现插入排序用到连续的存储空间，但它也能用链表来实现（并不是所有的排序都可以使用链表来实现），并且效率不差。
             */
            for (int j = 1; j < list.Count; j++)
            {
                int i = j - 1;
                int currnet = list[j];
                while (i >= 0 && currnet > list[i])
                {
                    list[i + 1] = list[i];
                    i--;
                }
                list[i + 1] = currnet;
            }
        }
        /// <summary>
        /// 快速排序
        /// </summary>
        /// <param name="list">目标数组</param>
        /// <param name="left">子表的起始位置</param>
        /// <param name="right">子表的终止位置</param>
        public static void QuickSort(List<int> list, int left, int right)
        {
            /*
           * 复杂度 O（nlg^n）
           * 描述　利用快速排序将数组data中的元素进行排序。数组中的元素个数由size决定。而每个元素的大小由esize决定。参数i和k定义当前进行排序的两个部分，其值分别初始化为0和size-1。函数指针compare会指向一个用户定义的函数来比较元素大小。其函数功能与issort中描述的一样。当qksort返回时，data包含已排序的元素
           */
            if (left < right)
            {
                int i = Division(list, left, right);
                //对枢轴的左边部分进行排序
                QuickSort(list, i + 1, right);
                //对枢轴的右边部分进行排序
                QuickSort(list, left, i - 1);
            }
        }
        /// <summary>
        /// 归并排序
        /// </summary>
        /// <param name="array">目标数组</param>
        /// <param name="first">子表的起始位置</param>
        /// <param name="last">子表的终止位置</param>
        public static void MergeSortFunction(List<int> array, int first, int last)
        {
            /*
             * 复杂度　O（nlg^n）
             * 描述　利用归并排序将数组data中的元素进行排序。数组中的元素个数由size决定。而每个元素的大小由esize决定。参数i和k定义当前进行排序的两个部分，其值分别初始化为0和size-1。函数指针compare会指向一个用户定义的函数来比较元素大小。其函数功能与issort中描述的一样。当mgsort返回时，data中包含已排序的元素。
             */
            if (first < last)   //子表的长度大于1，则进入下面的递归处理
            {
                int mid = (first + last) / 2;   //子表划分的位置
                MergeSortFunction(array, first, mid);   //对划分出来的左侧子表进行递归划分
                MergeSortFunction(array, mid + 1, last);    //对划分出来的右侧子表进行递归划分
                MergeSortCore(array, first, mid, last); //对左右子表进行有序的整合（归并排序的核心部分）
            }

        }
        /// <summary>
        /// 计数排序
        /// </summary>
        /// <param name="arrayToSort">要排序的数组</param>
        /// <param name="maxValue">数组的最大值加一</param>
        /// <returns>计数排序后的结果</returns>
        public static List<int> CountingSort(List<int> arrayA, int arrange)
        {
            /* 复杂度　O（n+k），n为要排序的元素的个数，k为data中最大的整数加1。
             * 计数排序是一种高效的线性排序，它通过计算一个集合中元素出现的次数来确定集合如何排列。不同于之前介绍的一些算法是基于比较的，计数排序不需要进行元素比较，而且它的运行效率要比效率为O（nlg n）比较排序高。
             */

            int[] arrayResult = new int[arrayA.Count];
            int[] arrayTemp = new int[arrange + 1];
            for (int i = 0; i <= arrange; i++)
            {
                arrayTemp[i] = 0;
            }
            for (int j = 0; j < arrayA.Count; j++)
            {
                arrayTemp[arrayA[j]] += 1;
            }
            for (int k = 1; k <= arrange; k++)
            {
                arrayTemp[k] += arrayTemp[k - 1];
            }
            for (int m = arrayA.Count - 1; m >= 0; m--)
            {
                arrayResult[arrayTemp[arrayA[m]] - 1] = arrayA[m];
                arrayTemp[arrayA[m]] -= 1;
            }
            return arrayResult.ToList();
        }
        /// <summary>
        /// 冒泡排序
        /// </summary>
        /// <param name="arr"></param>
        public void EbullitionSort(List<int> arr)
        {
            /*
             * 复杂度O(n^2)
             * 对1至n个记录，在第i趟排序中设置标志flag:=true，未排序的标志。从下往上扫描，以j作为内层循环变量，共做n-i次比较。在第j趟比较中，若r[j+1]<r[j]则交换，并至flag为false。在一趟排序结束后，若flag为true，则终止排序。
             */
            int i, j, temp;
            bool done = false;
            j = 1;
            while ((j < arr.Count) && (!done))//判断长度
            {
                done = true;
                for (i = 0; i < arr.Count - j; i++)
                {
                    if (arr[i] > arr[i + 1])
                    {
                        done = false;
                        temp = arr[i];
                        arr[i] = arr[i + 1];//交换数据
                        arr[i + 1] = temp;
                    }
                }
                j++;
            }
        }

        #endregion

        #region Private Methods
        /// <summary>
        /// 归并排序的核心部分：将两个有序的左右子表（以mid区分），合并成一个有序的表
        /// </summary>
        /// <param name="array"></param>
        /// <param name="first"></param>
        /// <param name="mid"></param>
        /// <param name="last"></param>
        private static void MergeSortCore(List<int> array, int first, int mid, int last)
        {

            int indexA = first; //左侧子表的起始位置
            int indexB = mid + 1;   //右侧子表的起始位置
            int[] temp = new int[last + 1]; //声明数组（暂存左右子表的所有有序数列）：长度等于左右子表的长度之和。
            int tempIndex = 0;
            while (indexA <= mid && indexB <= last) //进行左右子表的遍历，如果其中有一个子表遍历完，则跳出循环
            {
                if (array[indexA] <= array[indexB]) //此时左子表的数 <= 右子表的数
                {
                    temp[tempIndex++] = array[indexA++];    //将左子表的数放入暂存数组中，遍历左子表下标++
                }
                else//此时左子表的数 > 右子表的数
                {
                    temp[tempIndex++] = array[indexB++];    //将右子表的数放入暂存数组中，遍历右子表下标++
                }
            }
            //有一侧子表遍历完后，跳出循环，将另外一侧子表剩下的数一次放入暂存数组中（有序）
            while (indexA <= mid)
            {
                temp[tempIndex++] = array[indexA++];
            }
            while (indexB <= last)
            {
                temp[tempIndex++] = array[indexB++];
            }

            //将暂存数组中有序的数列写入目标数组的制定位置，使进行归并的数组段有序
            tempIndex = 0;
            for (int i = first; i <= last; i++)
            {
                array[i] = temp[tempIndex++];
            }

        }

        /// <summary>
        /// 获取按枢轴值左右分流后枢轴的位置
        /// </summary>
        /// <param name="list"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <returns></returns>
        private static int Division(List<int> list, int left, int right)
        {
            while (left < right)
            {
                int num = list[left]; //将首元素作为枢轴
                if (num > list[left + 1])
                {
                    list[left] = list[left + 1];
                    list[left + 1] = num;
                    left++;
                }
                else
                {
                    int temp = list[right];
                    list[right] = list[left + 1];
                    list[left + 1] = temp;
                    right--;
                }
            }
            return left; //指向的此时枢轴的位置
        }
        #endregion

    }