• 几种排序(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; }
  • 相关阅读:
    113. Path Sum II
    112. Path Sum
    111. Minimum Depth of Binary Tree
    110. Balanced Binary Tree
    Create
    SetWindowPos
    INT_PTR数据类型
    SDK介绍
    COLORREF
    setfont()函数
  • 原文地址:https://www.cnblogs.com/wskxy/p/10988341.html
Copyright © 2020-2023  润新知