C语言实现冒泡排序：一步步详解及优化思路

本文链接：https://blog.csdn.net/m0_64733058/article/details/147403676

1. 引言

排序是计算机科学中的基础问题，几乎在每个程序中都会涉及到。排序算法有很多种，而 冒泡排序 是最简单的一种。虽然冒泡排序的效率不高，但它仍然是学习和理解排序算法的一个很好的起点。今天，我们就来用C语言实现一个经典的冒泡排序算法，并且逐步讲解其原理和优化思路。

2. 冒泡排序的基本原理

冒泡排序是一种交换排序算法，其核心思想是通过重复遍历数组，比较相邻的元素，如果它们的顺序错误就交换它们的位置，经过每一轮遍历，未排序部分的最大元素会被“冒泡”到数组的末尾。因此，冒泡排序的名字就来源于此。

冒泡排序的步骤：

从数组的头部开始，依次比较相邻的元素。
如果前一个元素大于后一个元素，则交换这两个元素的位置。
继续向后比较，直到遍历完整个数组，最大的元素会被移到最后。
重复以上步骤，直到整个数组排序完成。

3. C语言实现冒泡排序

下面是用C语言实现冒泡排序的代码：

#include <stdio.h>

// 冒泡排序函数
void bubbleSort(int arr[], int size) {
    for (int i = 0; i < size - 1; i++) {
        // 内层循环用于每次遍历中进行相邻元素的比较和交换
        for (int j = 0; j < size - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                // 交换元素
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

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

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};  // 示例数组
    int size = sizeof(arr) / sizeof(arr[0]);   // 计算数组大小

    printf("原始数组:\n");
    printArray(arr, size);  // 打印原始数组

    bubbleSort(arr, size);  // 调用冒泡排序

    printf("排序后的数组:\n");
    printArray(arr, size);  // 打印排序后的数组

    return 0;
}

4. 代码解析

bubbleSort 函数：这是实现冒泡排序的核心部分。它的工作原理就是通过两层循环，不断地比较并交换相邻元素的位置，最终将最大元素“冒泡”到数组的最后。
- 外层循环 for (int i = 0; i < size - 1; i++) 控制比较的轮数。每进行一次外层循环，未排序部分中最大的元素就会被交换到最后。
- 内层循环 for (int j = 0; j < size - 1 - i; j++) 用于比较相邻的元素，如果前一个元素大于后一个元素，则交换它们的位置。size - 1 - i 是为了避免已经排序好的部分再次参与比较。
printArray 函数：用来输出数组的元素，方便观察排序前后的变化。
main 函数：在 main 函数中，我们定义了一个示例数组 {64, 34, 25, 12, 22, 11, 90}，然后调用 bubbleSort 函数进行排序，并在排序前后打印数组。

5. 冒泡排序的时间复杂度与空间复杂度

时间复杂度：
- 最坏情况下（数组是逆序的），冒泡排序需要进行 n-1 轮比较，每轮比较的次数依次为 n-1, n-2, ..., 1。所以，最坏时间复杂度为 O(n^2)。
- 平均时间复杂度也是 O(n^2)，因为每一轮的比较都需要遍历数组的剩余部分。
- 最好情况下（数组已经排序），如果我们不做优化，时间复杂度仍然是 O(n^2)。
空间复杂度：
- 冒泡排序是原地排序，不需要额外的存储空间，因此空间复杂度为 O(1)。

6. 冒泡排序的优化

虽然冒泡排序的实现非常简单，但其效率不高。在最坏情况下，冒泡排序的时间复杂度为 O(n^2)，这使得它不适合大规模数据的排序。我们可以通过以下方法优化冒泡排序：

提前退出优化：如果在某一轮遍历中没有发生任何交换，说明数组已经是有序的，这时候可以提前退出循环，避免不必要的比较和交换操作。

void optimizedBubbleSort(int arr[], int size) {
    for (int i = 0; i < size - 1; i++) {
        int swapped = 0;  // 标记是否发生了交换
        for (int j = 0; j < size - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                swapped = 1;  // 标记发生了交换
            }
        }
        // 如果没有发生交换，提前退出
        if (!swapped) break;
    }
}

优化后的冒泡排序减少了不必要的遍历，在已经部分有序的情况下提高了效率。