java算法之冒泡排序

1.算法思路

冒泡排序是最基础的排序，其思想是依次比较数组中相邻的两个元素，如果前面的数比后面的数大，就交换位置。这样，第一趟排序完成后，最大的那个数一定会被交换到数组的最后去，重复此过程，直到完成整个排序。

2.算法分析

时间复杂度：算法由2重循环来实现，在时间上依赖输入数据的规模，因此时间复杂度为O（n^2）

空间复杂度：由于不依赖额外的内存，只需要特定的临时变量来储存数据，所以空间复杂度为O（1）

3.代码实现

	/**
	 * 最基本的冒泡排序
	 */
	public static void bubbleSort(int[] array) {
		if(array == null) {//数组为空直接结束
			return;
		}
		int len = array.length;
		if(len <= 1) {//数组长度为0或者1，表示不需要排序
			return;
		}
		for (int i = 0; i < len; i++) {//外循环，表示第几次排序
			for (int j = 1; j < len; j++) {//内循环，表示当前的位置
				if(array[j] < array[j - 1]) {//如果前面的数比后面的数大，就交换位置
					int temp = array[j];
					array[j] = array[j - 1];
					array[j - 1] = temp;
				}
			}
		}
	}

4.算法优化

细心的同学会发现，其实该算法并不需要每次都比较每一个元素，当每一趟排序完成后，数组最后面的数据已经处于正确的位置，所以不需要再对这些数据进行比较了。

	/**
	 * 通过减少比较次数来优化算法
	 */
	public static void bubbleSort(int[] array) {
		if(array == null) {
			return;
		}
		int len = array.length;
		if(len <= 1) {
			return;
		}
		for (int i = 0; i < len; i++) {
			for (int j = 1; j < len - i; j++) {//减少判断的次数
				if(array[j] < array[j - 1]) {
					int temp = array[j];
					array[j] = array[j - 1];
					array[j - 1] = temp;
				}
			}
		}
	}

在经过思考我们会发现，如果数组是乱序的，那么每趟排序我们都会交换数组中的元素，但是如果数组已经有序的情况下，我们就不会有交换。也就是说，如果没有交换，就可以说明数组已经有序了。

	/**
	 * 通过判断是否有数据交换来提前结束
	 */
	public static void bubbleSort(int[] array) {
		if(array == null) {
			return;
		}
		int len = array.length;
		if(len <= 1) {
			return;
		}
		boolean flag;
		for (int i = 0; i < len; i++) {
			flag = false;//每次开始都重置
			for (int j = 1; j < len - i; j++) {
				if(array[j] < array[j - 1]) {
					int temp = array[j];
					array[j] = array[j - 1];
					array[j - 1] = temp;
					flag = true;//标志为有交换
				}
			}
			if(flag == false) {//如果没有交换，就结束
				return;
			}
		}
	}

下面有这样一种情况，如下图，即数组中其实只有前几个元素需要交换，但是我们每次还是去比较了整个数组，即后面的比较其实是多余的，因为后面已经是有序的了，永远不需要再进行交换。

依照这个思路，如果数组后面的数据已经有序了，且不会再发生交换，那我们就可以不需要再比较后面的数据了，从而省略了很多不必要的比较。因为在数组中，当前正在进行交换的元素一定会比前面的所有元素都大（因为每次比较都会把比较大的元素移到后面，在用这个比较大的元素去比较），所以如果这一趟排序中，最后有数据交换的那个位置的后面的所有元素都比这个元素大，而且是有序的（因为这后面没有进行交换了），所以我们只需要记录这个最后交换的位置，下一次我们就不需要再比较后面的元素了。这样即可以通过局部冒泡排序的方式来优化。

	/**
	 * 通过局部冒泡排序来优化
	 */
	public static void bubbleSort(int[] array) {
		if(array == null) {
			return;
		}
		int end, last, len;
		end = last = len = array.length;
		if(len <= 1) {
			return;
		}
		while(end > 0) {
			for (int j = 1; j < end; j++) {
				if(array[j] < array[j - 1]) {
					int temp = array[j];
					array[j] = array[j - 1];
					array[j - 1] = temp;
					last = j;//当前交换的位置
				}
			}
			end = last;//最后一次交换的位置
			last = 0;
		}
	}

上面的我们只考虑到数组最后面的元素有序的情况，同样的，如果数组前面的部分元素也是有序的呢，按照同样的思路，我们再记录第一次进行交换的位置，就可以进一步减少比较。

	public static void bubbleSort(int[] array) {
		if(array == null) {
			return;
		}
		/*first：第一次交换的位置，last：最后一次交换的位置
		 *start：下一次开始的位置，end：下一次结束的位置
		 */
		int first, last, start, end, len;
		last = end = len = array.length;
		first = start = 1;
		if(len <= 1) {
			return;
		}
		while(start != end) {
			for (int j = start; j < end; j++) {
				if(array[j] < array[j - 1]) {
					int temp = array[j];
					array[j] = array[j - 1];
					array[j - 1] = temp;
					last = j;
					if(start == first && j > 1) {//找到第一次交换的位置
						first = j - 1;
					}
				}
			}
			start = first;
			end = last;
		}
	}

注意：上面所有的算法都不是哪个一定比哪个好，而是要具体情况具体分析，毕竟冒泡排序要依赖具体输入数据的规模和数据本身的排序情况