冒泡排序可视化 - 算法动画演示

冒泡排序（Bubble Sort）是一种简单直观的排序算法。它重复地遍历待排序的数列，一次比较两个相邻元素，如果顺序错误就把它们交换过来。每一轮遍历后，最大的元素会"浮"到数组末尾，就像水中的气泡上浮一样。

算法步骤

从数组的第一个元素开始，比较相邻的两个元素
如果前一个元素比后一个元素大，则交换它们的位置
对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对
完成一轮后，最大的元素会排到最后
重复以上步骤，每次比较范围减少一个（已排好的元素不再参与）
当没有任何交换发生时，排序完成

时间与空间复杂度

情况	时间复杂度	说明
最好情况	O(n)	数组已经有序，只需一次遍历
平均情况	O(n²)	需要多次遍历和交换
最坏情况	O(n²)	数组完全逆序
空间复杂度	O(1)	只需常数级额外空间（原地排序）

冒泡排序是稳定排序，相等元素的相对顺序不会改变。

适用场景

教学演示：作为最简单的排序算法之一，非常适合算法入门学习
小规模数据：当数据量很小时（n < 50），简单实现的优势明显
几乎有序的数组：如果数组大部分已经有序，冒泡排序效率较高
需要稳定性：当需要保持相等元素的原始顺序时

算法教学小数据集稳定排序需求

代码实现

def bubble_sort(arr):
    """冒泡排序算法"""
    n = len(arr)
    
    for i in range(n):
        swapped = False
        
        # 每轮将最大元素"冒泡"到末尾
        for j in range(0, n - i - 1):
            if arr[j] > arr[j + 1]:
                # 交换相邻元素
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
                swapped = True
        
        # 如果没有交换发生，数组已有序
        if not swapped:
            break
    
    return arr


# 使用示例
arr = [64, 34, 25, 12, 22, 11, 90]
print(bubble_sort(arr))
# 输出: [11, 12, 22, 25, 34, 64, 90]

public class BubbleSort {
    
    /**
     * 冒泡排序算法
     * @param arr 待排序数组
     */
    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        
        for (int i = 0; i < n - 1; i++) {
            boolean 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;
            }
        }
    }
    
    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
        // 输出: [11, 12, 22, 25, 34, 64, 90]
    }
}