各常见排序算法实践 C#

来自：http://blog.youkuaiyun.com/stevenkylelee/article/details/7300395

如题。

实践了下几种比较常见的内排算法。并对各种排序算法的执行效率也排了个序。

数据量不大的情况下，一般是堆排比较快。

数据量很大时，快排才会有优势。

 

截图如下：为了更清楚看到结果，运行的是debug版。

 

 

源代码下载（语言:C++)：

http://download.youkuaiyun.com/detail/stevenkylelee/4095219

 

呵呵。

下面来一段BT点的。

看过《疯狂的程序员》吗？

P162最后一个段落开头有这样一句话：

“绝影晃眼看了看强哥做的题，虽然编译能通过，但逻辑肯定错了，冒泡排序法，才一个for语句，单凭这一点，也就算是连海选都没通过。”

我看到这里时，就开始思考：单for排序也是可以的吧。

然后，用C#语言，写了4个排序。

第一个只用了一个 for循环。

第二 第三个排序，没用任何循环控制语句。

第四个排序用了一个for，但只有一句话。

直接贴上代码吧。

提醒：不要拿这种问题去考别人，因为没什么建设性意义。纯属无聊恶搞。

 

[csharp]  view plain copy print ?

1. class Program  
2. {  
3.     static void Main(string[] args)  
4.     {  
5.         // 初始化3个列表，用于排序测试  
6.         Random Rnd = new Random(  ) ;  
7.         List<int> Array1 = new List< int >() ;  
8.         for (int i = 0; i < 20; ++i)  
9.         {  
10.             Array1.Add(Rnd.Next(0, 10));  
11.         }  
12.         List<int> Array2 = new List< int >( Array1 ) ;  
13.         List<int> Array3 = new List<int>(Array1);  
14.         List<int> Array4 = new List<int>(Array1);  
15.   
16.         Console.Write("待排序的关键字：\n");  
17.         Print(Array1);  
18.   
19.         Console.Write("单循环排序结果：\n");  
20.         Sort_1(Array1);  
21.         Print(Array1);  
22.   
23.         Console.Write("单循环排序2结果：\n");  
24.         Sort_4(Array4);  
25.         Print(Array4);  
26.   
27.         Console.Write("无循环语句排序结果：\n");  
28.         Sort_2(Array2, 0, 1);  
29.         Print(Array2);  
30.   
31.         Console.Write("无循环语句排序2结果：\n");  
32.         Sort_3(Array3, 0, 1);  
33.         Print(Array3);   
34.   
35.     }  
36.   
37.     // 在屏幕上打印列表内容  
38.     static void Print(List<int> Array)  
39.     {  
40.         for (int i = 0; i < Array.Count; ++i)  
41.         {  
42.             Console.Write(Array[i] + " ");  
43.         }  
44.         Console.Write("\n\n");  
45.     }  
46.   
47.     static void Swap(List<int> Array , int a, int b)  
48.     {  
49.         int t = Array[ a ];  
50.         Array[a] = Array[ b ];  
51.         Array[ b ] = t;  
52.   
53.     }  
54.   
55.     static int Swap2(List<int> Array, int a, int b)  
56.     {  
57.         int t = Array[a];  
58.         Array[a] = Array[b];  
59.         Array[b] = t;  
60.   
61.         return 1;  
62.     }  
63.   
64.     /// <summary>  
65.     /// 如果我是强哥。我写的单for排序会是这样。  
66.     /// 注意了。我只用了一个for哦  
67.     /// </summary>  
68.     static void Sort_1(List<int> Array)  
69.     {  
70.         for (int i = Array.Count - 1 ; i > 0 ; --i)  
71.             DoSort_1( Array , i , 0 ) ;   
72.     }  
73.     static void DoSort_1( List<int> Array , int i , int j )  
74.     {  
75.         if (j >= i) return;  
76.         if( Array[ i ] < Array[ j ] ) Swap(Array , i , j );  
77.         DoSort_1(Array, i, ++j);  
78.     }  
79.   
80.     /// <summary>  
81.     /// 但我不是强哥。我是 Steven·Kyle·Lee。  
82.     /// 所以，我会搞一个更加“变态”的。  
83.     /// 注意了。我没用任何循环关键字。只用了3个if。  
84.     /// 最后2个形参必须被初始化调用为：0,1  
85.     /// </summary>  
86.     static void Sort_2( List<int> Array , int i , int j )  
87.     {  
88.         if (j >= Array.Count ) return;  
89.         if (Array[i] > Array[j]) Swap(Array, i, j);  
90.         if (++j >= Array.Count ) j = ++i + 1;  
91.         Sort_2(Array , i , j );  
92.     }  
93.   
94.     /// <summary>  
95.     /// 继续“变态”，第二种无循环排序  
96.     /// 最后2个形参必须被初始化调用为：0,1  
97.     /// </summary>  
98.     static void Sort_3(List<int> Array, int i, int j)  
99.     {  
100.         if (i >= Array.Count - 1 || j >= Array.Count - i ) return;  
101.         if (Array[j] < Array[j-1]) Swap(Array, j, j - 1 ) ;  
102.         if (++j >= Array.Count - i && ( j = 1 ) == j ) ++i ;  
103.         Sort_3(Array, i, j);  
104.     }  
105.   
106.     /// <summary>  
107.     /// 将“变态”进行到底  
108.     /// 单for，1句话排序。  
109.     /// </summary>  
110.     static void Sort_4(List<int> Array )  
111.     {  
112.         for (int i = 0, j = i + 1, k = 1; i < Array.Count && 1 == (k = Array[i] < Array[j] ? Swap2(Array, i, j) : 1); i = ++j >= Array.Count && (j = 0) == j ? i + 1 : i)  
113.             ;  
114.     }