C#实现常用排序算法

　　本文实现的常用排序算法包括：冒泡排序，快速排序，希尔排序，插入排序，选择排序，归并排序。

　　冒泡排序：从后向前遍历数组，比较相邻的两个元素。如果两个元素的顺序是错的，那么就交换这两个元素。如果某次遍历过程中，元素都没有发生交换，那么说明数组已经排序好，可以中止停止排序。最坏的情况是在起始数组中，需要排在最后的元素位于最前边，那么冒泡算法必须经过n-1次遍历才能将数组排列好，而不能提前完成排序。该算法的时间复杂度是O(n^2)，是稳定的排序算法。

        /// <summary>
        /// 冒泡排序
        /// </summary>
        /// <param name="array">待排序的数组</param>
        /// <param name="isReverse">是否逆序</param>
        /// <param name="sortedArray">排序后的数组</param>
        public static void BubbleSort(IEnumerable<T> array, bool isReverse, out List<T> sortedArray)
        {
            sortedArray = array.ToList();
            int n = sortedArray.Count; ;
            int sign;//结束标记
            for (int j = 0; j < n - 1; j++)
            {
                sign = 0;
                for (int i = n - 1; i > j; i--)
                {
                    T item = sortedArray[i];
                    T preItem = sortedArray[i - 1];
                    if (isReverse && item.CompareTo(preItem) > 0 || //逆序
                        !isReverse && item.CompareTo(preItem) < 0)  //顺序
                    {
                        sign = 1;//不能结束
                        Swap(sortedArray, i, i-1);//交换元素的位置
                    }
                }
                if (sign < 1)
                    break;
            }
        }

　　快速排序：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。该算法是对冒泡排序的改进算法，时间复杂度是O(n*logn)，不是稳定的排序算法。

        /// <summary>
        /// 快速排序
        /// </summary>
        /// <param name="array">待排序的数组</param>
        /// <param name="isReverse">是否逆序</param>
        /// <param name="sortedArray">排序后的数组</param>
        public static void QuickSort(IEnumerable<T> array, bool isReverse, out List<T> sortedArray)
        {
            sortedArray = array.ToList();
            int n = sortedArray.Count;

            int key = 0;//选取第一个元素为两部分数据的分割项的索引

            //将数组分割成两部分
            int i = 0, j = n - 1;
            while(i < j)
            {
                while (j > i)
                {
                    if (isReverse && sortedArray[j].CompareTo(sortedArray[key]) > 0 ||
                        !isReverse && sortedArray[j].CompareTo(sortedArray[key]) < 0)
                    {
                        Swap(sortedArray, j, i);
                        key = j;
                        break;
                    }
                    j--;
                }
                while (i < j)
                {
                    if (isReverse && sortedArray[i].CompareTo(sortedArray[key]) < 0 ||
                        !isReverse && sortedArray[i].CompareTo(sortedArray[key]) > 0)
                    {
                        Swap(sortedArray, j, i);
                        key = i;                        
                        break;
                    }
                    i++;
                }
            }   
            if (n <= 2) return;//结束条件
            else
            {
                //递归调用，对key前面的数组进行排序
                List<T> array1 = new List<T>();
                for (i = 0; i < key; i++)
                {
                    array1.Add(sortedArray[i]);
                }
                QuickSort(array1, isReverse, out array1);
                for (i = 0; i < key; i++)
                {
                    sortedArray[i] = array1[i];
                }
                //递归调用，对key后面的数组进行排序
                List<T> array2 = new List<T>();
                for (i = 0; i < n - key - 1; i++)
                {
                    array2.Add(sortedArray[key + 1 + i]);
                }
                QuickSort(array2, isReverse, out array2);
                for (i = 0; i < array2.Count; i++)
                {
                    sortedArray[key + 1 + i] = array2[i];
                }
            }
        }

　　希尔排序：将要排序的一组数按某个增量d分成若干组，每组中记录的下标相差d。对每组中全部元素进行排序，然后再用一个较小的增量对它进行，在每组中再进行排序。当增量减到1时，整个要排序的数被分成一组，排序完成。该算法是对冒泡排序的改进，又称缩小增量排序，也可配合其他排序算法使用。该算法的时间复杂度是O(n*logn)，是不稳定的排序算法。

        /// <summary>
        /// 希尔排序
        /// </summary>
        /// <param name="array">待排序的数组</param>
        /// <param name="isReverse">是否逆序</param>
        /// <param name="sortedArray">排序后的数组</param>
        public static void ShellSort(IEnumerable<T> array, bool isReverse, out List<T> sortedArray)
        {
            sortedArray = array.ToList();
            int n = sortedArray.Count;
            //初始化增量
            int step = 1;
            while (step < n) step = 3 * step + 1;

            while (step > 1)
            {
                step = step / 3 + 1;
                for (int i = 0; i < step; i++)
                {
                    int nsub = (n - i - 1) / step + 1;
                    List<T> subArray = new List<T>();
                    for (int j = 0; j < nsub; j++)
                    {
                        subArray.Add(sortedArray[i + j * step]);
                    }
                    BubbleSort(subArray, isReverse, out subArray);//此处也可使用其他排序算法
                    for (int j = 0; j < nsub; j++)
                    {
                        sortedArray[i + j * step] = subArray[j];
                    }
                }
            }
        }

　　插入排序：假定这个数组的序是排好的，然后从头往后，如果有数比当前外层元素的值大，则将这个数的位置往后挪，直到当前外层元素的值大于或等于它前面的位置为止。算法适用于少量数据的排序，时间复杂度为O(n^2)，是稳定的排序方法。

        /// <summary>
        /// 插入排序
        /// </summary>
        /// <param name="array">待排序的数组</param>
        /// <param name="isReverse">是否逆序</param>
        /// <param name="sortedArray">排序后的数组</param>
        public static void InsertSort(IEnumerable<T> array, bool isReverse, out List<T> sortedArray)
        {
            sortedArray = array.ToList();
            int n = sortedArray.Count;
            for (int j = 1; j < n; j++)
            {
                int i = j - 1;
                T item = sortedArray[i];
                T nextItem = sortedArray[i + 1];
                while (isReverse && item.CompareTo(nextItem) < 0 ||
                      !isReverse && item.CompareTo(nextItem) > 0)
                {
                    Swap(sortedArray, i, i + 1);//交换元素的位置
                    i--;
                    if (i >= 0)
                    {
                        item = sortedArray[i];
                        nextItem = sortedArray[i + 1];
                    }
                    else
                    {
                        break;
                    }
                }               
            }
        }

　　选择排序：先找到起始数组中最小的元素，将它交换到i=0；然后寻找剩下元素中最小的元素，将它交换到i=1的位置…… 直到找到第二大的元素，将它交换到n-2的位置。这时，整个数组的排序完成。该算法的时间复杂度是O(n^2)，不是稳定的排序算法。　　

        /// <summary>
        /// 选择排序
        /// </summary>
        /// <param name="array">待排序的数组</param>
        /// <param name="isReverse">是否逆序</param>
        /// <param name="sortedArray">排序后的数组</param>
        public static void SelectSort(IEnumerable<T> array, bool isReverse, out List<T> sortedArray)
        {
            sortedArray = array.ToList();
            int n = sortedArray.Count;
            int selectIndex;
            for (int j = 0; j < n - 1; j++)
            {
                selectIndex = j;
                for (int i = j + 1; i < n; i++)
                { 
                    T item = sortedArray[i];
                    if ((isReverse && sortedArray[selectIndex].CompareTo(item) < 0) ||
                        (!isReverse && sortedArray[selectIndex].CompareTo(item) > 0))
                    {
                        selectIndex = i;
                    }
                }
                Swap(sortedArray, selectIndex, j);
            }
        }

　　归并排序：将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。该算法的时间复杂度是O(n*logn)，是稳定的排序算法。 

        /// <summary>
        /// 归并排序
        /// </summary>
        /// <param name="array">待排序的数组</param>
        /// <param name="isReverse">是否逆序</param>
        /// <param name="sortedArray">排序后的数组</param>
        public static void MergeSort(IEnumerable<T> array, bool isReverse, out List<T> sortedArray)
        {
            sortedArray = array.ToList();
            int n = sortedArray.Count;

            if (n <= 1) return;//结束标识
            
            //将数组分为两个数组
            int n1 = n / 2;
            List<T> array1 = new List<T>();
            for (int k = 0; k < n1; k++)
            {
                array1.Add(sortedArray[k]);
            }
            int n2 = n - n1;
            List<T> array2 = new List<T>();
            for (int k = 0; k < n2; k++)
            {
                array2.Add(sortedArray[n1 + k]);
            }

            //递归调用
            MergeSort(array1, isReverse, out array1);
            MergeSort(array2, isReverse, out array2);

            //合并有序序列
            int i = 0, j = 0;//array1和array2的索引
            int index = 0;//sortedArray的索引
            while (i < n1 && j < n2)
            {                
                if (isReverse && array1[i].CompareTo(array2[j]) > 0 ||
                    !isReverse && array1[i].CompareTo(array2[j]) <= 0)
                {
                    sortedArray[index++] = array1[i++];
                }
                else
                {
                    sortedArray[index++] = array2[j++];
                }                
            }
            while (i < n1)
            {
                sortedArray[index++] = array1[i++];
            }
            while (j < n2)
            {
                sortedArray[index++] = array2[j++];
            }
        }