冒泡排序和优化

冒泡排序：

如 9，8，7，6，5，4，3

现要递增排序，冒泡排序的思想是比较相邻元素的大小，将大的放在后面。经过一系列比较后，最大的元素被放在最后。

 第一轮：

9，8，7，6，5，4，3

9和8进行比较，8<9 交换位置得到 

 8，9，7，6，5，4，3

9和7进行比较，7<9交换位置得到

8，7，9，6，5，4，3

9和6进行比较，6<9交换位置得到

8，7，6，9，5，4，3

9和5进行比较，5<9交换位置得到

8，7，6，5，9，4，3

9和4进行比较，4<9交换位置得到

8，7，6，5，4，9，3

9和3进行比较，3<9交换位置得到

8，7，6，5，4，3，9

此时最大数9被冒到最后

第二轮：

8，7，6，5，4，3，9

8和7进行比较，7<8 交换位置得到 

7，8，6，5，4，3，9

8和6进行比较，6<8交换位置得到

7，6，8，5，4，3，9

8和5进行比较，5<8交换位置得到

7，6，5，8，4，3，9

8和4进行比较，4<8交换位置得到

7，6，5，4，8，3，9

8和3进行比较，3<8交换位置得到

7，6，5，4，3，8，9

此时第二轮中的最大数8被冒到最后

第三轮的结果为：

6，5，4，3，7，8，9   第三轮的最大数7被冒到最后

第四轮的结果为：

5，4，3，6，7，8，9   第四轮的最大数6被冒到最后

第五轮的结果为：

4，3，5，6，7，8，9   第五轮的最大数5被冒到最后

第六轮的结果为：

3，4，5，6，7，8，9  第六轮的最大数4被冒到最后

总结：

（1）n个元素进行比较，最多进行n-1趟比较；

（2）第i趟比较，要进行n-i次比较

（3）冒泡排序是稳定的

（4）时间复杂度O（n2）

void sort(int a[] , int n){
	for(int i = 1 ; i <n ; i++){  //共进行n-1趟排序
		for(int j = 0 ; j < n - i ; j++){  //每一趟排序进行n-i次比较
			if(a[j] > a[j+1]){
				int temp;
				temp = a[j];
				a[j]=a[j+1];
				a[j+1] =temp;
			}
		}
	}
}

冒泡排序的优化：

当某一趟排序没有元素交换时，排序即可结束

void sort(int a[] , int n){
	for(int i = 1 ; i <n ; i++){  //共进行n-1趟排序
		bool flag = false;  //通过标志flag来标识每趟元素是否有交换
		for(int j = 0 ; j < n - i ; j++){  //每一趟排序进行n-i次比较
			if(a[j] > a[j+1]){
				int temp;
				temp = a[j];
				a[j]=a[j+1];
				a[j+1] =temp;
				flag = true;
			}
		}

		if(!flag){ //若没有交换则跳出循环
			break;
		}
	}
}