冒泡排序（Bubble Sort）

冒泡排序是一种简单的比较类排序算法，通过重复交换相邻元素，将较大的元素逐步“冒泡”到序列末尾。

算法核心思想是多次遍历数组，每次比较相邻元素并交换，直到序列有序。

📌 算法原理解释

• 对数组进行多轮遍历；
• 每轮将相邻元素两两比较，如果前者大于后者则交换；
• 每轮遍历后，最大的元素移动到当前未排序序列末尾；
• 重复直到所有元素排序完成。

冒泡排序的时间复杂度最坏和平均均为 O(n²)，但当数据近乎有序时，最好情况下可达 O(n)。

💻 多语言代码实现

javascript

// JavaScript 冒泡排序
function bubbleSort(arr) {
  const n = arr.length;
  for (let i = 0; i < n - 1; i++) {
    let 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;
}

python

# Python 冒泡排序
def bubble_sort(arr):
    n = len(arr)
    for i in range(n - 1):
        swapped = False
        for j in range(n - 1 - i):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
                swapped = True
        if not swapped:
            break
    return arr

cpp

// C++ 冒泡排序
#include <vector>
using namespace std;

void bubbleSort(vector<int>& arr) {
    int n = arr.size();
    bool swapped;
    for (int i = 0; i < n - 1; i++) {
        swapped = false;
        for (int j = 0; j < n - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                swap(arr[j], arr[j + 1]);
                swapped = true;
            }
        }
        if (!swapped) break;
    }
}

java

// Java 冒泡排序
public class BubbleSort {
    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 - 1 - i; 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;
        }
    }
}

php

<?php
// PHP 冒泡排序
function bubbleSort(array &$arr): array {
    $n = count($arr);
    for ($i = 0; $i < $n - 1; $i++) {
        $swapped = false;
        for ($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;
}
?>

go

// Go 冒泡排序
package main

func bubbleSort(arr []int) []int {
    n := len(arr)
    for i := 0; i < n-1; i++ {
        swapped := false
        for 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)
空间复杂度	O(1)（原地排序）
稳定性	✅ 稳定
是否原地排序	✅ 是

📌 提示：冒泡排序适合教学、少量数据排序，实际大规模数据推荐更高效算法。