AI之DeepSeek帮我写C语言冒泡排序算法

概要

冒泡排序（Bubble Sort）： 是一种非常简单的排序算法，原理基于比较相邻元素并交换它们，直到整个数组有序。它的名字来源于“冒泡”的概念，即较大的元素逐步“冒泡”到数组的末尾。

推荐一个在线生成gif动图的网站：Visualgo

代码

#include <stdio.h>

// 冒泡排序函数
void bubbleSort(int arr[], int n) {
    int i, j;
    for (i = 0; i < n-1; i++) {
        // 标志位，用于检测是否发生了交换
        int swapped = 0;
        
        // 内层循环，每次将最大的元素“冒泡”到数组末尾
        for (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;
                
                // 设置标志位为1，表示发生了交换
                swapped = 1;
            }
        }
        
        // 如果没有发生交换，说明数组已经有序，提前退出
        if (swapped == 0) {
            break;
        }
    }
}

// 打印数组的函数
void printArray(int arr[], int size) {
    int i;
    for (i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main() {
    int arr[] = {40, 34, 25, 12, 22, 11, 50};
    int n = sizeof(arr) / sizeof(arr[0]);
    
    printf("排序前的数组: \n");
    printArray(arr, n);
    
    bubbleSort(arr, n);
    
    printf("排序后的数组: \n");
    printArray(arr, n);
    
    return 0;
}

输出

排序前的数组: 
40 34 25 12 22 11 50 
排序后的数组: 
11 12 22 25 34 40 50 

分析

针对数组【40,34,25,12,22,11,50】做冒泡排序解析，解析如下：

1、第一轮：

• 比较 40 和 34，因为 40 > 34，所以交换它们。数组变成 [34, 40, 25, 12, 22, 11, 50]
• 比较 40 和 25，交换它们，数组变成 [34, 25, 40, 12, 22, 11, 50]
• 比较 40 和 12，交换它们，数组变成 [34, 25, 12, 40, 22, 11, 50]
• 比较 40 和 22，交换它们，数组变成 [34, 25, 12, 22, 40, 11, 50]
• 比较 40 和 11，交换它们，数组变成 [34, 25, 12, 22, 11, 40, 50]
• 比较 40 和 50，不交换。数组变成 [34, 25, 12, 22, 11, 40, 50]。
• 经过第一轮，50 是最大的元素，它已经排到了末尾。

2、第二轮：

• 比较 34 和 25，交换，数组变成 [25, 34, 12, 22, 11, 40, 50]
• 比较 34 和 12，交换，数组变成 [25, 12, 34, 22, 11, 40, 50]
• 比较 34 和 22，交换，数组变成 [25, 12, 22, 34, 11, 40, 50]
• 比较 34 和 11，交换，数组变成 [25, 12, 22, 11, 34, 40, 50]
• 比较 34 和 40，不交换。数组变成 [25, 12, 22, 11, 34, 40, 50]。
• 经过第二轮，40 已经排到倒数第二个位置。

3、继续排序，直到全部元素排好序。

优缺点

优点：

• 简单易懂，代码实现也很简单。
• 是稳定排序（相等元素的相对顺序不会改变）。

缺点：

• 时间复杂度较高，尤其在数据量大的时候效率较低，不适合处理大量数据。
• 即使数组已经部分排序，仍然需要进行多轮比较和交换，性能不够高效。

平均时间复杂度为O(n²)，最好的情况下是O(n)，稳定排序。

平均时间复杂度	最好情况	最坏情况	空间复杂度
O(n²)	O(n)	O(n²)	O(1)