冒泡排序算法——C/C++

冒泡排序

1. 算法思想

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

2. 排序步骤

2.1 默认认为原数据为无序的。
2.2 从第二个数据开始排序，进行数据比较，如果array[i]>array[i+1]，就进行交换。
2.3 把这一轮比较结果，最小的置换到最前面（或者把最大的置换到最后面）。
2.4 置换后的为有序数组。
2.5 重复2-4步骤，直到数组有序为止。

3. 动图演示

4. 完整代码

4.1 核心函数

排序函数：void bubble_sort(int* array, int size)

4.2 代码

#include <stdio.h>
#include <stdlib.h> // rand() srand()
#include <time.h>   // time()

void display(int* array, int size); // 打印函数
int  check(int* array, int size);   // 检查函数
void swap(int* a, int* b);          // 交换函数

/**
 * @brief 冒泡排序：重的往下沉，从小到大
 *
 * @param array        数组首地址
 * @param size         数组大小
 */
void bubble_sort(int* array, int size)
{
    // 外循环为排序趟数，size 个数进行 size-1 趟
    // 内循环为每趟比较的次数，第 i 趟比较 size-1-i 次
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - 1 - i; j++) {
            if (array[j] > array[j + 1]) {
                swap(&array[j], &array[j + 1]);
            }
        }
    }
}

void bubble_sort_better(int* array, int size)
{
    for (int i = 0; i < size - 1; i++) {
        // 以 flag 作为标志，如果遍历完没有改变说明有序不再遍历排序
        int flag = 1;
        for (int j = 0; j < size - 1 - i; j++) {
            if (array[j] > array[j + 1]) {
                swap(&array[j], &array[j + 1]);
                flag = 0;
            }
        }
        if (flag) {
            break;
        }
    }
}

int main()
{
    // 测试用例
    // int array[]    = {49, 38, 65, 97, 76, 13, 27, 49, 10};
    // int array_size = sizeof(array) / sizeof(array[0]);
    // printf("%d \n", array_size);
    // printf("排序前数组：");
    // display(array, array_size);
    // bubble_sort(array, array_size);
    // printf("排序后数组：");
    // display(array, array_size);

    // 随机测试
    int array_num  = 20;             // 数组数量
    int array_size = 20;             // 数组大小
    int array[array_size];           // 数组初始化
    srand((unsigned int)time(NULL)); // 随机数种子，保证每次不一样
    for (int i = 0; i < array_num; i++) {
        for (int j = 0; j < array_size; j++) {
            array[j] = rand() % 1000; // 随机生成数大小 0~999
        }
        printf("原来的数组：");
        display(array, array_size);
        bubble_sort(array, array_size);
        printf("排序后数组：");
        display(array, array_size);
        // 检测排序结果
        if (check(array, array_size) != 0) {
            exit(-1);
        }
        printf("\n");
    }

    return 0;
}

/**
 * @brief 打印函数
 *
 * @param array        数组首指针
 * @param size         数组大小
 */
void display(int* array, int size)
{
    for (int i = 0; i < size; i++) {
        printf("%d ", array[i]);
    }
    printf("\n");
}

/**
 * @brief 检查函数，从小到大
 *
 * @param array        数组首指针
 * @param size         数组大小
 */
int check(int* array, int size)
{
    for (int i = 0; i < size - 1; i++) {
        if (array[i] > array[i + 1]) {
            printf("sort array fail...\n");
            return -1;
        }
    }
    printf("sort array success...\n");
    return 0;
}

/**
 * @brief 交换函数
 *
 * @param a            第一个交换地址
 * @param b            第二个交换地址
 */
void swap(int* a, int* b)
{
    int temp = *b;
    *b       = *a;
    *a       = temp;
}

5. 结果展示（显示每次排序结果）

6. 算法分析

时间复杂度：

1. 最好：O(n)
2. 最坏：O(n^2)
3. 平均：O(n^2)

空间复杂度：O(1)

稳定性：稳定