冒泡排序可视化

控制面板

数组大小: 20

排序速度: 100ms

排序状态

当前步骤

初始化

排序进度

0%

当前状态

准备就绪

排序过程可视化

未排序

比较中

交换中

已排序

比较次数

0

交换次数

0

数组大小

20

冒泡排序代码实现

void bubbleSort(int arr[], int n) {
    int i, j;
    for (i = 0; i < n-1; i++) {
        // 最后i个元素已经就位
        for (j = 0; j < n-i-1; j++) {
            // 从0到n-i-1遍历
            if (arr[j] > arr[j+1]) {
                // 交换元素
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}
                    

def bubble_sort(arr):
    n = len(arr)
    # 遍历所有数组元素
    for i in range(n):
        # 最后i个元素已经就位
        for j in range(0, n-i-1):
            # 从0到n-i-1遍历
            if arr[j] > arr[j+1]:
                # 交换元素
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr
                    

func bubbleSort(arr []int) {
    n := len(arr)
    for i := 0; i < n-1; i++ {
        // 最后i个元素已经就位
        for j := 0; j < n-i-1; j++ {
            // 从0到n-i-1遍历
            if arr[j] > arr[j+1] {
                // 交换元素
                arr[j], arr[j+1] = arr[j+1], arr[j]
            }
        }
    }
}
                    

public class BubbleSort {
    void bubbleSort(int arr[]) {
        int n = arr.length;
        for (int i = 0; i < n-1; i++) {
            // 最后i个元素已经就位
            for (int j = 0; j < n-i-1; j++) {
                // 从0到n-i-1遍历
                if (arr[j] > arr[j+1]) {
                    // 交换元素
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }
}
                    

冒泡排序算法说明

算法原理

冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个相邻的元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端，就如同水中的气泡一样向上冒，因此得名冒泡排序。

复杂度分析

时间复杂度

最佳情况：O(n)（当数组已经排序时，使用优化版本）
平均情况：O(n²)
最坏情况：O(n²)

空间复杂度

额外空间：O(1)
原地排序算法，不需要额外的存储空间

与其他排序算法的对比

排序算法	最佳时间复杂度	平均时间复杂度	最坏时间复杂度	空间复杂度	稳定性
冒泡排序	O(n)	O(n²)	O(n²)	O(1)	稳定
选择排序	O(n²)	O(n²)	O(n²)	O(1)	不稳定
插入排序	O(n)	O(n²)	O(n²)	O(1)	稳定
快速排序	O(n log n)	O(n log n)	O(n²)	O(log n)	不稳定
归并排序	O(n log n)	O(n log n)	O(n log n)	O(n)	稳定
堆排序	O(n log n)	O(n log n)	O(n log n)	O(1)	不稳定

适用场景

冒泡排序由于其简单性和稳定性，在某些特定场景下仍然有用：

对于几乎已经排序的数据，优化版的冒泡排序性能良好
数据量很小的情况，简单性比效率更重要时
教学场景，用于解释排序算法的基本原理
需要稳定排序且实现简单的场景

然而，对于大规模数据集，冒泡排序通常不是一个好的选择，因为其时间复杂度为O(n²)，效率较低。在这种情况下，应该选择快速排序、归并排序等更高效的算法。