排序算法 - 冒泡排序及终极优化

参考大神的文章,写的很详细：
https://www.cnblogs.com/onepixel/p/7674659.html
https://blog.csdn.net/wubingju93123/article/details/81215984

原理分析

首先放一张网上找的动图。

过程分析：
假设一个数组 arr[] ，长度length
第一轮：
从0开始，依次比较相邻的两个元素,0与1比，1与2比，2与3比 … … ，如果满足条件，则将两个位置的元素互换,一直比到 最后一位。此时，最后一位元素一定是最大或最小的。
第二轮：
从0开始，依次比较相邻的两个元素,0与1比，1与2比，2与3比 … … ，如果满足条件，则将两个位置的元素互换,一直比到倒数第二位。此时，最后两位元素的顺序已经是排好的。
第三轮：
从0开始，依次比较相邻的两个元素,0与1比，1与2比，2与3比 … … ，如果满足条件，则将两个位置的元素互换,一直比到倒数第三位。此时，最后三位元素的顺序已经是排好的。
第N轮：
从0开始，依次比较相邻的两个元素,0与1比，1与2比，2与3比 … … ，如果满足条件，则将两个位置的元素互换,一直比到倒数第N位。此时，最后N位元素的顺序已经是排好的。
第 arr.length-1 轮：
0与1比 ，如果满足条件，则将两个位置的元素互换。到此为止，数组的所有元素都排好序了。

从以上分析，可以得出冒泡排序的基础代码：

基础版

int temp  = 0;
// 从小到大排序
// 循环 arr.length-1 次
for(int i = 0;i<arr.length-1;i++){
	//  一直比到 倒数 arr.length-1-i为
	for(int j = 0; j<arr.length-1-i;j++){
		if(arr[j] > arr[j+1]){
			temp = arr[j];
			arr[j] = arr[j+1];
			arr[j+1] = temp;
		}
	}		
}

假设有数组： 3 2 1 8 5 6
按照上面的分析，需要循环4轮

第一轮：2 1 3 5 6 8
第二轮：1 2 3 5 6 8
第三轮：1 2 3 5 6 8
第四轮：1 2 3 5 6 8
第五轮：1 2 3 5 6 8

可以看到: 在第二轮完成后，数组其实已经是有序的了。也就是说，后续的循环都是多余的。针对这种情况，可以怎样做优化呢？

分析：
从第二轮之后，元素的位置已经是有序的，后续每一轮也都不再有元素的变动。优化点可以从这里找出。

优化原理：
在每一轮执行完成后，判断在这一轮的过程中，是否出现元素的变动，如果没有出现元素的变动，说明已经每一个位置的元素都已经是有序的，那么就不再进行后续的循环。

进阶版（对于外层循环次数优化）

int temp = 0;
for(int i = 0;i<arr.length-1;i++){
	// 在每一轮开始时候，先初始化，默认为true
	boolean isSorted = true;
	for(int j = 0; j<arr.length-1-i;j++){
		if(arr[j] > arr[j+1]){
			temp = arr[j];
			arr[j] = arr[j+1];
			arr[j+1] = temp;
			// 当元素位置变动后，设置该轮存在元素的变动。
			isSorted = false;
		}
	}
	// 内层循环完成后，判断该轮有没有元素的变动。
	// 如果没有，说明已经排好序，直接跳出循环。
	if(isSorted) {
		break;
	}	
}

按照上面的优化，数组： 3 2 1 8 5 6 只需要循环3轮

第一轮：2 1 3 5 6 8
第二轮：1 2 3 5 6 8
第三轮：1 2 3 5 6 8（该轮完成后，判断没有元素变动，跳出循环）

继续分析：
第一轮完成后，数组的最后4位，3 5 6 8 已经是排好序的，为什么每次还都要遍历比较到最后一位？能不能做优化?
优化原理：
在每一轮执行完成后，判断在这一轮的过程中，元素变动的最后一位索引是多少，下次循环则只遍历到这个位置为止。

终极版（对于内层遍历元素位置优化）

int temp = 0;
//记录最后一次交换的位置
int lastExchangeIndex = 0;
//无序数列的边界，每次比较只需要比到这里为止
int sortBorder = array.length - 1;
for(int i = 0;i < arr.length-1;i++){
	boolean isSorted = true;
	for(int j = 0; j < sortBorder;j++){
		if(arr[j] > arr[j+1]){
			temp = arr[j];
			arr[j] = arr[j+1];
			arr[j+1] = temp;
			isSorted = false;
			//把无序数列的边界更新为最后一次交换元素的位置
            lastExchangeIndex = j;
		}
	}
	sortBorder = lastExchangeIndex;
	if(isSorted) {
		break;
	}	
}

经过再次优化：

数组： 3 2 1 8 5 6 只需要循环3轮

第一轮 比较到 最后一位
第二轮 比较到 最后一位
第三轮 比较到 第二位