算法——浅谈冒泡排序

冒泡排序(BubbleSort)

冒泡排序是最简单不过的了，记得在大学的时候最初学的就是冒泡排序，今天总结一下这个是程序员就会写的冒泡排序：

冒泡冒泡，想象一下冒泡，比如说我们从小到大排序，肯定最大的往上冒，所以说我们通过for循环第一趟排序，那么最右侧一定是一个最大的，那么第一趟比较完成后，第二趟排序最后一个数就不参与啦。

直接来吧，这里重点要注意的就是第二个for循环 j < arr.length - i - 1的含义：

• - 1原因是冒泡排序只需循环到最后一位的前一位，因为排序是两位两位的判断的，判断完前一位还用判断后一位吗
• - i原因是冒泡排序循环几趟， 就能确定最后几位已经是最大的数了，后面的就不需要参与排序了

/**
	 * 最基本的冒泡
	 * @param arr
	 */
	public static void bubbleSort(int[] arr) {
		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = 0; j < arr.length - i - 1; j++) {
				if (arr[j] > arr[j + 1]) {
					int temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}
			}
		}
	}

优化一、添加标志位

如果说比如{9,1,2,3,4,5}，经过一次排序之后就变成了{1,2,3,4,5,9}，那么后面很多的就是多余的

/**
	 * 加标志位的冒泡
	 * @param arr
	 */
	public static void bubbleSort2(int[] arr) {
		boolean isSortChange;
		for (int i = 0; i < arr.length - 1; i++) {
			isSortChange = false;
			for (int j = 0; j < arr.length - 1 - i; j++) {
				if (arr[j] > arr[j + 1]) {
					int temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
					isSortChange = true;
				}
			}
			
			if (!isSortChange) {
				return;
			}
		}
	}

优化二、记录最后一次无变化的位置

有部分情况，排序了一次或几次之后，后半部分都已经有序啦，那么能记录下来这个位置，然后下一趟排序的时候排到这个位置之前就可以

/**
	 * 记录位置的冒泡
	 * @param arr
	 */
	public static void bubbleSort3(int[] arr) {
		boolean isSortChange;
		int k = arr.length - 1;
		int lastNoChangePosition = 0;
		for (int i = 0; i < arr.length - 1; i++) {
			isSortChange = false;
			for (int j = 0; j < k; j++) {
				if (arr[j] > arr[j + 1]) {
					int temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
					isSortChange = true;
					lastNoChangePosition = j;
				}
			}
			
			if (!isSortChange) {
				return;
			}
			k = lastNoChangePosition;
		}
	}

优化三、双向冒泡

在外层的for循环的时候，不光从左往右排，也从右往左排，并且也都添加标志位，去记录上次无变化的位置

/**
	 * 双向冒泡
	 * @param arr
	 */
	public static void bubbleSort4(int[] arr) {
		boolean isSortChange;
		int k = arr.length - 1;
		int m = 0;
		int lastNoChangePosition = 0;

		for (int i = 0; i < arr.length - 1; i++) {

			isSortChange = false;

			for (int j = m; j < k; j++) {
				if (arr[j] > arr[j + 1]) {
					int temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
					isSortChange = true;
					lastNoChangePosition = j;
				}
			}
			
			if (!isSortChange) {
				return;
			}
			
			k  = lastNoChangePosition;
            
            isSortChange = false;
			
			for (int j = k; j > m;  j--) {
				if (arr[j] < arr[j - 1]) {
					int temp = arr[j];
					arr[j] = arr[j - 1];
					arr[j - 1] = temp;
					isSortChange = true;
				}
			}

			if (!isSortChange) {
				return;
			}

			m++;
			
		}
	}

总结

以上就是冒泡排序的一些总结和优化，虽然很多人说冒泡排序还有什么优化的意义，但是明白其中的道理我们会从中学到很多很多，有一些的细节要注意，为什么- 1，为什么- i，为什么放标志位，为什么记录未变化的位置，为什么要双向排序，明白了这些，就理解的差不多了。