菜鸡的冒泡排序

冒泡排序的2种实现方法

最近复习冒泡排序（bubble_sort）时，感觉直接拍的话太死板，而且当数组元素过多时比较浪费时间，于是就上网搜索了下，然后发现了其他的1种方法
1.首先是最开始学习的冒泡排序的算法
这种方法就是进行循环遍历数组，相邻的两个之间进行比较，符合条件交换位置，就不在进行过多的解释了。
（标准）冒泡排序中有两层for循环
外层for循环正好进行N次迭代，但内部循环越来越少。
1.i=0，进行（N-1）次迭代
2.i=1 ，进行（N-2）次迭代
3.i=2，进行（N-3）次迭代。
…
n.i=n-1，进行0次迭代
因此，总迭代次数=（N-1）+（N-2）+…+1+0=N（N-1）/2
总时间=o（N^2）

#include <iostream>                             
using namespace std;                            
//冒泡排序                                      
void bubble_sort(int a[],int lenth)             
{                                               
 int i,j;                                   /
 int temp = 0;                              /
 for(i = 0; i < lenth - 1; i++){             
  for(j = 0; j < lenth - 1 - i; j++){     
   if(a[j] > a[j + 1]){                
    temp = a[j];                    
    a[j] = a[j + 1];                
    a[j + 1] = temp;                
   }          
  }                                       
 }                                           
 for(i = 0; i < 10; i++){                    
  if(i % 5 == 0 && i != 0){               
   cout << endl;                       
  }                                       
  cout << a[i] << " ";                    
 }                                           
}             
 int main()                                 
{                                          
 int a[10] = {1,5,7,98,65,3,4,59,41,45};
 bubble_sort1(a,10);                    
 return 0;                              
}                                                           

2.鸡尾酒排序（cocktail_sort）也是一种变相的冒泡排序
*就是用2分法的思想，将数组分成两部分排序。即排序从前往后排序的同时，从后往前排
你每趟循环走完后，就将最大（较大，非第一次时）的数放到最后面，最小（较小）的放到最前面，并且 left+1，right-1 这样在第二次遍历的时候便不再扫描已经排好的数，这样就减少了排序次数，。
*

void cocktail_sort(int a[], int lenth)      
{                                           
 int i,left = 0,right = lenth - 1;       
 int temp = 0;                           
 while(left < right){                    
  for(i = left; i < right; i++){      
   if(a[i] > a[i + 1]){            
    temp = a[i];                
    a[i] = a[i + 1];            
    a[i + 1] = temp;            
   }                               
  }                                   
  right--;                            
  for(i = right; i > left; i--){      
   if(a[i - 1] > a[i]){            
    temp = a[i];                
    a[i] = a[i - 1];            
    a[i - 1] = temp;            
   }                               
  }                                   
  left++;                             
 }                                       
 for(i = 0; i < 10; i++){                
  if(i % 5 == 0 && i != 0){           
   cout << endl;                   
  }                                   
  cout << a[i] << " ";                
 }                                       
}                                           

鸡尾酒排序最糟或是平均所花费的次数都是O(n²)，但如果序列在一开始已经大部分排序过的话，会接近O(n)。如果想详细了解鸡尾酒排序算法。请点击下面的链接

https://baike.baidu.com/item/鸡尾酒排序