冒泡排序：简单而优雅的排序算法-CSDN博客

本文链接：https://blog.csdn.net/qq_73662931/article/details/135851364

引言：

冒泡排序（Bubble Sort）是一种简单直观的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。冒泡排序的名字来源于较小的元素会经由交换慢慢“浮”到数列的顶端，就像水中的气泡最终会上浮到水面一样。尽管它在效率上不是最优的，但由于其实现简单，经常被用来作为教学示例或者在小型数据集上使用。

算法原理：

冒泡排序的基本思想是通过对待排序序列从前向后（从下标较小的元素开始），依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就像水底下的气泡一样逐渐向上冒。

具体步骤如下：

比较相邻的元素。如果第一个比第二个大（小），就交换它们两个。
对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

算法实现：

c++

#include<iostream>
using namespace std;

void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                swap(arr[j], arr[j + 1]);
            }
        }
    }
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int n = sizeof(arr) / sizeof(arr[0]);
    bubbleSort(arr, n);
    cout << "排序后的数组： 
";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
    return 0;
}

java

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};
    System.out.println("原始数组：");
    for (int num : arr) {
        System.out.print(num + " ");
    }
    System.out.println();
    bubbleSort(arr);
    System.out.println("排序后的数组：");
    for (int num : arr) {
        System.out.print(num + " ");
    }
}

Python

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]
                # 如果发生交换，标记为True
                swapped = True
        # 如果在这次遍历中没有发生交换，说明数组已经有序，可以提前结束
        if not swapped:
            break
    return arr

# 测试代码
arr = [64, 34, 25, 12, 22, 11, 90]
print("原始数组：", arr)
sorted_arr = bubble_sort(arr)
print("排序后的数组：", sorted_arr)