C语言实现排序之快速排序算法

一、快速排序讲解

基本思想

        快速排序的核心在于选择一个“基准”元素，然后通过一系列操作将数据分为两部分，使得一部分的所有元素都比另一部分的元素小。具体来说，选择一个基准元素后，所有比基准小的元素都会被移动到基准的左边，而所有比基准大的元素都会被移动到基准的右边。这一过程称为分区（Partitioning）。

分区过程

1. 选择基准：从数组中选择一个元素作为基准值。
2. 重排数组：重新排列数组，所有小于基准的元素移动到基准前面，所有大于基准的元素移动到基准后面。这时，基准就处于最终排序后的位置。
3. 递归排序子数组：递归地对基准左边的子数组和右边的子数组重复上述过程，直到所有元素都被排序。

示例

假设有一个数组 [8, 5, 2, 9, 5, 6, 3]，我们可以按照以下步骤来进行快速排序：

1. 选择基准：假设我们选择第一个元素 8 作为基准。
2. 重排数组：
   • 从数组的最右端开始，找到第一个比基准小的元素 5。
   • 从数组的最左端开始，找到第一个比基准大的元素 9。
   • 交换这两个元素。
   • 重复这个过程，直到左指针和右指针相遇。
   • 最后将基准元素与右指针指向的元素交换位置。
   经过这个过程后，数组变为 [5, 5, 2, 3, 8, 6, 9]。此时，基准元素 8 已经位于它的最终位置上。
3. 递归排序子数组：
   • 递归地对 [5, 5, 2, 3] 进行快速排序。
   • 递归地对 [6, 9] 进行快速排序。

性能分析

• 最好情况：每次分区都能将数组均匀分为两半，时间复杂度为 O(n log n)。
• 最坏情况：每次分区只能将数组分为极不平衡的两半，例如总是选择最大或最小元素作为基准，时间复杂度退化为 O(n^2)。
• 平均情况：时间复杂度为 O(n log n)。
• 空间复杂度：O(log n)，因为递归调用需要栈空间。

实现细节

在实际的快速排序实现中，选择基准的方法有很多种，比如可以选择数组的第一个元素、最后一个元素、中间的元素或者随机选择一个元素。不同的选择方法会影响排序的效率。

二、代码

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
 
// 函数声明
int* create_and_generate_random_array(int size);
void print_array(int *array, int size);
void quick_sort(int *array, int left, int right);
int partition(int *array, int left, int right);
int generate_random_size();
 
int main() {
    int size = generate_random_size(); // 随机生成数组大小
 
    int *array = create_and_generate_random_array(size);
 
    if (array == NULL) {
        // 如果内存分配失败
        printf("Memory allocation failed\n");
        return 1;
    }
 
    // 打印原始数组（如果需要，可以取消注释）
    // printf("Original array:\n");
    // print_array(array, size);
 
    // 获取开始时间
    clock_t start_time = clock();
 
    // 对数组进行快速排序
    quick_sort(array, 0, size - 1);
 
    // 获取结束时间
    clock_t end_time = clock();
 
    // 计算时间差并转换为毫秒
    double execution_time = ((double)(end_time - start_time) / CLOCKS_PER_SEC) * 1000;
 
    // 打印排序后的数组（如果需要，可以取消注释）
    // printf("Sorted array:\n");
    // print_array(array, size);
 
    printf("array_size = %d\n", size);
 
    // 打印执行时间
    printf("Execution time: %.2f ms\n", execution_time);
 
    // 释放分配的内存
    free(array);
 
    return 0;
}
 
// 生成随机数组大小
int generate_random_size() {
    srand(time(NULL));
    return rand() % 9000 + 1000; // 生成1000到9999之间的随机数
}
 
// 创建并生成随机数组
int* create_and_generate_random_array(int size) {
    int *array = (int *)malloc(sizeof(int) * size);
    if (array == NULL) {
        // 如果内存分配失败
        return NULL;
    }
 
    // 使用当前时间作为随机数种子
    srand(time(NULL));
    for (int i = 0; i < size; i++) {
        array[i] = rand() % 1000; // 生成0到999之间的随机数
    }
 
    return array;
}
 
// 打印数组
void print_array(int *array, int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", array[i]);
    }
    printf("\n");
}
 
// 快速排序
void quick_sort(int *array, int left, int right) {
    if (left < right) {
        int pivotIndex = partition(array, left, right);
        quick_sort(array, left, pivotIndex - 1);
        quick_sort(array, pivotIndex + 1, right);
    }
}
 
// 分区函数
int partition(int *array, int left, int right) {
    int pivot = array[right]; // 选择最后一个元素作为基准
    int i = left - 1; // 指示小于pivot元素的位置
 
    for (int j = left; j < right; j++) {
        if (array[j] <= pivot) {
            i++;
            swap(&array[i], &array[j]); // 交换元素
        }
    }
 
    swap(&array[i + 1], &array[right]); // 把pivot放到正确的位置
    return i + 1;
}
 
// 交换两个整数
void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}