[C#][算法] 用菜鳥的思惟學習算法 -- 馬桶排序、冒泡排序和快速排序

時間 2019-11-13

原文原文鏈接

用菜鳥的思惟學習算法 -- 馬桶排序、冒泡排序和快速排序

【博主】反骨仔　　　　【來源】http://www.cnblogs.com/liqingwen/p/4994261.html 　　html

馬桶排序（使人做嘔的排序）

　　1、場景：期末考試完了，老師要將同窗們的分數從高到低排序。假設班上有 5 名同窗，分別考了 5 分、3 分、5 分、2 分和 8 分【滿分：10 分】，排序後的結果就是 8 5 5 3 2，如今，讓咱們先思考 10 分鐘吧！

　　2、思路：

　　　　（1）先建立一個數組 int scores[11]，就有 scores[0]~scores[10] 共 11 個變量。咱們用變量值爲 0 表示沒有人獲得該分數，即 scores [0]=0 表示沒有人得 0 分，scores [10]=0 表示沒有人得 10 分，而 scores [8]=1 表示有一我的獲得 8 分。

　　　　（2）第 1 個數爲 5，因此在 scores[5]=0 的基礎上+1，即 scores[5]=1 表示有 1 人獲得 5 分

　　　　（3）第 2 個數爲 3，因此在 scores[3]=0 的基礎上+1，即 scores[3]=1 表示有 1 人獲得 3 分

　　　　（4）第 3 個數爲 5，因此在 scores[5]=1 的基礎上+1，即 scores[5]=2 表示有 2 人獲得 5 分

　　　　　　... ...

　　　　（5）依此類推，處理第 4 和第 5 個數，最終的結果圖以下：

　　　　（6）咱們發現，scores[0]~scores[10] 內對應的值就是 0~10 分中每一個分數所出現的次數。如今，只需將結果打印便可，出現幾回就打印機次。

咱們暫且稱它爲「馬桶排序」，這個算法就至關於有 11 個馬桶，編號從 0~10。每出現一個數，就在對應編號的馬桶中放一個旗子。

圖：這裏有 11 個馬桶

　　 3、思考：如今分別有 5 我的的名字和分數：小A 五、小二三、小三五、小妞 2 和王大錘 8，請按照分數從高到低，輸出他們的名字？

　　【特色】

　　　　假設須要排序的範圍 0~20000000，則須要 new int[20000001]，很是浪費空間，即使只給 2 個數排序（1,19999999 ）;

　　　　若是排序的數是小數也不行，如：3.141 5926 5358 9793 2384 6264 3383 2795 0238；

　　這裏使用 C# 給出簡單的算法過程。

 1         static void Main(string[] args)
 2         {
 3             var scores = new int[] { 5, 3, 5, 2, 8 };
 4             var newScores = new int[9];
 5 
 6             for (int i = 0; i < scores.Length; i++)
 7             {
 8                 var score = scores[i];
 9                 newScores[score]++;
10             }
11 
12             for (int i = newScores.Length - 1; i >= 0; i--)
13             {
14                 var num = newScores[i];
15                 for (int j = 1; j <= num; j++)
16                 {
17                     Console.Write($"{i} ");
18                 }
19             }
20 
21             Console.WriteLine();
22             Console.Read();
23         }
24     }

冒泡排序（面試都要問的算法）

　　1、基本思想：每次比較相鄰的兩個元素，按需調整順序

　　2、題目：要求將 12 35 99 18 76 這 5 個數進行從大到小排序

　　3、思路：

　　　　（1）先比較第 1 位和第 2 位的大小，12<35，由於但願越小越靠後，因此要調整二者順序，交換後的結果：35 12 99 18 76

　　　　（2）如今比較第 2 位和第 3 位的大小，12<99，因此須要交換位置，交換後的結果爲：35 99 12 18 76

　　　　（3）接着比較第 3 位和第 4 位的大小，12<18，交換後的結果爲：35 99 18 12 76

　　　　（4）最後比較第 4 位和第 5 位的大小，12<76，交換後的結果爲：35 99 18 76 12

　　　　（5）通過 4 次後咱們發現 5 個數中最小的一個數已經就位，每將一個數歸位咱們稱其爲「一趟」；

　　　　（6）如今咱們開始第二趟，目標將第 2 小的數歸位，根據以前邏輯，仍是從第 1 個數和第 2 個數開始比較上：

　　35 99 18 76 12 --①--> 99 35 18 76 12 --②--> 99 35 18 76 12 --③--> 99 35 76 18 12

　　在第一趟比較就知道第 5 位是最小的，因此第 4 位不用和第 5 位比較，這一趟只需比較 3 次

　　　　（7）第3趟：99 35 76 18 12 --> 99 35 76 18 12 --> 99 76 35 18 12 （比較 2 次）

　　　　（8）第4趟：99 76 35 18 12 --> 99 76 35 18 12 ,有4個數已經就位，那麼最後一個數無須比較，它就是最大的

　　【總結】若是有 n 個數進行排序，只需將 n-1 個數歸位，即要進行 n-1 趟操做，而每一趟開始都從第 1 位進行相鄰的兩個數進行比較，將小的那個數放在後面，已經歸位的就不用進行比較。

　　【特色】冒泡算法的核心部分是雙重嵌套循環，能夠看出時間複雜度是 O(N²)，這是一個很是高的時間複雜度。

　　這裏使用 C# 給出簡單的算法過程。

 1         static void Main(string[] args)
 2         {
 3             var nums = new int[] { 12, 35, 99, 18, 76 };
 4             Output(nums);
 5 
 6             for (int j = 0; j < nums.Length - 1; j++)
 7             {
 8                 for (int i = 0; i < nums.Length - 1; i++)
 9                 {
10                     if (nums[i] < nums[i + 1])
11                     {
12                         var temp = nums[i];
13                         nums[i] = nums[i + 1];
14                         nums[i + 1] = temp;
15                     }
16                 }
17 
18                 Output(nums);
19             }
20 
21             Console.Read();
22         }
23 
24         /// <summary>
25         /// 控制檯輸出
26         /// </summary>
27         /// <param name="nums"></param>
28         static void Output(int[] nums)
29         {
30             foreach (var num in nums)
31             {
32                 Console.Write($"{num} ");
33             }
34 
35             Console.WriteLine();
36         }