排序算法--SortingAlgorithm

 1.排序算法图解

    /// <summary>
    /// 排序算法
    /// </summary>
    public class SortingAlgorithm
    {
        /// <summary>
        /// [01][稳定] 冒泡排序 
        /// 1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。
        /// 2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
        /// 3.针对所有的元素重复以上的步骤，除了最后一个。
        /// 4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="array"></param>
        public static void BubbleSort<T>(T[] array) where T : IComparable<T>
        {
            for (int i = 0; i < array.Length; i++)
            {
                var swapped = false;
                var length = array.Length - 1 - i;
                for (int j = 0; j < length; j++)
                {
                    var value = array[j];
                    var latterValue = array[j + 1];
                    if (value.CompareTo(latterValue) > 0)
                    {
                        array[j] = latterValue;
                        array[j + 1] = value;
                        if (!swapped)
                        {
                            swapped = true;
                        }
                    }
                }
                if (!swapped)
                {
                    return;
                }
            }
        }

2.选择排序图解

 
        /// <summary>
        /// [02][不稳定] 选择排序
        /// 整數或浮點數皆可使用
        /// 1.首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
        /// 2.再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
        /// 3.重复第二步，直到所有元素均排序完毕。
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="array"></param>
        public static void SelectionSort<T>(T[] array) where T : IComparable<T>
        {
            var length = array.Length;
            for (var i = 0; i < length - 1; i++)
            {
                var min = i;
                for (var j = i + 1; j < length; j++)
                {
                    if (array[min].CompareTo(array[j]) > 0)
                    {
                        min = j;
                    }
                }
                var temp = array[min];
                array[min] = array[i];
                array[i] = temp;
            }
        }

 3.插入排序图解

        /// <summary>
        /// [03][稳定] 插入排序
        /// 1.将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。
        /// 2.从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="array"></param>
        public static void InsertSort<T>(T[] array) where T : IComparable<T>
        {
            for (int i = 1; i < array.Length; i++)
            {
                var temp = array[i];
                for (int j = i - 1; j >= 0; j--)
                {
                    var value = array[j];
                    if (value.CompareTo(temp) <= 0)
                    {
                        break;
                    }
                    array[j + 1] = array[j];
                    array[j] = temp;
                }
            }
        }

4.希尔排序图解 

        /// <summary>
        /// [04][不稳定] 希尔排序
        /// 1.选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；
        /// 2.按增量序列个数 k，对序列进行 k 趟排序；
        /// 3.每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。
        ///   仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整