怎样在 C 语言中实现快速排序？

🍅关注博主🎗️ 带你畅游技术世界，不错过每一次成长机会！
📙C 语言百万年薪修炼课程 通俗易懂，深入浅出，匠心打磨，死磕细节，6年迭代，看过的人都说好。

C 语言中的快速排序实现

一、快速排序的基本原理

快速排序（Quick Sort）是对冒泡排序的一种改进，它采用了分治法的思想。基本原理是通过选择一个基准元素，将待排序的数组划分为两部分，一部分的元素都小于等于基准元素，另一部分的元素都大于基准元素，然后对这两部分分别进行快速排序，从而实现整个数组的有序。

二、快速排序的步骤

1. 选择一个基准元素，可以选择数组的第一个元素、最后一个元素或者中间元素，通常选择第一个元素。
2. 重新排列数组，将所有小于基准元素的元素放在基准元素的左边，将所有大于基准元素的元素放在基准元素的右边。这个过程称为分区（Partition）操作。
3. 对基准元素左边和右边的子数组分别递归地进行快速排序。

三、快速排序的代码实现

#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 - 1; j++) {
        if (arr[j] <= pivot) {
            i++;
            swap(&arr[i], &arr[j]);
        }
    }
    swap(&arr[i + 1], &arr[high]);
    return (i + 1);
}

// 快速排序函数
void quickSort(int arr[], int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);

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

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

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

    printf("排序前的数组为: \n");
    printArray(arr, n);

    quickSort(arr, 0, n - 1);

    printf("排序后的数组为: \n");
    printArray(arr, n);

    return 0;
}

上述代码中，我们首先定义了一个swap函数用于交换两个元素的值。

partition函数用于选择基准元素并对数组进行分区。它选择数组的最后一个元素作为基准元素，然后通过遍历数组，将小于等于基准元素的值移动到左边，大于基准元素的值移动到右边，并返回基准元素的最终位置。

quickSort函数是快速排序的核心函数。如果当前的子数组长度大于 1，就通过partition函数获取基准元素的位置，然后对基准元素左边和右边的子数组分别递归调用quickSort函数。

在main函数中，我们创建了一个测试数组，并打印出排序前后数组的所有元素。

四、快速排序的时间复杂度和空间复杂度分析

1. 时间复杂度

   • 最坏情况：当每次分区操作都选择到数组中的最大值或最小值作为基准元素时，快速排序的时间复杂度为$O(n^2)$。这种情况发生的概率很低，例如数组已经有序的情况。
   • 平均情况：快速排序的平均时间复杂度为$O(nlogn)$。这是因为每次分区操作都能将数组大致分成两等份，递归的深度为$logn$，而每次分区操作的时间复杂度为$O(n)$。
   • 最好情况：当每次分区操作都能将数组平均分成两等份时，时间复杂度为$O(nlogn)$。

2. 空间复杂度

   • 快速排序的空间复杂度主要取决于递归调用所使用的栈空间。在平均情况下，空间复杂度为$O(logn)$；在最坏情况下，空间复杂度为$O(n)$。

五、快速排序的优化

1. 随机选择基准元素

在上述代码中，我们总是选择数组的最后一个元素作为基准元素。为了避免在最坏情况下的时间复杂度，我们可以随机选择一个元素作为基准元素，这样可以减少出现最坏情况的概率。

#include <stdlib.h>

int partition(int arr[], int low, int high) {
    // 随机选择一个索引作为基准元素的索引
    int random_index = low + rand() % (high - low + 1);
    swap(&arr[random_index], &arr[high]);

    int pivot = arr[high];
    int i = (low - 1);

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

2. 小数组切换到插入排序

当子数组的长度较小时，快速排序的递归调用开销可能会超过其带来的优势。此时，可以切换到插入排序等简单排序算法来提高效率。

void quickSort(int arr[], int low, int high) {
    if (low < high) {
        if (high - low + 1 < 10) {
            // 当子数组长度小于 10 时，使用插入排序
            insertionSort(arr, low, high);
            return;
        }
        int pi = partition(arr, low, high);

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

void insertionSort(int arr[], int low, int high) {
    for (int i = low + 1; i <= high; i++) {
        int key = arr[i];
        int j = i - 1;

        while (j >= low && arr[j] > key) {
            arr[j + 1] = arr[j];
            j = j - 1;
        }
        arr[j + 1] = key;
    }
}

3. 三路快速排序

对于包含大量重复元素的数组，可以使用三路快速排序来进一步提高效率。三路快速排序将数组分为小于基准、等于基准和大于基准三部分，然后对小于基准和大于基准的两部分分别递归排序。

#include <stdlib.h>

void quickSort3Way(int arr[], int low, int high) {
    if (high <= low) return;

    int lt = low;
    int gt = high;
    int v = arr[low];
    int i = low;

    while (i <= gt) {
        if (arr[i] < v) {
            swap(&arr[lt], &arr[i]);
            lt++;
            i++;
        } else if (arr[i] > v) {
            swap(&arr[i], &arr[gt]);
            gt--;
        } else {
            i++;
        }
    }

    quickSort3Way(arr, low, lt - 1);
    quickSort3Way(arr, gt + 1, high);
}

六、总结

快速排序是一种高效的排序算法，在平均情况下具有出色的性能。通过合理的优化，如随机选择基准元素、在小数组时切换到插入排序和使用三路快速排序，可以进一步提高其在各种情况下的效率。在实际应用中，需要根据数据的特点和性能要求选择合适的排序算法和优化策略。

🎉相关推荐

• 📙C 语言百万年薪修炼课程 通俗易懂，深入浅出，匠心打磨，死磕细节，6年迭代，看过的人都说好。
• 🍅博客首页-关注博主🎗️ 带你畅游技术世界，不错过每一次成长机会！
• 📙CSDN专栏-C语言修炼
• 📙技术社区-墨松科技