冒泡排序，插入排序，快速排序，选择排序

目录

[1. 冒泡排序（Bubble Sort）](#1. 冒泡排序（Bubble Sort）)

例子步骤：

[2. 插入排序（Insertion Sort）](#2. 插入排序（Insertion Sort）)

例子步骤：

[3. 选择排序（Selection Sort）](#3. 选择排序（Selection Sort）)

例子步骤：

[4. 快速排序（Quick Sort）](#4. 快速排序（Quick Sort）)

例子步骤：

---

1. 冒泡排序（Bubble Sort）

冒泡排序通过重复地交换相邻的元素来将数组排序。每一轮操作都将最大元素"冒泡"到数组的末尾。

例子步骤：

数组初始状态：[5, 2, 9, 1, 5, 6]

• 第 1 轮：

  • 比较 5 和 2，交换，数组变成 [2, 5, 9, 1, 5, 6]
  • 比较 5 和 9，不交换
  • 比较 9 和 1，交换，数组变成 [2, 5, 1, 9, 5, 6]
  • 比较 9 和 5，交换，数组变成 [2, 5, 1, 5, 9, 6]
  • 比较 9 和 6，交换，数组变成 [2, 5, 1, 5, 6, 9]

• 第 2 轮：

  • 比较 2 和 5，不交换
  • 比较 5 和 1，交换，数组变成 [2, 1, 5, 5, 6, 9]
  • 比较 5 和 5，不交换
  • 比较 5 和 6，不交换

• 第 3 轮：

  • 比较 2 和 1，交换，数组变成 [1, 2, 5, 5, 6, 9]
  • 比较 2 和 5，不交换

排序完成，最终数组为 [1, 2, 5, 5, 6, 9]。

#include <stdio.h>

int main(int argc, const char *argv[])
{
    int arr[] = {5, 2, 9, 1, 5, 6};
    int len = sizeof(arr) / sizeof(arr[0]);
    int temp;

    // 输出排序前的数组
    printf("排序前的数组: ");
    for (int i = 0; i < len; i++) {
        printf("%d  ", arr[i]);
    }
    printf("\n");

    // 冒泡排序
    for (int i = 0; i < len - 1; i++) {
        for (int j = 0; j < len - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                // 交换元素
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }

    // 输出排序后的数组
    printf("排序后的数组: ");
    for (int i = 0; i < len; i++) {
        printf("%d  ", arr[i]);
    }
    printf("\n");

    return 0;
}

2. 插入排序（Insertion Sort）

插入排序通过逐个元素进行插入操作，将每个元素插入到它之前已经排序好的部分。

例子步骤：

数组初始状态：[5, 2, 9, 1, 5, 6]

• 第 1 步：元素 2 与 5 比较，插入到 5 前面，数组变成 [2, 5, 9, 1, 5, 6]
• 第 2 步：元素 9 无需移动，保持不变，数组仍为 [2, 5, 9, 1, 5, 6]
• 第 3 步：元素 1 与 9、5、2 比较，插入到第一个位置，数组变成 [1, 2, 5, 9, 5, 6]
• 第 4 步：元素 5 与 9 比较，插入到 9 前面，数组变成 [1, 2, 5, 5, 9, 6]
• 第 5 步：元素 6 与 9 比较，插入到 9 前面，数组变成 [1, 2, 5, 5, 6, 9]

排序完成，最终数组为 [1, 2, 5, 5, 6, 9]。

#include <stdio.h>

int main(int argc, const char *argv[])
{
    int arr[] = {5, 2, 9, 1, 5, 6};
    // 获取数组的长度
    int len = sizeof(arr) / sizeof(arr[0]);
    int temp, j;

    // 输出排序前的数组
    printf("排序前的数组: ");
    for (int i = 0; i < len; i++) {
        printf("%d  ", arr[i]);
    }
    printf("\n");

    // 插入排序的实现
    for (int i = 1; i < len; i++) {
        temp = arr[i]; // 当前需要插入的值
        j = i - 1;
        
        // 找到比当前值大的元素，将其向后移动
        while (j >= 0 && arr[j] > temp) {
            arr[j + 1] = arr[j]; // 移动元素
            j--;
        }
        
        // 将当前值插入到正确位置
        arr[j + 1] = temp;
    }

    // 输出排序后的数组
    printf("排序后的数组: ");
    for (int i = 0; i < len; i++) {
        printf("%d  ", arr[i]);
    }
    printf("\n");

    return 0;
}

---

3. 选择排序（Selection Sort）

选择排序每次从未排序的部分中选择最小的元素，并将其放到已排序部分的末尾。

例子步骤：

数组初始状态：[5, 2, 9, 1, 5, 6]

• 第 1 步：找到最小的元素 1，与第一个元素交换，数组变成 [1, 2, 9, 5, 5, 6]
• 第 2 步：找到剩下未排序部分中的最小元素 2，位置不变，数组仍为 [1, 2, 9, 5, 5, 6]
• 第 3 步：找到最小的元素 5，与 9 交换，数组变成 [1, 2, 5, 9, 5, 6]
• 第 4 步：找到最小的元素 5，与 9 交换，数组变成 [1, 2, 5, 5, 9, 6]
• 第 5 步：找到最小的元素 6，与 9 交换，数组变成 [1, 2, 5, 5, 6, 9]

排序完成，最终数组为 [1, 2, 5, 5, 6, 9]。

#include <stdio.h>

int main(int argc, const char *argv[])
{
    int arr[] = {5, 2, 9, 1, 5, 6};
    int len = sizeof(arr) / sizeof(arr[0]);
    int temp, min_index;

    // 输出排序前的数组
    printf("排序前的数组: ");
    for (int i = 0; i < len; i++) {
        printf("%d  ", arr[i]);
    }
    printf("\n");

    // 选择排序
    for (int i = 0; i < len - 1; i++) {
        min_index = i; // 假设当前最小值的索引为 i
        for (int j = i + 1; j < len; j++) {
            if (arr[j] < arr[min_index]) {
                min_index = j; // 找到更小的值
            }
        }
        // 交换最小值与当前位置的值
        temp = arr[i];
        arr[i] = arr[min_index];
        arr[min_index] = temp;
    }

    // 输出排序后的数组
    printf("排序后的数组: ");
    for (int i = 0; i < len; i++) {
        printf("%d  ", arr[i]);
    }
    printf("\n");

    return 0;
}

---

4. 快速排序（Quick Sort）

快速排序通过选择一个"基准"（pivot）元素，将数组分为两部分，一部分比基准小，另一部分比基准大，然后递归排序。

例子步骤：

数组初始状态：[5, 2, 9, 1, 5, 6]

• 选择 5 作为基准。

  • 小于 5 的部分：[2, 1]
  • 大于或等于 5 的部分：[9, 5, 6]

  递归对每部分排序。

• 排序 [2, 1]：

  • 选择 2 作为基准。
    • 小于 2 的部分：[1]
    • 大于 2 的部分：[]

  排序完成后为 [1, 2]。

• 排序 [9, 5, 6]：

  • 选择 9 作为基准。
    • 小于 9 的部分：[5, 6]
    • 大于 9 的部分：[]

  继续排序 [5, 6]：

  • 选择 5 作为基准。
    • 小于 5 的部分：[]
    • 大于或等于 5 的部分：[6]

  排序完成后为 [5, 6]。

最后组合所有部分，得到 [1, 2] + [5] + [5, 6, 9] = [1, 2, 5, 5, 6, 9]。

#include <stdio.h>

// 快速排序函数
void quickSort(int arr[], int left, int right)
{
    if (left >= right) {
        return; // 递归终止条件
    }

    int pivot = arr[left]; // 选择最左边的元素作为基准
    int i = left;
    int j = right;
    int temp;

    // 分区操作
    while (i < j) {
        // 从右向左找到第一个比基准小的元素
        while (i < j && arr[j] >= pivot) {
            j--;
        }
        // 从左向右找到第一个比基准大的元素
        while (i < j && arr[i] <= pivot) {
            i++;
        }
        // 交换i和j位置的元素
        if (i < j) {
            temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }

    // 基准元素归位
    arr[left] = arr[i];
    arr[i] = pivot;

    // 对基准左右两边的子数组进行递归快速排序
    quickSort(arr, left, i - 1);
    quickSort(arr, i + 1, right);
}

int main(int argc, const char *argv[])
{
    int arr[] = {5, 2, 9, 1, 5, 6};
    int len = sizeof(arr) / sizeof(arr[0]);

    // 输出排序前的数组
    printf("排序前的数组: ");
    for (int i = 0; i < len; i++) {
        printf("%d  ", arr[i]);
    }
    printf("\n");

    // 调用快速排序
    quickSort(arr, 0, len - 1);

    // 输出排序后的数组
    printf("排序后的数组: ");
    for (int i = 0; i < len; i++) {
        printf("%d  ", arr[i]);
    }
    printf("\n");

    return 0;
}