十大排序算法c#

1.冒泡排序

        /// <summary>
        /// 冒泡排序  (每次循环都将最值，一步一步交换到最后位置，与选择排序的差别是交换的次数和是否记录每次最值的游标位置)
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        public static int[] BubbleOrder(int[] list)
        {
            for (int i = 0, j = list.Length - 1; i < j; i++)
            {
                // 从后往前冒泡，将最值一步一步交换到每次循环的队首
                //for (int x = i + 1, y = list.Length - 1; x < y; y--)
                //{
                //    if (list[y] > list[y - 1])
                //    {
                //        var min = list[y - 1];
                //        list[y - 1] = list[y];
                //        list[y] = min;
                //    }
                //}
                // 从前往后冒泡，将最值一步一步交换到每次循环的队尾
                for (int x = 0, y = list.Length - 1 - i; x < y; x++)
                {
                    if (list[x] > list[x + 1])
                    {
                        var max = list[x];
                        list[x] = list[x + 1];
                        list[x + 1] = max;
                    }
                }
            }
            return list;
        }

2.选择排序

        /// <summary>
        /// 选择排序（每次循环找到一个最值[最大值或最小值]，然后交换到响应位置，每次外层循环只交换一次）
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        public static int[] SelectOrder(int[] list)
        {
            for (int i = 0, j = list.Length; i < j; i++)
            {
                int min = list[i];
                int minCursor = i;
                for (int x = i + 1, y = list.Length; x < y; x++)
                {
                    if (min > list[x])
                    {
                        minCursor = x;
                        min = list[x];
                    }
                }
                min = list[minCursor];
                list[minCursor] = list[i];
                list[i] = min;
            }
            return list;
        }

3.插入排序

        /// <summary>
        /// 插入排序
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        public static int[] InsertOrder(int[] list)
        {
            int time = 0;
            int preIndex = 0; int current = 0;
            for (int i = 1, j = list.Length; i < j; i++)
            {
                preIndex = i - 1;
                current = list[i];
                // 选择一个当前值，从当前位置往前对比，知道找到自己的位置，中间过程中，挨个交换经过的所有值（也就是将中间经过的值整体往后挪动一个位置）
                while (preIndex >= 0 && list[preIndex] > current)
                {
                    time = time + 1;
                    list[preIndex + 1] = list[preIndex];
                    preIndex--;
                }
                list[preIndex + 1] = current;
            }
            return list;
        }

4.希尔排序

        /// <summary>
        /// 希尔排序  
        /// 先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录"基本有序"时，再对全体记录进行依次直接插入排序。
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        public static int[] ShellOrder(int[] list)
        {
            int k = 3; // 将数据分成多少份
            int lenght = list.Length;
            int temp;
            for (int step = lenght / k; step >= 1; step /= k)
            {
                for (int i = step; i < lenght; i++)
                {
                    temp = list[i];
                    int j = i - step;
                    while (j >= 0 && list[j] > temp)
                    { 
                        list[j+step]=list[j];
                        j-= step;
                    }
                    list[j + step] = temp;
                }
            }

            return list;
        }