【C语言冒泡排序的三种方法&笔者自己写的】

冒泡排序算法的核心思想是通过多次遍历数组，比较相邻元素的大小，并根据需要交换它们的位置，从而把较大的元素逐步“冒泡”到数组的末尾。以下是几种不同风格的冒泡排序实现方法，使用C语言编写：

1. 基本的冒泡排序

#include <stdio.h>  
  
void bubbleSort(int arr[], int n) {  
    for (int i = 0; i < n - 1; i++) {  
        for (int j = 0; j < n - i - 1; j++) {  
            if (arr[j] > arr[j + 1]) {  
                // 交换 arr[j] 和 arr[j + 1]  
                int temp = arr[j];  
                arr[j] = arr[j + 1];  
                arr[j + 1] = temp;  
            }  
        }  
    }  
}  
  
int main() {  
    int arr[] = {64, 34, 25, 12, 22, 11, 90};  
    int n = sizeof(arr) / sizeof(arr[0]);  
    bubbleSort(arr, n);  
    printf("Sorted array: \n");  
    for (int i = 0; i < n; i++) {  
        printf("%d ", arr[i]);  
    }  
    return 0;  
}

2. 优化版的冒泡排序（加入标志位减少不必要的遍历）

#include <stdio.h>  
  
void bubbleSort(int arr[], int n) {  
    int swapped;  
    for (int i = 0; i < n - 1; i++) {  
        swapped = 0;  
        for (int j = 0; j < n - i - 1; j++) {  
            if (arr[j] > arr[j + 1]) {  
                // 交换 arr[j] 和 arr[j + 1]  
                int temp = arr[j];  
                arr[j] = arr[j + 1];  
                arr[j + 1] = temp;  
                swapped = 1;  
            }  
        }  
        // 如果没有发生交换，说明数组已经有序，直接退出  
        if (!swapped) {  
            break;  
        }  
    }  
}  
  
int main() {  
    // ... 同上 ...  
}

3. 双向冒泡排序（从两端向中间遍历）

#include <stdio.h>  
  
void bubbleSort(int arr[], int n) {  
    int swapped;  
    int start = 0;  
    int end = n - 1;  
    while (start < end) {  
        swapped = 0;  
        // 从左向右遍历  
        for (int i = start; i < end; i++) {  
            if (arr[i] > arr[i + 1]) {  
                // 交换 arr[i] 和 arr[i + 1]  
                int temp = arr[i];  
                arr[i] = arr[i + 1];  
                arr[i + 1] = temp;  
                swapped = 1;  
            }  
        }  
        if (!swapped) {  
            break;  
        }  
        swapped = 0;  
        end--;  
        // 从右向左遍历  
        for (int i = end - 1; i >= start; i--) {  
            if (arr[i] > arr[i + 1]) {  
                // 交换 arr[i] 和 arr[i + 1]  
                int temp = arr[i];  
                arr[i] = arr[i + 1];  
                arr[i + 1] = temp;  
                swapped = 1;  
            }  
        }  
        start++;  
    }  
}  
  
int main() {  
    // ... 同上 ...  
}

在上面的三种实现中，基本的冒泡排序是最直接的，但是效率相对较低。优化版的冒泡排序通过添加一个标志位来减少不必要的遍历次数，当某次遍历中没有发生交换时，说明数组已经有序，可以提前退出。双向冒泡排序则是结合了从数组两端向中间遍历的思想，进一步提高了效率。

请注意，冒泡排序算法的时间复杂度是O(n^2)，对于大型数据集，其效率较低。在实际应用中，通常会选择更高效的排序算法，如归并排序、快速排序等。

3. 笔者

// Function: 数组冒泡排序  
// Author: [你的名字]  
// Date: [日期]  
#include<stdio.h>  
  
int main(void)  
{  
    int i = 0, j = 0, temp = 0;  
      
    int arr[] = {1,3,2,8,6,4,7,9,5}; // 初始化一个未排序的整数数组  
  
    int arr_length = sizeof(arr) / sizeof(arr[0]); // 计算数组的长度  
  
    // 外层循环，控制需要排序的轮数  
    for(i = 0; i < arr_length - 1; i++)  
    {  
        // 内层循环，负责相邻元素的比较和交换  
        for(j = 0; j < arr_length - 1 - i; j++)  
        {  
            // 如果当前元素大于下一个元素，则交换它们的位置  
            // 这样最大的元素就会"冒泡"到数组的末尾  
            if(arr[j] > arr[j + 1]) // 注意这里应该是大于号，因为我们是进行升序排序  
            {  
                temp = arr[j];  
                arr[j] = arr[j + 1];  
                arr[j + 1] = temp;  
            }  
        }  
    }  
      
    // 遍历输出排序后的数组  
    for(i = 0; i < arr_length; i++)  
    {  
        printf("%d ", arr[i]);  
    }  
    // 打印换行符  
    putchar(10);  
  
    return 0;  
}