几种排序（c#实现）

　　代码：

            int[] arr = { 2, 3, 4, 6, 1, 5, 4 };
            // 冒泡排序：把最小的往前冒 O(n2)
            //int temp1;
            //for (int i = 0; i < arr.Length - 1; i++)
            //{
            //    for (int j = i + 1; j < arr.Length; j++)
            //    {
            //        if (arr[j] < arr[i])
            //        {
            //            temp1 = arr[j];
            //            arr[j] = arr[i];
            //            arr[i] = temp1;
            //        }
            //    }
            //}
            // 选择排序：从小到大依次选出来 O(n2)
            //for (int i = 0; i < arr.Length - 1; i++)
            //{
            //    int temp2 = arr[i];
            //    int index = i;
            //    for (int j = i + 1; j < arr.Length; j++)
            //    {
            //        if (arr[j] < temp2)
            //        {
            //            temp2 = arr[j];
            //            index = j;
            //        }
            //    }
            //    arr[index] = arr[i];
            //    arr[i] = temp2;
            //}
            // 直接插入排序：适合基本有序 O(n2)
            //for (int i = 1; i < arr.Length; i++)
            //{
            //    int temp = arr[i];
            //    int j;
            //    for (j = i - 1; j >= 0; j--)
            //    {
            //        if (temp > arr[j])
            //        {
            //            break;
            //        }
            //        arr[j + 1] = arr[j];
            //    }
            //    arr[j + 1] = temp;
            //}
            // 希尔排序
            //int gap = arr.Length / 2;
            //while (gap >= 1)
            //{
            //    // 把距离为 gap 的元素编为一个组，扫描所有组
            //    for (int i = gap; i < arr.Length; i++)
            //    {
            //        int j = 0;
            //        int temp = arr[i];
            //        // 对距离为 gap 的元素组进行排序
            //        for (j = i - gap; j >= 0 && temp < arr[j]; j = j - gap)
            //        {
            //            arr[j + gap] = arr[j];
            //        }
            //        arr[j + gap] = temp;
            //    }
            //    gap = gap / 2;
            //}

            for (int i = 0; i < arr.Length; i++)
            {
                Console.WriteLine(arr[i]);
            }
            Console.ReadLine();

二、程序员内功修炼（排序）

1、直接插入排序：适合数组基本有序的情况

　　像打扑克牌，从前往后对应，把数字插入到合适的位置，如：

　　

　　初始值3，认为一个已经有序的序列

　　第一次遍历：6和3比

　　第二次遍历：5和6、5和3

　　第三次遍历：9和6

　　弟四次遍历：7和9、7和6

　　以此类推。。

　　代码：

        public static int[] InsertionSort(int[] arr)
        {
            /*
             数据结构-数组
             最差时间复杂度-输入的序列为降序，复杂度为O(n^2)
             最优时间复杂度-输入的序列为升序，复杂度为O(n)
             辅助空间-O(1)
             稳定性-稳定
             */
            for (int i = 1; i < arr.Length; i++)
            {
                int temp = arr[i];
                int j = i - 1;
                while (j >= 0 && temp < arr[j])
                {
                    arr[j + 1] = arr[j];
                    j--;
                }
                arr[j + 1] = temp;
            }
            return arr;
        }

2、二分插入排序（是对直接插入排序的改进）：适合数组较长的情况

　　直接插入排序每次遍历均是从右往左找，直到找到比自己小的，当序列足够长的情况下，这很耗时

　　二分是取前面有序序列的中间值做对比，一半一半缩小范围，减少排序对比时间。

        public static int[] BinarySort(int[] arr)
        {
            /*
            数据结构-数组
            最差时间复杂度-输入的序列为降序，复杂度为O(n^2)
            最优时间复杂度-输入的序列为升序，复杂度为O(log2 n)
            辅助空间-O(1)
            稳定性-稳定
            */
            for (int i = 1; i < arr.Length; i++)
            {
                int temp = arr[i];
                int low = 0;
                int high = i - 1;
                while (low <= high)
                {
                    int mid = (low + high) / 2;
                    if (temp >= arr[mid])
                        low = mid + 1;
                    else
                        high = mid - 1;
                }
                for (int j = i - 1; j >= low; j--)
                {
                    arr[j + 1] = arr[j];
                }
                arr[low] = temp;
            }
            return arr;
        }

3、希尔排序

　　又称为缩小增量排序，定义排序间隔，并逐步缩小增量，如图：

　　

        public static int[] ShellSort(int[] arr)
        {
            /*
            数据结构-数组
            最差时间复杂度-根据步长的不同而不同，已知最好的为O(n(log2 n)^2)
            最优时间复杂度-O(n)
            辅助空间-O(1)
            稳定性-不稳定
            */
            for (int gap = arr.Length / 2; gap >= 1; gap = gap / 2)
            {
                for (int i = gap; i < arr.Length; i++)
                {
                    int temp = arr[i];
                    int j = i - gap;
                    while (j >= 0 && temp < arr[j])
                    {
                        arr[j + gap] = arr[j];
                        j = j - gap;
                    }
                    arr[j + gap] = temp;
                }
            }
            return arr;
        }

4、冒泡排序

　　最小的往前冒  或者  最大的往后冒

        public static int[] BubbleSort(int[] arr)
        {
            /*
            数据结构-数组
            最差时间复杂度-O(n^2)
            最优时间复杂度-O(n^2)
            辅助空间-O(1)
            稳定性-稳定
            */
            for (int i = 0; i < arr.Length - 1; i++)
            {
                for (int j = i + 1; j < arr.Length; j++)
                {
                    if (arr[j] < arr[i])
                    {
                        int temp = arr[j];
                        arr[j] = arr[i];
                        arr[i] = temp;
                    }
                }
            }
            return arr;
        }

5、快速排序（目前最好的排序）

　　以第一个元素为基准值，把剩余元素小的放前边，大的放后边

　　

        public static int[] QuickSort(int[] arr, int low, int high)
        {
            /*
            数据结构-数组
            最差时间复杂度-每次选取的基准值都是最大或者最小O(n^2)
            最优时间复杂度-每次选取的基准值都是中位数O(nlogn)
            辅助空间-主要是递归造成的栈空间的使用，取决于递归树的深度，一般为O(logn)，最差为O(n)
            稳定性-不稳定
            */
            if (low >= high)
                return arr;
            int i = low;
            int j = high;
            int temp = arr[i];//基准值
            while (i < j)//从两端向中间扫描,跳出循环时i=j
            {
                while (i < j && arr[j] >= temp)//从右往左
                    j--;
                arr[i] = arr[j];
                while (i < j && arr[i] <= temp)//从左往右
                    i++;
                arr[j] = arr[i];
            }
            arr[i] = temp;// 基准值回归正确位置
            QuickSort(arr, low, i - 1);
            QuickSort(arr, i + 1, high);
            return arr;
        }

6、直接选择排序

　　直接选择最小的，和第一位替换位置，以此类推

        public static int[] SelectionSort(int[] arr)
        {
            /*
            数据结构-数组
            最差时间复杂度-O(n^2)
            最优时间复杂度-O(n^2)
            辅助空间-O(1)
            稳定性-不稳定
            */
            for (int i = 0; i < arr.Length - 1; i++)
            {
                int k = i; // k指向最小值索引
                for (int j = i + 1; j < arr.Length; j++)
                    if (arr[j] < arr[k])
                        k = j;
                if (k != i)
                {
                    int temp = arr[i];
                    arr[i] = arr[k];
                    arr[k] = temp;
                }
            }
            return arr;
        }