排序算法（二）：冒泡排序

        冒泡排序（Bubble Sort）是一种简单的排序算法，它通过不断交换相邻的元素，将最大的元素逐步“浮”到数组的末尾。

冒泡排序的步骤如下：

1. 从左到右遍历数组，比较相邻的元素，如果左边元素大于右边元素，则交换它们的位置。
2. 重复步骤 1，直到整个数组都被遍历完毕。
3. 如果整个步骤2中没有数字被交换，则数组已排序好，结束排序，否则再次从左到右遍历数组，重复步骤 1 和 2，直到整个数组都被排序。

动画演示

下面为各编程语言实现冒泡排序的方法

C语言

#include <stdio.h>

/* 冒泡排序函数 */
void BubbleSort(int arr[], int n) {
    int i, swapped;

	// 如果在内部循环中没有交换，则数组已排序好，结束排序
    while (swapped){
        swapped = 0;

		// 遍历数组
        for (i = 0; i < n - 1; i++) {

			// 如果左边元素 > 右边元素，交换两个元素的值
            if (arr[i] > arr[i + 1]) {
                int temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
                swapped = 1;
            }
        }
    }
}

int main() {
    int arr[] = {8, 45, 0, 30, 49, 16, 20, 20};
    int n = sizeof(arr) / sizeof(arr[0]); // 求数组长度
	
    printf("排序前的数组：");
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);
	putchar(10);

    BubbleSort(arr, n);

    printf("排序后的数组：");
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);

    return 0;
}

C++

#include <iostream>
using namespace std;

/* 冒泡排序函数 */
void BubbleSort(int arr[], int n) {
    int swapped;

	// 如果在内部循环中没有交换，则数组已排序好，结束排序
    while (swapped) {
        swapped = 0;

		// 遍历数组
        for (int i = 0; i < n - 1; i++) {
            if (arr[i] > arr[i + 1]) {

				// 如果左边元素 > 右边元素，交换两个元素的值
                int temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
                swapped = 1;
            }
        }
    }
}

int main() {
    int arr[] = {8, 45, 0, 30, 49, 16, 20, 20};
    int n = sizeof(arr) / sizeof(arr[0]); // 求数组长度
	
	cout << "排序前的数组：";
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";

    BubbleSort(arr, n);

    cout << endl << "排序后的数组：";
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";

    return 0;
}

Python

''' 冒泡排序函数 '''
def BubbleSort(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]
                swapped = True

        # 如果在内部循环中没有交换，则数组已排序好，结束排序
        if not swapped:
            break

arr = [8,45,0,30,49,16,20,20]
print("排序前的数组：", ' '.join(map(str, arr)))
BubbleSort(arr)
print("排序后的数组：", ' '.join(map(str, arr)))

Java

import java.util.Arrays;

/* 冒泡排序函数 */
public class Bubble_Sort {
	public static void BubbleSort(int[] arr) {
		
		// 如果在内部循环中没有交换，则数组已排序好，结束排序
        boolean swapped = true;
        while (swapped) {
            swapped = false;

			// 遍历数组
            for (int i = 0; i < arr.length - 1; i++) {

                // 如果左边元素 > 右边元素，交换两个元素的值
                if (arr[i] > arr[i + 1]) {
                    int temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                    swapped = true;
                }
            }
        }
    }
	
    public static void main(String[] args) {
        int[] arr = {8, 45, 0, 30, 49, 16, 20, 20};

        System.out.print("排序前的数组：");
        for (int num : arr)
            System.out.print(num + " ");
		System.out.println();

        BubbleSort(arr);

        System.out.print("排序后的数组：");
        for (int num : arr)
            System.out.print(num + " ");
    }
}