冒泡排序

基本介绍

冒泡排序的基本思想是：通过对待排序的序列从前向后，依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前向后移动，就像水底的气泡一样逐渐向上冒。
冒泡排序会经过多轮循环排序，每轮排序相邻的元素进行比较，最终就会找出这轮数值当中最大的数值，并且排到最后。因为最后的数值已经确定是最大的数值，所以就没有必要在下一轮排序中比较大小，所以第二轮排序就不会在把最后的数值进行排序，在第二轮排序完成之后就会确定第二大的数值，排在由第一轮确定的最大值的前面，然后第三轮。。。。依次类推。

冒泡排序排序过程

原始数组：3，9，-1，20，10

第一轮排序：

1. 3，9，-1，20，10   比较 3，9 因为 3<9 所以位置不交换
2. 3，-1，9，20，10   比较 9，-1 因为 9>-1 所以位置交换
3. 3，-1，9，20，10   比较 9，20 因为 9<20 所以位置不交换
4. 3，-1，9，10，20   比较 20，10 因为 20>10 所以位置交换

第一轮相邻的元素两两比较完成，选出第一轮的最大数值20。

第二轮排序：

第二轮排序 20 不参与排序 因为它是已经确定最大的值，所以不需要参与第二轮排序。

1. -1，3，9，10，20    比较 3，-1 因为 3>-1 所以位置交换
2. -1，3，9，10，20    比较 3，9 因为 3<9 所以位置不交换
3. -1，3，9，10，20    比较 9，10 因为 9<10 所以位置不交换

第二轮相邻的元素两两比较完成，选出第二轮的最大数值10。

第三轮排序：

第三轮排序 20，10 不参与排序

1. -1，3，9，10，20    比较 -1，3 因为 -1<3 所以位置不交换
2. -1，3，9，10，20    比较 3，9 因为 3<9 所以位置不交换

第三轮相邻的元素两两比较完成，选出第三轮的最大数值9。

第四轮排序：

第四轮排序 20，10，9不参与排序

1. -1，3，9，10，20    比较 -1，3 因为 -1<3 所以位置不交换

第四轮相邻的元素两两比较完成，选出第四轮的最大数值3。

排序完成！！！

小结：

1. 一共进行了数组长度减1轮的循环
2. 每一轮排序比较的次数逐渐减少1次

代码

public static void sort(int arr[]) {
	for (int i = 0; i < arr.length - 1; i++) {
		for (int j = 0; j < arr.length - i - 1; j++) {
			int temp;
			if (arr[j] > arr[j + 1]) {
				temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}				 
                  System.out.println(Arrays.toString(arr));
		}
	}
}

优化

冒泡排序由一个最大的问题就是不管原数组是不是已经有序还是没序，它总是要循环排序。例如我们上面的排序过程中的 第三轮和第四轮 就没有必要排序，我们可以提前结束。我们发现如果在每一轮排序中没有发生交换，那么我们就可以结束掉这个排序。

public static void sortOptimization(int arr[]) {
	for (int i = 0; i < arr.length - 1; i++) {
		boolean isExchange = false;
		for (int j = 0; j < arr.length - i - 1; j++) {
			int temp;
			if (arr[j] > arr[j + 1]) {
				temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
				isExchange = true;
			}
			System.out.println(Arrays.toString(arr));
		}
		if(!isExchange) {
			break;
		}
	}
}