冒泡排序——Java、C++、Python 中的算法示例代码

原文： https://www.freecodecamp.org/news/bubble-sort-algorithm-in-java-cpp-python-with-example-code/

冒泡排序是一种排序算法，你可以用它来将一组值按升序排列。如果你愿意，你也可以实现冒泡排序，以降序排序。

一个现实世界中的冒泡排序算法的例子是你手机上的联系人列表是如何按字母顺序排序的，或者根据文件的添加时间对你手机上的文件进行排序。

在这篇文章中，我将用我准备的一些信息图表解释所有你需要知道的冒泡排序算法知识。然后，我将向你展示 Python、Java 和 C++ 中的冒泡排序算法的示例代码。

冒泡排序算法如何运行

为了实现冒泡排序算法，开发人员通常会写一个函数，然后在一个循环中写一个循环——内循环和外循环。当我向你展示 Python、C++ 和 Java 中的代码时，你会看到它的实际效果。

假设我们想对一系列数字 5、3、4、1 和 2 进行排序，使它们按升序排列......

排序开始的第一次迭代是比较前两个值。如果第一个值大于第二个值，算法就把第一个值推到第二个值的索引上。

排序的第一次迭代

第 1 步：在 5、3、4、1 和 2 的情况下，5 大于 3。所以 5 占用了 3 的位置，数字变成了 3、5、4、1 和 2。

第 2 步：算法现在有 3、5、4、1 和 2 需要比较，这一次，它比较了下两个值，即 5 和 4。5 比 4 大，所以 5 占用了 4 的索引，现在的值是 3、4、5、1 和 2。

第 3 步：算法现在有 3、4、5、1 和 2 需要比较。它比较下两个值，即 5 和 1。5 比 1大，所以 5 占用了 1 的索引，数字变成 3、4、1、5 和 2。

第 4 步：该算法现在有 3、4、1、5 和 2 需要比较。它比较下两个值，即 5 和 2。5 比 2 大，所以 5 占用了 2 的索引，数字变成 3、4、1、2 和 5。

这就是第一次迭代。现在数字从最初的 5、3、4、1 和 2 被排列成 3、4、1、2 和 5。正如你可能意识到的，如果数字按升序排列，5 应该是最后一个数字。这意味着第一次迭代真的完成了。

第二次迭代的排序和其余部分

该算法以 3、4、1、2、5 的最后结果开始第二次迭代。这一次，3 比 4 小，所以没有发生交换。这意味着这些数字将保持不变。

算法继续比较 4 和 1。4 比 1 大，所以 4 被换成 1，数字变成 3、1、4、2 和 5。

该算法现在开始比较 4 和 2。4 比 2 大，所以 4 被换成了 2，数字变成了 3、1、2、4 和 5。

4 现在在正确的位置，所以 4 和 5 之间没有发生互换，因为 4 比 5 小。

就这样，算法继续比较数字，直到它们按照 1、2、3、4、5 的升序排列。

冒泡排序算法的 Python 代码示例

下面是一个代码例子，展示了 Python 中冒泡排序算法的实现：

def bubble_sort(arr):
    arr_len = len(arr)
    for i in range(arr_len-1):
        flag = 0
        for j in range(0, arr_len-i-1):
            if arr[j] > arr[j+1]:
                arr[j+1], arr[j] = arr[j], arr[j+1]
                flag = 1
                if flag == 0:
                    break
    return arr

arr = [5, 3, 4, 1, 2]
print("List sorted with bubble sort in ascending order: ", bubble_sort(arr))

# 输出：用冒泡排序法对列表进行升序排序：[1, 2, 3, 4, 5]

要使排序以降序出现，只需将大于符号（>）替换为小于（<）。

def bubble_sort(arr):
    arr_len = len(arr)
    for i in range(arr_len-1):
        flag = 0
        for j in range(0, arr_len-i-1):
            if arr[j] < arr[j+1]:
                arr[j+1], arr[j] = arr[j], arr[j+1]
                flag = 1
                if flag == 0:
                    break
    return arr

arr = [5, 3, 4, 1, 2]
print("List sorted with bubble sort in descending order: ", bubble_sort(arr))

# 输出：用冒泡排序法对列表进行升序排序：[5, 4, 3, 2, 1]

在以下代码中，我在其中添加了注释，以便你可以知道发生了什么：

# 定义一个函数来创建排序，并传入一个数组作为参数
def bubble_sort(arr):
    # 获取数组的长度
    arr_len = len(arr)
    # 遍历数组中的元素，包括最后一个元素 - 外循环
    for i in range(arr_len-1):
        # 声明一个标志变量来检查是否发生了交换 - 用于优化
        flag = 0
        # 创建一个循环，比较数组中的每个元素，直到最后一个。
        for j in range(0, arr_len-i-1):
            # 比较两个相邻的元素，并按升序排序
            if arr[j] > arr[j+1]:
                # 如果元素的顺序不对，就交换它们
                arr[j+1], arr[j] = arr[j], arr[j+1]
                flag = 1
                # 在 0 处跳出循环
                if flag == 0:
                    break
    # 返回值必须在外循环块中
    return arr

arr = [5, 3, 4, 1, 2]
print("List sorted with bubble sort in ascending order: ", bubble_sort(arr))

# 输出：用冒泡排序法对列表进行升序排序：[1, 2, 3, 4, 5]

冒泡排序算法的 Java 代码示例

要在 Java 中实现冒泡排序算法，你必须比在 Python 中写更多的代码。

这就是为什么我添加了注释，让你在执行的过程中了解这些步骤：

import java.util.Arrays;

class Main {
  static void bubbleSort(int array[]) {
    int size = array.length;
    // 遍历数组中的每个元素以读取它们
    for (int i = 0; i < size - 1; i++)
      // 用一个循环比较数组的元素
      for (int j = 0; j < size - i - 1; j++)
        // 比较数组中的两个相邻元素
        if (array[j] > array[j + 1]) {
          // 如果元素不在正确的位置，就交换它们
          int temp = array[j];
          array[j] = array[j + 1];
          array[j + 1] = temp;
        }
  }

  public static void main(String args[]) {
    int[] data = { 5, 3, 4, 1, 2 };
    // 用 class 名调用方法
    Main.bubbleSort(data);
    
    System.out.println("Array sorted with bubble sort: ");
    System.out.println(Arrays.toString(data));
  }
}

// 输出：用冒泡排序法对数组进行排序： [1, 2, 3, 4, 5]

冒泡排序算法 C++ 代码实例

就像我对 Java 代码所做的那样，我也为 C++ 中的冒泡排序算法的实现添加了注释，因为它比 Python 和 Java 的算法更加冗长：

#include <iostream>

using namespace std;

// 创建一个函数来执行冒泡排序
void bubble_sort(int array[], int size) {
  // 遍历数组中的每个元素以读取它们 - 外循环
  for (int step = 0; step < (size-1); ++step) {
    // 检查是否发生互换
    int swapped = 0;
    // 遍历数组中的每个元素以比较它们 - 外循环
    for (int i = 0; i < (size-step-1); ++i) {
     // 比较两个相邻的元素，并按升序排序
      if (array[i] > array[i + 1]) {

        // 如果元素的顺序不对，就交换它们
        int temp = array[i];
        array[i] = array[i + 1];
        array[i + 1] = temp;
        
        swapped = 1;
      }
    }

    // 如果不再有交换发生，则跳出循环
    if (swapped == 0)
      break;
  }
}

// 打印一个数组
void printArray(int array[], int size) {
  for (int i = 0; i < size; ++i) {
    cout << "  " << array[i];
  }
  cout << "\n";
}

int main() {
  int data[] = {5, 3, 4, 1, 2};
  // find the length of the array
  int size = sizeof(data) / sizeof(data[0]);

  // 调用函数
  bubble_sort(data, size);
  
  cout << "Array sorted with bubble sort: \n";
  printArray(data, size);
}

// 输出：用冒泡排序法对数组进行排序：1  2  3  4  5

最后的思考

我不会说冒泡排序算法的实现是简单或困难的。对于一个有经验的程序员来说，这并不难，但初学者一开始可能会被吓到。

然而，要真正理解该算法的原理，你需要知道：

你需要写一个函数将数据[或数组]传入
你需要写一个外循环来访问这些元素
你需要写一个内循环来比较这些元素
你需要调用该函数并传入数据（数组）

我希望这篇文章能帮助你理解冒泡排序算法以及如何实现它。

谢谢你阅读本文。

目录