C语言指针-冒泡排序之旅

文章目录

• 一、冒泡排序原理
• 二、冒泡排序过程示例
• • 1、第一轮排序
  • 2、第二轮排序
  • 3、第三轮排序
  • 4、第四轮排序
• 三、C语言代码实现步骤及程度
• • [1、外层循环（`for (i = 0; i < n - 1; i++)`）](#1、外层循环（for (i = 0; i < n - 1; i++)）)
  • [2、内层循环（`for (j = 0; j < n - i - 1; j++)`）](#2、内层循环（for (j = 0; j < n - i - 1; j++)）)
  • [3、交换元素部分（`if (arr[j] > arr[j + 1]) {...}`）](#3、交换元素部分（if (arr[j] > arr[j + 1]) {...}）)

一、冒泡排序原理

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

二、冒泡排序过程示例

• 假设我们有一个整数数组arr = {5, 4, 3, 2, 1}，我们要对这个数组进行升序排列。

1、第一轮排序

 - 比较`arr[0]`和`arr[1]`，即`5`和`4`。因为`5 > 4`，所以交换它们的位置，数组变为`{4, 5, 3, 2, 1}`。
 - 接着比较`arr[1]`和`arr[2]`，即`5`和`3`。因为`5 > 3`，交换位置，数组变为`{4, 3, 5, 2, 1}`。
 - 再比较`arr[2]`和`arr[3]`，即`5`和`2`。因为`5 > 2`，交换位置，数组变为`{4, 3, 2, 5, 1}`。
 - 最后比较`arr[3]`和`arr[4]`，即`5`和`1`。因为`5 > 1`，交换位置，数组变为`{4, 3, 2, 1, 5}`。
 - 经过第一轮排序后，最大的元素`5`已经"浮"到了数组的最后一个位置。

2、第二轮排序

 - 比较`arr[0]`和`arr[1]`，即`4`和`3`。因为`4 > 3`，交换位置，数组变为`{3, 4, 2, 1, 5}`。
 - 接着比较`arr[1]`和`arr[2]`，即`4`和`2`。因为`4 > 2`，交换位置，数组变为`{3, 2, 4, 1, 5}`。
 - 再比较`arr[2]`和`arr[3]`，即`4`和`1`。因为`4 > 1`，交换位置，数组变为`{3, 2, 1, 4, 5}`。
 - 经过第二轮排序后，第二大的元素`4`已经"浮"到了倒数第二个位置。

3、第三轮排序

 - 比较`arr[0]`和`arr[1]`，即`3`和`2`。因为`3 > 2`，交换位置，数组变为`{2, 3, 1, 4, 5}`。
 - 接着比较`arr[1]`和`arr[2]`，即`3`和`1`。因为`3 > 1`，交换位置，数组变为`{2, 1, 3, 4, 5}`。
 - 经过第三轮排序后，第三大的元素`3`已经"浮"到了倒数第三个位置。

4、第四轮排序

 - 比较`arr[0]`和`arr[1]`，即`2`和`1`。因为`2 > 1`，交换位置，数组变为`{1, 2, 3, 4, 5}`。
 - 经过四轮排序后，数组已经完成升序排列。

三、C语言代码实现步骤及程度

• 以下是一个简单的C语言冒泡排序代码实现：

#include <stdio.h>

void bubble_sort(int arr[], int n) {
    int i, j, temp;
    for (i = 0; i < n - 1; i++) {
        // 每一轮比较
        for (j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                // 交换元素
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main() {
    int arr[] = {5, 4, 3, 2, 1};
    int n = sizeof(arr)/sizeof(arr[0]);
    bubble_sort(arr, n);
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    return 0;
}

1、外层循环（for (i = 0; i < n - 1; i++)）

 - 这个循环控制排序的轮数。对于一个有`n`个元素的数组，最多需要`n - 1`轮排序就可以完成整个数组的排序。
 - 因为每一轮排序都会将当前未排序部分的最大元素"浮"到后面已经排序好的部分，所以每一轮结束后，后面就会多一个已经排序好的元素，
 - 需要排序的部分就会减少一个。

2、内层循环（for (j = 0; j < n - i - 1; j++)）

 - 这个循环控制每一轮中相邻元素的比较次数。在每一轮排序中，由于最后`i`个元素已经在前面的轮次中排序好了，
 - 所以只需要比较前`n - i - 1`个元素。例如，在第一轮排序中，需要比较`n - 1`次，因为所有元素都还未排序；
 - 在第二轮排序中，只需要比较`n - 2`次，因为最后一个元素已经是最大的了，不需要再参与比较，以此类推。

3、交换元素部分（if (arr[j] > arr[j + 1]) {...}）

 - 当`arr[j]`大于`arr[j + 1]`时，说明这两个相邻元素的顺序不符合升序要求，需要交换它们的位置。
 - 通过一个临时变量`temp`来实现交换，先将`arr[j]`的值赋给`temp`，然后将`arr[j + 1]`的值赋给`arr[j]`，
 - 最后将`temp`（原来`arr[j]`的值）赋给`arr[j + 1]`，这样就完成了两个元素的交换。
 - 在主函数`main`中，首先定义了一个待排序的数组`arr`，然后通过`sizeof`操作符计算出数组的长度`n`。
 - 接着调用`bubble_sort`函数对数组进行排序，最后通过一个循环打印出排序后的数组元素。