幾種排序(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