LeetCode刷题笔记：Java实现冒泡排序

1. 冒泡排序定义

多次进行遍历，在每次遍历中，比较连续相邻的元素。如果相邻两个元素中的前一个元素大于后一个元素，则将它们互换位置；否则保持不变。整个排序过程中，较小的值像“气泡”一样逐渐浮向顶部，而较大的值沉向底部。
第一次遍历后，数组的最后位置上存放的是整个数组中最大的元素；
第二次遍历后，数组的倒数第二个位置上存放的是整个数组中第二大的元素。

2. 实例分析

     数组：2 9 5 4 8 1
-----------------------
第一次遍历：2 9 5 4 8 1
 		  2 5 9 4 8 1
          2 5 4 9 8 1
          2 5 4 8 9 1
          2 5 4 8 1 9
第二次遍历：2 5 4 8 1 9
          2 4 5 8 1 9
          2 4 5 8 1 9
          2 4 5 1 8 9
          2 4 5 1 8 9
第三次遍历：2 4 5 1 8 9
          2 4 5 1 8 9
          2 4 1 5 8 9
          2 4 1 5 8 9
          2 4 1 5 8 9
第四次遍历：2 4 1 5 8 9
          2 1 4 5 8 9
          2 1 4 5 8 9
          2 1 4 5 8 9
          2 1 4 5 8 9
第五次遍历：1 2 4 5 8 9
           1 2 4 5 8 9
           1 2 4 5 8 9
           1 2 4 5 8 9
           1 2 4 5 8 9  

3. 代码实现

在第 k 次遍历时，不需要考虑最后 k - 1个元素，因为它们已经排序好了。
所以内循环里的条件为 j < nums.length - k

public void BubbleSort(int nums[]) {
	int len = nums.length;
	// 第 k 次遍历，遍历次数为 数组元素-1，即 len - 1
	for (int k = 1; k < len; k++) {
		// 每次遍历都从第一个元素开始两两相邻比较
		for (int i = 0; i < len - k; i++) {
			if (nums[i] > nums[i + 1]) {
				int temp = nums[i];
				nums[i] = nums[i + 1];
				nums[i + 1] = temp;
			}
		}
	}
}

⭐改进：如果在某次遍历中没有发生交换，则不必进行下一次循环。

public void BubbleSort(int[] nums) {
	int len = nums.length;
	boolean needNextPass = true;
	// 第 k 次遍历，遍历次数为 数组元素-1，即 len - 1
	for (int k = 1; k < len && needNextPass; k++) {
		needNextPass = false;
		// 每次遍历都从第一个元素开始两两相邻比较
		for (int i = 0; i < len - k; i++) {
			if (nums[i] > nums[i + 1]) {
				int temp = nums[i];
				nums[i] = nums[i + 1];
				nums[i + 1] = temp;
				needNextPass = true;
			}
		}
	}
}

4. 时间复杂度

① 最佳情况：1 次遍历
最佳情况下 1 次遍历即可，需要比较 n - 1次，时间复杂度为 O(n) = n
② 最差情况：n - 1 次遍历
最差情况下需要 n - 1次遍历，第一次遍历需要比较 n - 1 次，第二次遍历需要比较 n - 2 次，…，最后一次遍历需要比较 1 次。
所以比较总次数：n(n - 1) / 2 即 时间复杂度为 O(n) = n²
因此，冒泡排序的时间复杂度为 O(n) = n²