冒泡排序：最直观的排序方法-CSDN博客

本文链接：https://blog.csdn.net/qq_39032307/article/details/149632310

冒泡排序：最直观的排序方法

想象一下你在整理一叠扑克牌，每次比较相邻的两张牌，如果顺序不对就交换它们的位置。就这样一遍遍地重复这个过程，直到所有的牌都按顺序排列好。这种简单直观的排序方式，就是计算机科学中的冒泡排序算法。

冒泡排序就像水中的气泡一样，较轻的元素会逐渐"浮"到数组的顶端，而较重的元素则会"沉"到底部。虽然它不是最高效的排序算法，但它的简单性和直观性使其成为学习算法和排序概念的绝佳起点。

一、冒泡排序的基本流程

理解了冒泡排序的基本概念后，我们来看看它的具体执行流程。冒泡排序的核心思想是通过多次遍历数组，每次比较相邻的两个元素，如果它们的顺序不对就交换它们。

以上流程图展示了冒泡排序的基本执行流程。外层循环控制遍历的轮数，内层循环负责每轮中的相邻元素比较和交换。

1.1 冒泡排序的实现代码

下面是一个标准的冒泡排序实现代码，我们用JavaScript来演示：

function bubbleSort(arr) {
    let n = arr.length;
    for (let i = 0; i < n - 1; i++) {
        // 每次遍历后，最大的元素会"冒泡"到最后
        for (let j = 0; j < n - 1 - i; j++) {
            // 比较相邻元素
            if (arr[j] > arr[j + 1]) {
                // 交换元素
                [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
            }
        }
    }
    return arr;
}

// 测试示例
const unsortedArray = [64, 34, 25, 12, 22, 11, 90];
console.log("排序前:", unsortedArray);
console.log("排序后:", bubbleSort(unsortedArray));

上述代码展示了冒泡排序的基本实现。外层循环控制排序的轮数，内层循环负责每轮中的相邻元素比较和交换。每次外层循环结束后，当前最大的元素会被移动到正确的位置。

二、冒泡排序的工作原理

现在我们已经看到了冒泡排序的实现代码，让我们更深入地理解它的工作原理。冒泡排序之所以被称为"冒泡"，是因为较大的元素会像气泡一样逐渐"浮"到数组的顶部（末尾）。

这个序列图展示了冒泡排序中各个组件之间的交互过程。外层循环控制整体轮数，内层循环负责具体的比较和交换操作。

2.1 冒泡排序的逐步解析

让我们通过一个具体的例子来逐步解析冒泡排序的工作过程。假设我们有一个数组：[5, 3, 8, 6, 2]。

第一轮遍历：

比较5和3 → 交换 → [3, 5, 8, 6, 2]
比较5和8 → 不交换
比较8和6 → 交换 → [3, 5, 6, 8, 2]
比较8和2 → 交换 → [3, 5, 6, 2, 8]

第一轮结束后，最大的数字8已经"冒泡"到了正确的位置。

第二轮遍历：

比较3和5 → 不交换
比较5和6 → 不交换
比较6和2 → 交换 → [3, 5, 2, 6, 8]

第二轮结束后，第二大的数字6到达了正确位置。

第三轮遍历：

比较3和5 → 不交换
比较5和2 → 交换 → [3, 2, 5, 6, 8]

第三轮结束后，数字5到达正确位置。

第四轮遍历：

比较3和2 → 交换 → [2, 3, 5, 6, 8]

第四轮结束后，数组已经完全排序。

这个甘特图展示了冒泡排序在不同轮次中的时间分布。可以看到，随着排序的进行，每轮需要处理的元素数量在减少。

三、冒泡排序的优化

虽然冒泡排序的基本实现很简单，但它有一些可以优化的地方。在实际应用中，我们通常会采用一些优化策略来提高冒泡排序的效率。

3.1 提前终止的冒泡排序

基本的冒泡排序即使在数组已经有序的情况下也会继续执行所有轮次的遍历。我们可以通过添加一个标志位来检测某一轮是否发生了交换，如果没有交换发生，说明数组已经有序，可以提前终止排序。

function optimizedBubbleSort(arr) {
    let n = arr.length;
    let swapped;
    for (let i = 0; i < n - 1; i++) {
        swapped = false;
        for (let j = 0; j < n - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
                swapped = true;
            }
        }
        // 如果没有发生交换，提前终止
        if (!swapped) break;
    }
    return arr;
}

这个优化版本在最好的情况下（数组已经有序）时间复杂度可以从O(n²)降到O(n)，这是一个显著的改进。

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

另一种常见的优化是鸡尾酒排序，也称为双向冒泡排序。它通过在每轮中交替方向进行冒泡，可以更快地将元素移动到正确的位置。

function cocktailSort(arr) {
    let left = 0;
    let right = arr.length - 1;
    let swapped;
    
    while (left < right) {
        swapped = false;
        
        // 从左到右的冒泡
        for (let i = left; i < right; i++) {
            if (arr[i] > arr[i + 1]) {
                [arr[i], arr[i + 1]] = [arr[i + 1], arr[i]];
                swapped = true;
            }
        }
        right--;
        
        // 从右到左的冒泡
        for (let i = right; i > left; i--) {
            if (arr[i] < arr[i - 1]) {
                [arr[i], arr[i - 1]] = [arr[i - 1], arr[i]];
                swapped = true;
            }
        }
        left++;
        
        if (!swapped) break;
    }
    
    return arr;
}

鸡尾酒排序在某些情况下比传统冒泡排序效率更高，特别是当数组中存在大量已经有序的子序列时。