【算法基础】冒泡排序算法

【算法基础】冒泡排序算法 - JAVA

一、算法基础

1.1 什么是冒泡排序

冒泡排序是一种简单直观的比较排序算法。它重复地走访待排序的数列，依次比较相邻两个元素，如果顺序错误就交换它们，直到没有元素需要交换为止。

1.2 基本思想

比较相邻元素：从头开始，两两比较相邻元素
交换位置：如果前一个元素大于后一个元素，则交换位置
重复操作：每完成一次迭代，最大的元素会"冒泡"到数组末尾
多次迭代：重复以上步骤，每次排除已排好序的末尾元素

1.3 时间复杂度

最好情况：O(n)，当数组已经排好序
最坏情况：O(n²)，当数组逆序排列
平均情况：O(n²)

二、冒泡排序的分类

2.1 标准冒泡排序

标准版本每次将最大元素冒泡到末尾：

外层循环：控制排序轮数，最多n-1轮
内层循环：控制每轮比较次数，逐渐减少
无优化：即使数组已排序仍会执行全部循环

2.2 优化冒泡排序

通过标记变量检测一轮比较中是否有交换发生：

设置标记：初始假设本轮无交换
发生交换：更新标记变量
提前终止：若一轮比较无交换发生，则排序完成

三、冒泡排序实现

3.1 标准实现

public class BubbleSort {/*** 标准冒泡排序算法* @param arr 待排序数组*/public static void bubbleSort(int[] arr) {int n = arr.length;// 外层循环控制排序轮数for (int i = 0; i < n - 1; i++) {// 内层循环进行相邻元素比较和交换// 每轮结束后，最大的i+1个元素已经排好序for (int j = 0; j < n - i - 1; j++) {// 如果当前元素大于下一个元素，交换它们if (arr[j] > arr[j + 1]) {int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}}
}

3.2 优化实现

public class OptimizedBubbleSort {/*** 优化版冒泡排序算法* @param arr 待排序数组*/public static void bubbleSort(int[] arr) {int n = arr.length;boolean swapped;// 外层循环控制排序轮数for (int i = 0; i < n - 1; i++) {swapped = false;// 内层循环进行相邻元素比较和交换for (int j = 0; j < n - i - 1; j++) {if (arr[j] > arr[j + 1]) {// 交换元素int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;// 标记发生了交换swapped = true;}}// 如果没有发生交换，说明数组已经有序，提前结束if (!swapped) {break;}}}
}

3.3 双向冒泡排序（鸡尾酒排序）

public class CocktailSort {/*** 双向冒泡排序（鸡尾酒排序）算法* @param arr 待排序数组*/public static void cocktailSort(int[] arr) {int left = 0;int right = arr.length - 1;boolean swapped;while (left < right) {swapped = false;// 从左向右，将最大元素冒泡到右侧for (int i = left; i < right; i++) {if (arr[i] > arr[i + 1]) {int temp = arr[i];arr[i] = arr[i + 1];arr[i + 1] = temp;swapped = true;}}// 如果没有交换，数组已经有序if (!swapped) {break;}right--; // 最大元素已经到位，缩小右边界swapped = false;// 从右向左，将最小元素冒泡到左侧for (int i = right; i > left; i--) {if (arr[i] < arr[i - 1]) {int temp = arr[i];arr[i] = arr[i - 1];arr[i - 1] = temp;swapped = true;}}// 如果没有交换，数组已经有序if (!swapped) {break;}left++; // 最小元素已经到位，缩小左边界}}
}

四、算法分析与优化

4.1 理论推导

冒泡排序的工作原理可以用以下数学表达式描述：

比较次数：(n-1) + (n-2) + ... + 1 = n(n-1)/2
最大交换次数：同上 n(n-1)/2
元素移动次数：最多3×n(n-1)/2（每次交换需要3次移动）

4.2 优化策略

提前终止优化：如前述，检测是否有交换发生
记录最后交换位置：每轮记录最后一次交换的位置，下一轮只需扫描到该位置即可
奇偶交替扫描：类似鸡尾酒排序，减少"乌龟"（小元素靠后）的情况

public class EnhancedBubbleSort {/*** 记录最后交换位置的优化冒泡排序* @param arr 待排序数组*/public static void bubbleSort(int[] arr) {int n = arr.length;int lastSwappedIndex = n - 1;int newLastSwappedIndex;while (lastSwappedIndex > 0) {newLastSwappedIndex = 0;for (int i = 0; i < lastSwappedIndex; i++) {if (arr[i] > arr[i + 1]) {// 交换元素int temp = arr[i];arr[i] = arr[i + 1];arr[i + 1] = temp;// 记录最后交换的位置newLastSwappedIndex = i;}}// 更新下一轮排序的终止位置lastSwappedIndex = newLastSwappedIndex;}}
}

五、完整示例程序

public class BubbleSortDemo {public static void main(String[] args) {// 测试数据int[] arr = {64, 34, 25, 12, 22, 11, 90};System.out.println("原始数组: ");printArray(arr);// 执行优化版冒泡排序optimizedBubbleSort(arr);System.out.println("\n排序后数组: ");printArray(arr);}/*** 优化的冒泡排序实现*/public static void optimizedBubbleSort(int[] arr) {int n = arr.length;boolean swapped;for (int i = 0; i < n - 1; i++) {swapped = false;for (int j = 0; j < n - i - 1; j++) {// 如果当前元素大于下一个元素，交换它们if (arr[j] > arr[j + 1]) {swap(arr, j, j + 1);swapped = true;}}// 如果没有发生交换，数组已经有序if (!swapped) {System.out.println("提前结束于第 " + (i + 1) + " 轮");break;}}}/*** 交换数组中两个元素*/private static void swap(int[] arr, int i, int j) {int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}/*** 打印数组*/private static void printArray(int[] arr) {for (int num : arr) {System.out.print(num + " ");}System.out.println();}
}