算法中的冒泡排序

冒泡排序（Bubble Sort）简介

冒泡排序是一种简单的排序算法，它通过重复地遍历待排序的列表，依次比较相邻的两个元素，如果它们的顺序错误就交换它们的位置。遍历列表的过程会重复进行，直到没有需要交换的元素，这时列表就已经排序完成。

冒泡排序的名字来源于较小的元素会像 "气泡" 一样逐渐 "浮" 到列表的顶端。

冒泡排序的步骤

从列表的第一个元素开始，比较相邻的两个元素。
如果前一个元素大于后一个元素，交换它们的位置。
继续遍历列表，重复上述步骤，直到列表末尾。
重复以上过程，直到没有需要交换的元素。

冒泡排序的时间复杂度

最好情况：当列表已经有序时，时间复杂度为 O(n)。
最坏情况：当列表完全逆序时，时间复杂度为 O(n^2)。
平均情况：时间复杂度为 O(n^2)。

JavaScript 实现

javascript 复制代码

function bubbleSort(arr) {
  let n = arr.length;
  let swapped; // 用于标记是否发生了交换

  do {
    swapped = false; // 每次遍历前重置标记
    for (let i = 0; i < n - 1; i++) {
      // 比较相邻元素
      if (arr[i] > arr[i + 1]) {
        // 交换元素
        [arr[i], arr[i + 1]] = [arr[i + 1], arr[i]];
        swapped = true; // 标记发生了交换
      }
    }
    n--; // 每次遍历后，最大的元素已经"浮"到末尾，减少遍历范围
  } while (swapped); // 如果没有发生交换，说明列表已经有序

  return arr;
}

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

代码解析

swapped 标记：用于检测在一次遍历中是否发生了交换。如果没有发生交换，说明列表已经有序，可以提前结束排序。
n--：每次遍历后，最大的元素已经 "浮" 到列表末尾，因此可以减少下一次遍历的范围。
交换元素 ：使用 ES6 的解构赋值语法 [arr[i], arr[i + 1]] = [arr[i + 1], arr[i]] 来交换相邻元素。

示例运行

输入：

javascript 复制代码

const array = [64, 34, 25, 12, 22, 11, 90];

输出：

javascript 复制代码

排序前: [64, 34, 25, 12, 22, 11, 90]
排序后: [11, 12, 22, 25, 34, 64, 90]

优化版本

如果列表在某一轮遍历中已经有序，可以提前结束排序，避免不必要的遍历。

javascript 复制代码

function bubbleSortOptimized(arr) {
  let n = arr.length;
  let swapped;

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

  return arr;
}

// 示例用法
const array = [64, 34, 25, 12, 22, 11, 90];
console.log("优化排序后:", bubbleSortOptimized(array));

总结

冒泡排序是一种简单但效率较低的排序算法，适合小规模数据。
通过优化（如提前结束排序），可以减少不必要的遍历。
在实际开发中，对于大规模数据，建议使用更高效的排序算法（如快速排序、归并排序）。