[C#][算法] 用菜鸟的思惟学习算法 -- 马桶排序、冒泡排序和快速排序

用菜鸟的思惟学习算法 -- 马桶排序、冒泡排序和快速排序

【博主】反骨仔　　　　【来源】http://www.cnblogs.com/liqingwen/p/4994261.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         }

 

快速排序（见证亚当和夏娃的爱情之旅）

　　1、场景：对 6 1 2 7 9 3 4 5 10 8 这 10 个数进行排序

 

　　2、思路：

　　　　先找一个基准数（一个用来参照的数），为了方便，咱们选最左边的 6，但愿将 >6 的放到 6 的右边，<6 的放到 6 左边。如：3 1 2 5 4 6 9 7 10 8

　　　　先假设须要将 6 挪到的位置为 k，k 左边的数 <6，右边的数 >6

　　　　（1）咱们先从初始数列“6 1 2 7 9 3 4 5 10 8 ”的两端开始“探测 ”，先从右边往左找一个 <6 的数，再从左往右找一个 >6 的数，而后交换。咱们用变量 i 和变量 j 指向序列的最左边和最右边。刚开始时最左边 i=0 指向 6，最右边 j=9 指向 8

 

 

 

图：亚当 i 和夏娃 j 

 

　　　　（2）如今设置的基准数是最左边的数，因此序列先右往左移动（j--），当找到一个 <6 的数（5）就停下来。接着序列从左往右移动（i++），直到找到一个 >6 的数又停下来（7）；

　　　　（3）二者交换，结果：6 1 2 5 9 3 4 7 10 8；

 

 

 

　　　　（4）j 的位置继续向左移动（友情提示：每次都必须先从 j 的位置出发），发现 4 知足要求，接着 i++ 发现 9 知足要求，交换后的结果：6 1 2 5 4 3 9 7 10 8；

 

 

　　　　（5）目前 j 指向的值为 9，i 指向的值为 4，j-- 发现 3 符合要求，接着 i++ 发现 i=j，说明这一轮移动结束啦。如今将基准数 6 和 3 进行交换，结果：3 1 2 5 4 6 9 7 10 8； 如今 6 左边的数都是 <6 的，而右边的数都是 >6 的，但游戏还没结束

 

　　　　

  图：亚当和夏娃终于产生了交集

 

　　　　（6）咱们将 6 左边的数拿出来先：3 1 2 5 4，此次以 3 为基准数进行调整，使得 3 左边的数 <3，右边的数 >3，根据以前的模拟，此次的结果：2 1 3 5 4

　　　　（7）再将 2 1 抠出来从新整理，获得的结果： 1 2

　　　　（8）剩下右边的序列：9 7 10 8 也是这样来搞，最终的结果： 1 2 3 4 5 6 7 8 9 10 （具体看下图）

 

 

 

 

　　　　【总结】快速排序的每一轮处理其实就是将这一轮的基准数归位，当全部的基准数归位，排序就结束啦

 

 

 

 

---

　　【参考】文章改编与插图来源《啊哈！算法》