5类内部排序----交换排序之冒泡排序



交换排序是通过两两比较带待排序记录的关键值，交换不能满足顺序的那些偶对，直到全部满足为止。冒泡排序是一种稳定的排序。

冒泡排序（Bubble Sort），是一种计算机领域的较简单的交换排序算法。

冒泡排序的基本思路：先将第一个记录的关键字和第二个记录的关键字比较，若为逆序则交换，然后比较第二个和三个记录的关键字，若为逆序，又继续交换两个记录；如此下去直到n-1和n,这样就完成第一趟排序，而且序列中的最大值放在最后。然后进行第二趟，第三趟直到第n-1趟

算法思路;

(1)第一重循环进行n-1趟排序，k=0;

(2)第二重循环是在进行第i趟排序时候进行的n-i次两两比较，若逆序，交换并使k值增加；找出该趟的最大值放在n-i+1位置上；继续下一次直到结束所有的排序结束。

初始状态：60    71    49    11    82   49   3    66

第一趟   ：60     49    11    71    49   3    66   82

第二趟   ：49     11     60    49    3    66  71   82

第三趟   ：11     49     49    3     60   66  71   82

第四趟   ：11     49     3      49   60   66  71   82

第五趟   ：11      3     49     49   60   66  71   82

第六趟   ：3       11    49     49   60   66  71   82

第七趟   ：3       11    49     49   60   66  71   82

public class BubbleSort {
	public static void bubble(int n[]){

		for(int i=1;i<n.length;i++){               //第一重循环控制执行n-1趟排序
			int max=n[0];						   //每次从0开始进行比较
			for(int j=1;j<n.length-i+1;j++){       //第二重进行每一趟里面的逆序排序
				if(max>n[j]){
					n[j-1]=n[j];				   //交换
					n[j]=max;
				}else{
					max=n[j];
				}
			}
		}
	}
	public static void main(String[] args) {
		int n[]={3,2,5,12,53,32,56,100};
		bubble(n);
		for(int i=0;i<n.length;i++){
			System.out.print(n[i]+" ");
		}
	}
}

改进过后的代码：

//冒泡排序  
void BubbleSort2(int a[], int n)  
{  
       int j, k;  
       bool flag;  
  
       k = n;  
       flag = true;  
       while (flag)  
       {  
              flag = false;  
              for (j = 1; j < k; j++)  
                     if (a[j - 1] > a[j])  
                     {  
                           Swap(a[j - 1], a[j]);  
                            flag = true;  
                     }  
              k--;  
      }  
}  

很明显通过判断是否有序列交换而停止这样不用排到最后一趟

时间复杂度：O(n²)