冒泡排序各层循环的含义

 

1.1第一层循环

 

 通常为

for (int i=0;i

或

For(int i=1;i

 

当然，如果你喜欢，你甚至可以定义i初始值为3、为4、为100等。不过我相信，没人会那么无聊的。

 

不过这却揭示了第一层循环与i的初始值无关，而只与循环了多少次有关。

 

因此，冒泡排序第一层循环的含义为：需要遍历多次数组，才能将这个数组排好序。

 

 

那到底需要遍历多少次数组，才能排好序呢？

 

第一次遍历，确定一个最值。

第二次遍历，确定第二个最值。

。。。

第num-1次遍历，确定第num-1最值。  Num-1个最值都确定了，自然整个数组也就排好序了。  

 

因此，第一层循环含义为：需要遍历num-1次数组，才能将数组排好序。

 

1.2第二层循环

通常定义为int j;  j是一个与i相关的变量，第2层循环需要用到第一层的i的值。

 

那第二层循环要解决的问题是什么？

 

不好想的话，我们反过来想，在第二层循环时，我们还要对已经排好序的位置进行遍历吗？

当然不需要作此无用功，在第二层遍历中，我们只需对未排好序的那些待排位置进行遍历即可，而首先，我们必须知道，哪些元素是已经拍过序的，哪些元素是待排序的。

 

所以，我们第二层循环要解决的问题便是：待排序区域的起始和结尾位置。

 

而要解决这个问题，

首先，第一个要解决的便是：在进行这个循环时，数组已经排好了几个值。

 

其次，第二个要解决的便是：在数组中，待排序区域的其实和末尾位置分别是什么。

 

第一个要解决的问题与第一层循环已经进行了多少次有关。

第二个要解决的问题则与排序时遍历的方向有关。

 

 

 

2 冒泡排序算法

2.1  i=0

 

[cpp] view plaincopy

1. void BubbleSortBtoS(int A[],int num)  // 从数组末尾向数组开始遍历  
2. {  
3.   
4.     int temp=0;  
5.     for (int i=0;i
6.     {  
7.   
8.         for (int j=num-1;j>i;j--)    //  待排的数据为i,i+1,...num-1    此处判断条件为j>i  
9.         {  
10.             if (A[j]
11.             {  
12.                 temp=A[j];  
13.                 A[j]=A[j-1];  
14.                 A[j-1]=temp;  
15.             }  
16.         }  
17.     }  
18.   
19. }  

 

[cpp] view plaincopy

1. void BubbleSortStoB(int A[],int num)  // 从数组开始向数组末尾遍历  
2. {  
3.   
4.     int temp=0;  
5.     for (int i=0;i
6.     {  
7.   
8.         for (int j=0;j// 待排的数据为0,1,2,...,n-i-1      此处判断条件为j  
9.         {  
10.             if (A[j]>A[j+1])  
11.             {  
12.                 temp=A[j];  
13.                 A[j]=A[j+1];  
14.                 A[j+1]=temp;  
15.             }  
16.         }  
17.     }  
18.   
19. }  

 

2.2  i=1

好吧，总有人喜欢从i=1开始作为第一层循环的起始值，这是习惯问题，因此我们也分析下从1开始时的程序。

 

[cpp] view plaincopy

1. void BubbleSortBtoS1(int A[],int num)  // 从数组末尾向数组开始遍历  
2. {  
3.   
4.     int temp=0;  
5.     for (int i=1;i
6.     {  
7.   
8.         for (int j=num-1;j>=i;j--)    //  待排的数据为i-1,i,i+1,...num-1   此处为j>=i  
9.         {  
10.             if (A[j]
11.             {  
12.                 temp=A[j];  
13.                 A[j]=A[j-1];  
14.                 A[j-1]=temp;  
15.             }  
16.         }  
17.     }  
18.   
19. }  

 

 

[cpp] view plaincopy

1. void BubbleSortStoB1(int A[],int num)  // 从数组开始向数组末尾遍历  
2. {  
3.   
4.     int temp=0;  
5.     for (int i=1;i
6.     {  
7.   
8.         for (int j=0;j<=num-i-1;j++)     // 待排的数据为0,1,2,...,n-i-1,n-i    此处为j<=num-i-1  
9.         {  
10.             if (A[j]>A[j+1])  
11.             {  
12.                 temp=A[j];  
13.                 A[j]=A[j+1];  
14.                 A[j+1]=temp;  
15.             }  
16.         }  
17.     }  
18.   
19. }  

 

3 冒泡算法的小改进

3.1  简化从前往后遍历

 

[cpp] view plaincopy

1. void BubbleSortStoB_Tail(int A[],int num)  // tail参数记录末尾位置  
2. {  
3.   
4.     int temp=0;  
5.     int tail=num-1;  
6.     for (int i=0;i
7.     {  
8.   
9.         for (int j=0;j// 待排的数据为0,1,2,...,tail      实则tail==num-i-1  
10.         {  
11.             if (A[j]>A[j+1])  
12.             {  
13.                 temp=A[j];  
14.                 A[j]=A[j+1];  
15.                 A[j+1]=temp;  
16.             }  
17.         }  
18.   
19.         tail--;  
20.     }  
21.   
22. }  

 

3.2 增设是否有序标志

[cpp] view plaincopy

1. void BubbleSortBtoS_Modify(int A[],int num)  // 从数组末尾向数组开始遍历  
2. {  
3.   
4.     bool bSwap=false;  
5.     int temp=0;  
6.     for (int i=0;i
7.     {  
8.   
9.         for (int j=num-1;j>i;j--)    //  待排的数据为i,i+1,...num-1    此处判断条件为j>i  
10.         {  
11.             if (A[j]
12.             {  
13.                 bSwap=true;  
14.                 temp=A[j];  
15.                 A[j]=A[j-1];  
16.                 A[j-1]=temp;  
17.             }  
18.         }  
19.   
20.         if (!bSwap)               //   设置是否交换标志以提前退出  
21.         {  
22.             break;  
23.         }  
24.     }  
25.   
26. }  

 

4  鸡尾酒算法

 

 

 

 

[cpp] view plaincopy

1. void CockTail(int A[],int num)  
2. {  
3.   
4.     int tail=num-1;  
5.   
6.     int temp=0;  
7.   
8.     for (int i=0;i
9.     {  
10.   
11.         for (int j=tail;j>i;j--)  
12.         {  
13.             if (A[j]
14.             {  
15.                 temp=A[j];  
16.                 A[j]=A[j-1];  
17.                 A[j-1]=temp;  
18.   
19.             }  
20.         }  
21.   
22.         i++;  
23.   
24.   
25.         for (int j=i;j
26.         {  
27.             if (A[j]>A[j+1])  
28.             {  
29.                 temp=A[j];  
30.                 A[j]=A[j+1];  
31.                 A[j+1]=temp;  
32.             }  
33.         }  
34.         tail--;  
35.     }  
36.   
37. }