各种排序算法汇集

        private void Sort1(int[] list)//冒泡排序
        {
            //从第一个字符向后冒泡亮亮比较获取最大值放在最后
            //第一次循环首先得到一个最大值；第二次循环得到第二大值
            int i, j, temp;
            bool done = false;
            j = 1;
            while ((j < list.Length) && (!done))
            {
                done = true;
                for (i = 0; i < list.Length - j; i++)
                {
                    if (list[i] > list[i + 1])
                    {
                        done = false;
                        temp = list[i];
                        list[i] = list[i + 1];
                        list[i + 1] = temp;
                    }
                }
                j++;
            }
        }
        //选择排序
        //向后冒泡获取最小值的索引，然后和第i个值进行数据交换
        private void Sort2(int[] list)
        {
            int minIndex = 0;
            for (int i = 0; i < list.Length; i++)
            {
                minIndex = i;
                for (int j = i; j < list.Length; j++)
                {
                    if (list[j] < list[minIndex])
                    {
                        minIndex = j;
                    }
                }
                int temp = list[i];
                list[i] = list[minIndex];
                list[minIndex] = temp;
            }
        }
        //插入排序
        //此种算法是首先循环第二个元素，让第二个元素和第一个元素比较，如果i+1<i,交换。
        //然后依次进行，如果是循环第i个元素，i索引的数据将会和前边所有的数据进行比较，如果i索引数据小于后边的数据，则继续下去知道最后一个进行替换，否则跳出继续下一个；

        private void Sort3(int[] list)
        {
            for (int i = 1; i < list.Length; i++)
            {
                int t = list[i];
                for (int j = i; j > 0; j--)
                {
                    if (list[j - 1] > t)
                    {
                        list[j] = list[j - 1];
                        list[j - 1] = t;
                    }
                }
            }
        }
        private void Sort4(int[] list)//希尔排序
        {
            //list.Length=25;
            int inc;
            for (inc = 1; inc <= list.Length / 9; inc = 3 * inc + 1) ;
            for (; inc > 0; inc = inc / 3)
            {
                for (int i = inc + 1; i <= list.Length; i += inc)
                {
                    int t = list[i - 1];
                    int j = i;
                    while ((j > inc) && (list[j - inc - 1] > t))
                    {
                        list[j - 1] = list[j - inc - 1];
                        j -= inc;
                    }
                    list[j - 1] = t;
                }
            }
        }
        //快速排序
        private void quick_sort(int[] s, int l, int r)
        {
            if (l < r)
            {
                int i = l, j = r, data = s[l];
                while (i < j)
                {
                    while (i < j && s[j] >= data) // 从右向左找第一个小于x的数
                    {
                        j--;
                    }
                    if (i < j)
                    {
                        s[i] = s[j];
                        i++;
                    }

                    while (i < j && s[i] < data) // 从左向右找第一个大于等于x的数
                    {
                        i++;
                    }
                    if (i < j)
                    {
                        s[j] = s[i];
                        j--;
                    }
                }
                s[i] = data;//第一次循环获取的是左边的数据都比data小的数据，右边的大于data的数据
                quick_sort(s, l, i - 1); // 递归调用
                quick_sort(s, i + 1, r);
            }
        }