用c语言写一个快速排序

### 回答1：
快速排序是一种常用的排序算法，其基本思想是通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，然后再分别对这两部分记录继续进行排序，以达到整个序列有序的目的。

以下是用C语言实现快速排序的代码：

#include <stdio.h>

void quick_sort(int arr[], int left, int right) {
    int i, j, pivot, temp;
    if (left < right) {
        i = left;
        j = right;
        pivot = arr[left];
        while (i < j) {
            while (i < j && arr[j] >= pivot)
                j--;
            if (i < j)
                arr[i++] = arr[j];
            while (i < j && arr[i] < pivot)
                i++;
            if (i < j)
                arr[j--] = arr[i];
        }
        arr[i] = pivot;
        quick_sort(arr, left, i - 1);
        quick_sort(arr, i + 1, right);
    }
}

int main() {
    int arr[] = { 5, 2, 8, 4, 7, 1, 3, 6 };
    int n = sizeof(arr) / sizeof(arr[]);
    quick_sort(arr, , n - 1);
    printf("排序后的数组：");
    for (int i = ; i < n; i++)
        printf("%d ", arr[i]);
    return ;
}

在这个代码中，我们定义了一个名为`quick_sort`的函数，它接受三个参数：待排序的数组`arr`、数组的左边界`left`和右边界`right`。在函数内部，我们首先判断左边界是否小于右边界，如果是，则进行以下操作：

1. 定义变量`i`和`j`，分别指向数组的左右两端；
2. 定义变量`pivot`，用于存储枢轴元素的值，这里我们选择数组的第一个元素作为枢轴元素；
3. 在`while`循环中，我们先从右往左扫描数组，找到第一个小于枢轴元素的元素，然后将其赋值给`arr[i]`，并将`i`加1；
4. 接着从左往右扫描数组，找到第一个大于等于枢轴元素的元素，然后将其赋值给`arr[j]`，并将`j`减1；
5. 重复步骤3和4，直到`i`和`j`相遇；
6. 将枢轴元素赋值给`arr[i]`，此时枢轴元素左边的元素都小于它，右边的元素都大于等于它；
7. 递归调用`quick_sort`函数，对枢轴元素左边的子数组进行排序；
8. 递归调用`quick_sort`函数，对枢轴元素右边的子数组进行排序。

最后，在`main`函数中，我们定义了一个数组`arr`，并调用`quick_sort`函数对其进行排序。排序完成后，我们输出排序后的数组。

### 回答2：
快速排序是一种高效的排序算法，它采用分治的思想。下面是用C语言编写的一个快速排序的实现：

#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[] = {7, 2, 1, 6, 8, 5, 3, 4};
    int size = sizeof(arr) / sizeof(arr[0]);

    printf("原始数组：");
    printArray(arr, size);

    quicksort(arr, 0, size - 1);

    printf("排序后数组：");
    printArray(arr, size);

    return 0;
}

这个快速排序算法通过递归地划分子数组并交换元素，从而实现对整个数组的排序。它首先选择一个基准元素，将大于基准元素的元素放到右侧，小于等于基准元素的元素放到左侧，然后对左右两个子数组分别进行递归排序，直到子数组只有一个元素。最后，合并各个子数组，完成排序。算法的时间复杂度为O(nlogn)。

### 回答3：
快速排序（Quicksort）是一种常用的排序算法，它的基本思想是通过一趟排序将待排记录分割成独立的两部分，使得左侧部分的所有记录均比右侧部分的所有记录小，然后再分别对两部分进行排序，达到整个序列有序的目的。

以下是用C语言实现快速排序的示例代码：

#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 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[] = { 64, 25, 12, 22, 11 };
    int n = sizeof(arr) / sizeof(arr[0]);

    printf("Before sorting: \n");
    printArray(arr, n);

    quickSort(arr, 0, n - 1);

    printf("After sorting: \n");
    printArray(arr, n);

    return 0;
}

这段代码实现了快速排序算法。核心函数`quickSort`使用了递归的方式，先通过`partition`函数将数组按基准值分割成两部分，然后再对两部分分别递归调用`quickSort`函数来进行排序。最后，通过`printArray`函数输出排序后的数组。运行这段代码，可以看到输出结果。