冒泡排序算法教程

算法原理

冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

算法步骤：

比较相邻的两个元素，如果第一个比第二个大，就交换它们两个
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对
在这一点，最大的元素会"冒泡"到数组的末尾
针对所有的元素重复以上的步骤，除了最后一个
重复步骤1~4，直到排序完成

可视化演示

速度: 5

0

比较次数

0

交换次数

0

遍历轮数

0ms

执行时间

代码实现

JavaScript 实现：

function bubbleSort(arr) {
    let n = arr.length;
    let comparisons = 0;
    let swaps = 0;
    
    // 外层循环控制遍历轮数
    for (let i = 0; i < n - 1; i++) {
        let swapped = false;
        
        // 内层循环进行相邻元素比较
        for (let j = 0; j < n - i - 1; j++) {
            comparisons++;
            
            // 如果前一个元素大于后一个元素，则交换
            if (arr[j] > arr[j + 1]) {
                // 交换元素
                [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
                swapped = true;
                swaps++;
            }
        }
        
        // 如果这一轮没有发生交换，说明数组已经有序
        if (!swapped) break;
    }
    
    return { arr, comparisons, swaps };
}

Python 实现：

def bubble_sort(arr):
    n = len(arr)
    comparisons = 0
    swaps = 0
    
    # 外层循环控制遍历轮数
    for i in range(n - 1):
        swapped = False
        
        # 内层循环进行相邻元素比较
        for j in range(n - i - 1):
            comparisons += 1
            
            # 如果前一个元素大于后一个元素，则交换
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
                swapped = True
                swaps += 1
        
        # 如果这一轮没有发生交换，说明数组已经有序
        if not swapped:
            break
    
    return arr, comparisons, swaps

算法复杂度分析

复杂度类型	最好情况	平均情况	最坏情况
时间复杂度	O(n)	O(n²)	O(n²)
空间复杂度	O(1)

复杂度说明：

最好情况 O(n)：当数组已经有序时，只需要一轮遍历即可确定数组已排序
平均情况 O(n²)：需要进行约 n²/2 次比较和交换
最坏情况 O(n²)：当数组完全逆序时，需要进行 n(n-1)/2 次比较和交换
空间复杂度 O(1)：只需要常数级别的额外空间，是原地排序算法

冒泡排序算法教程

算法原理

算法步骤：

可视化演示

代码实现

JavaScript 实现：

Python 实现：

算法复杂度分析

复杂度说明：

算法特点

优点

缺点