几种排序(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();

  程序员内功修炼(排序)

        /// <summary>
        /// 直接插入排序
        /// </summary>
        /// <param name="arr"></param>
        /// <returns></returns>
        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;
        }
        /// <summary>
        /// 二分插入排序(是对直接插入排序的改进)
        /// </summary>
        /// <param name="arr"></param>
        /// <returns></returns>
        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;
        }
        /// <summary>
        /// 希尔排序
        /// </summary>
        /// <param name="arr"></param>
        /// <returns></returns>
        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;
        }
        /// <summary>
        /// 冒泡排序
     /// 最小的往前冒
/// </summary> /// <param name="arr"></param> /// <returns></returns> 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; } /// <summary> /// 快速排序(目前最好的排序) /// </summary> /// <param name="arr"></param> /// <param name="low"></param> /// <param name="high"></param> /// <returns></returns> 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; } /// <summary> /// 直接选择排序 /// </summary> /// <param name="arr"></param> /// <returns></returns> 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; }

 


免责声明!

本站转载的文章为个人学习借鉴使用,本站对版权不负任何法律责任。如果侵犯了您的隐私权益,请联系本站邮箱yoyou2525@163.com删除。



 
粤ICP备18138465号  © 2018-2025 CODEPRJ.COM