C语言排序算法

在 C 语言中，排序算法是基本的算法之一。排序的目的是将一个数组按照指定的顺序排列（升序或降序）。排序算法分为两大类：

1. 比较排序算法：通过比较元素的大小决定顺序。
2. 非比较排序算法：不直接比较元素的大小（如基数排序）。

接下来，我们将详细讲解几种常用的排序算法，并提供 C 语言的实现代码。

1. 冒泡排序（Bubble Sort）

算法简介

• 冒泡排序是最简单的排序算法之一。
• 它通过多次遍历数组，每次将相邻的两个元素比较并交换，直到数组有序。
• 时间复杂度：
  • 最优：O(n)（当数组已经有序时，仅需一趟遍历）
  • 最差：O(n²)（当数组逆序时）
  • 平均：O(n²)

代码实现

#include <stdio.h>

void bubble_sort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        int swapped = 0; // 优化：如果某一轮没有发生交换，说明已经有序
        for (int j = 0; j < n - i - 1; 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; // 提前退出
    }
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int n = sizeof(arr) / sizeof(arr[0]);

    bubble_sort(arr, n);

    printf("Sorted array: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    return 0;
}

2. 选择排序（Selection Sort）

算法简介

• 每次从未排序的部分中选择最小（或最大）的元素，并将其放到已排序部分的末尾。
• 时间复杂度：
  • 最优、最差、平均：O(n²)（始终需要两层循环）
• 特点：
  • 简单易实现，但不适合大型数据集。

代码实现

#include <stdio.h>

void selection_sort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        int min_index = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[min_index]) {
                min_index = j;
            }
        }
        // 交换最小值到当前位置
        int temp = arr[min_index];
        arr[min_index] = arr[i];
        arr[i] = temp;
    }
}

int main() {
    int arr[] = {29, 10, 14, 37, 13};
    int n = sizeof(arr) / sizeof(arr[0]);

    selection_sort(arr, n);

    printf("Sorted array: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    return 0;
}

3. 插入排序（Insertion Sort）

算法简介

• 每次将一个元素插入到已排序部分的合适位置。
• 时间复杂度：
  • 最优：O(n)（数组已部分有序时）
  • 最差：O(n²)（数组完全逆序）
  • 平均：O(n²)
• 特点：
  • 对于小规模或接近有序的数据集效率较高。

代码实现

#include <stdio.h>

void insertion_sort(int arr[], int n) {
    for (int i = 1; i < n; i++) {
        int key = arr[i];
        int j = i - 1;

        // 将大于 key 的元素向后移动
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}

int main() {
    int arr[] = {12, 11, 13, 5, 6};
    int n = sizeof(arr) / sizeof(arr[0]);

    insertion_sort(arr, n);

    printf("Sorted array: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    return 0;
}

4. 快速排序（Quick Sort）

算法简介

• 快速排序是基于分治思想的高效排序算法。
• 通过选择一个基准元素（pivot），将数组分为两部分：比基准小的元素和比基准大的元素，然后递归排序。
• 时间复杂度：
  • 最优、平均：O(n log n)
  • 最差：O(n²)（当每次选择的基准是最小或最大元素时）

代码实现

#include <stdio.h>

void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int partition(int arr[], int low, int high) {
    int pivot = arr[high]; // 选择最后一个元素作为基准
    int i = low - 1;

    for (int j = low; j < high; j++) {
        if (arr[j] < pivot) {
            i++;
            swap(&arr[i], &arr[j]);
        }
    }
    swap(&arr[i + 1], &arr[high]);
    return i + 1;
}

void quick_sort(int arr[], int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);

        quick_sort(arr, low, pi - 1);
        quick_sort(arr, pi + 1, high);
    }
}

int main() {
    int arr[] = {10, 7, 8, 9, 1, 5};
    int n = sizeof(arr) / sizeof(arr[0]);

    quick_sort(arr, 0, n - 1);

    printf("Sorted array: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    return 0;
}

5. 归并排序（Merge Sort）

算法简介

• 归并排序是基于分治思想的排序算法。
• 将数组分成两部分，分别排序后合并。
• 时间复杂度：
  • 最优、最差、平均：O(n log n)
• 特点：
  • 稳定排序，适合大规模数据。

代码实现

#include <stdio.h>
#include <stdlib.h>

void merge(int arr[], int l, int m, int r) {
    int n1 = m - l + 1;
    int n2 = r - m;

    int *L = malloc(n1 * sizeof(int));
    int *R = malloc(n2 * sizeof(int));

    for (int i = 0; i < n1; i++) L[i] = arr[l + i];
    for (int j = 0; j < n2; j++) R[j] = arr[m + 1 + j];

    int i = 0, j = 0, k = l;

    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        } else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }

    while (i < n1) arr[k++] = L[i++];
    while (j < n2) arr[k++] = R[j++];

    free(L);
    free(R);
}

void merge_sort(int arr[], int l, int r)