自己動手寫演算法.Sort.Bubble

Bubble Sort Algorithm

 

 

 

    This is an sorting algorithm which I learned when I began to study the C languange. I never wrote it down even though it's such a simple algorithm.

 

• Implementation

C++：

Cs

2. /*                                                                                  
3. 1. pick the last one as the seed
4. 2. if smaller than the previous one, swap it
5. 3. else the previous becomes as the seed
6. 4. this loop ends until to the 'top'
8. we can make sure that the smallest one is on the top each time
9. */
10. void SortBubble::sort(int arr[], const int nSize)
11. {
12.     ALog::print(_T("# Bubble Sort: /n#"));
13.     ALog::print(arr, nSize) << LINE_SPLIT;
15.     int top = 0;
16.     while( top < nSize-1 )
17.     {       
18.         ALog::print(_T("# ")) << top << std::endl;
19.         for(int cur=nSize-1; cur>top; --cur)
20.         {
21.             if( arr[cur] < arr[cur-1] )
22.             {
23.                 std::swap(arr[cur], arr[cur-1]);
24.             }
26.             ALog::print(arr, nSize);
27.         }
29.         ++top;
30.     }
32.     ALog::print(LINE_SPLIT);
33. }

• Test data

The intermediate results:

 

1. # Bubble Sort: 
2. # 2 9 3 7 8 6 4 5 0 1
3. =========================
4. # 0
5.  2 9 3 7 8 6 4 5 0 1
6.  2 9 3 7 8 6 4 0 5 1
7.  2 9 3 7 8 6 0 4 5 1
8.  2 9 3 7 8 0 6 4 5 1
9.  2 9 3 7 0 8 6 4 5 1
10.  2 9 3 0 7 8 6 4 5 1
11.  2 9 0 3 7 8 6 4 5 1
12.  2 0 9 3 7 8 6 4 5 1
13.  0 2 9 3 7 8 6 4 5 1
14. # 1
15.  0 2 9 3 7 8 6 4 1 5
16.  0 2 9 3 7 8 6 1 4 5
17.  0 2 9 3 7 8 1 6 4 5
18.  0 2 9 3 7 1 8 6 4 5
19.  0 2 9 3 1 7 8 6 4 5
20.  0 2 9 1 3 7 8 6 4 5
21.  0 2 1 9 3 7 8 6 4 5
22.  0 1 2 9 3 7 8 6 4 5
23. # 2
24.  0 1 2 9 3 7 8 6 4 5
25.  0 1 2 9 3 7 8 4 6 5
26.  0 1 2 9 3 7 4 8 6 5
27.  0 1 2 9 3 4 7 8 6 5
28.  0 1 2 9 3 4 7 8 6 5
29.  0 1 2 3 9 4 7 8 6 5
30.  0 1 2 3 9 4 7 8 6 5
31. # 3
32.  0 1 2 3 9 4 7 8 5 6
33.  0 1 2 3 9 4 7 5 8 6
34.  0 1 2 3 9 4 5 7 8 6
35.  0 1 2 3 9 4 5 7 8 6
36.  0 1 2 3 4 9 5 7 8 6
37.  0 1 2 3 4 9 5 7 8 6
38. # 4
39.  0 1 2 3 4 9 5 7 6 8
40.  0 1 2 3 4 9 5 6 7 8
41.  0 1 2 3 4 9 5 6 7 8
42.  0 1 2 3 4 5 9 6 7 8
43.  0 1 2 3 4 5 9 6 7 8
44. # 5
45.  0 1 2 3 4 5 9 6 7 8
46.  0 1 2 3 4 5 9 6 7 8
47.  0 1 2 3 4 5 6 9 7 8
48.  0 1 2 3 4 5 6 9 7 8
49. # 6
50.  0 1 2 3 4 5 6 9 7 8
51.  0 1 2 3 4 5 6 7 9 8
52.  0 1 2 3 4 5 6 7 9 8
53. # 7
54.  0 1 2 3 4 5 6 7 8 9
55.  0 1 2 3 4 5 6 7 8 9
56. # 8
57.  0 1 2 3 4 5 6 7 8 9
58. =========================

• Optimization

We can end the loops if there are no swaping operations.

1. void SortBubble::sort2(int arr[], const int nSize)
2. {
3.     ALog::print(_T("# Bubble Sort: /n#"));
4.     ALog::print(arr, nSize) << LINE_SPLIT;
6.     int top = 0;
7.     bool bNoSort = false;
9.     while( !bNoSort && top < nSize-1 )
10.     {       
11.         bNoSort = true;
12.         ALog::print(_T("# ")) << top << std::endl;
13.         for(int cur=nSize-1; cur>top; --cur)
14.         {
15.             if( arr[cur] < arr[cur-1] )
16.             {
17.                 std::swap(arr[cur], arr[cur-1]);
18.                 bNoSort = false;
19.             }
20.             ALog::print(arr, nSize);
21.         }
23.         ++top;
24.     }
26.     ALog::print(LINE_SPLIT);
27. }