冒泡排序法

性质：1、稳定交换

          2、最坏情况下：移动：3n（n-1)/2 次 ;

                                   比较：n(n-1)/2  次 ;

          3、时分复杂度分析：时间复杂度 O（n^2）;

                                          空间复杂度O(1 );

                                    

思想：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

void swap(int a[], int n){            //一个有n个元素的数据排序
    for(int i =0 ; i< n-1; ++i) {         // n个数组元素需要循环比较n-1次
        for(int j = i+1; j <n; j++) {    // 每一次排序都比上次循环排序少一次
            if(a[j] > a[j+1])   //升序排序
            {  
                int tmp = a[j] ; a[j] = a[j+1] ;  a[j+1] = tmp;  
            }  
        }  
    }  
}  

改进：当循环一次冒泡所有位置均不发生改变时即此序列已完成排序即可退出循环。

void swap (int a[],int n){
    int i,j;
 int temp;
 bool exchange;
 for(i=;i<n-1;i++){
  exchange=false;
  for(j=n-1;j>i;j--){
   if(a[j]<a[j-]){
    temp=a[j];
    a[j]=a[j-1];
    a[j-1]=temp;
    exchange=true; 
   }
   if(exchange==false)   //当不发生交换位置时则意味着该数组排序已完成，直接退出；
   return;
  }
 }
}

改进：在每趟排序中进行正向和反向两遍冒泡的方法一次可以得到两个最终值(最大者和最小者) ,从而使排序趟数几乎减少了一半。

void Bubble_2 ( int r[], int n){  
    int low = 0;   
    int high= n -1; //设置变量的初始值  
    int temp,j;  
    while (low < high) {  
        for (j= low; j< high; ++j) //正向冒泡,找到最大者  
            if (r[j]> r[j+1]) {  
                temp = r[j]; r[j]=r[j+1];r[j+1]=tmp;  
            }   
        --high;               //修改high值, 前移一位 for ( j=high; j>low; --j) //反向冒泡,找到最小者  

    if (r[j]<r[j-1]) {  
       temp = r[j]; r[j]=r[j-1];r[j-1]=temp;  
            }  
        ++low;                  //修改low值,后移一位  
    }   
}