C语言写个快速排序算法

### 回答1：

按照快速排序算法，C语言实现的程序如下： void quick_sort(int *arr, int start, int end)
{
if (start >= end) //如果只有一个元素，就不用再排下去了
return;
int mid = arr[end]; //取最后一个元素作为基准
int left = start, right = end - 1;
while (left < right)
{
while (arr[left] < mid && left < right)
left++;
while (arr[right] >= mid && left < right)
right--;
if (left < right)
swap(arr[left],arr[right]);
}
//基准归位
if (arr[left] >= arr[end])
swap(arr[left], arr[end]);
else
left++;
if (left)
quick_sort(arr, start, left - 1);
quick_sort(arr, left + 1, end);
}

### 回答2：
快速排序（Quick Sort）是一种常见且高效的排序算法，它的基本思想是选择一个基准元素，将数组分为左右两部分，将小于基准的元素放在左边，大于基准的元素放在右边。

以下是用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[] = { 10, 7, 8, 9, 1, 5 };
    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`函数用来递归调用`partition`函数，实现对子数组的快速排序。`printArray`函数用来打印数组的元素。

在`main`函数中，首先打印原始数组，然后调用`quickSort`函数对数组进行快速排序，最后打印排序后的数组。

快速排序算法的时间复杂度为O(nlogn)，是一种非常高效的排序算法。

### 回答3：
快速排序是一种常用的排序算法，它基于分治的思想。下面是用C语言实现快速排序的代码：

#include <stdio.h>

// 交换两个元素的值
void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

// 将数组以pivot为基准分成两部分，左边元素小于pivot，右边元素大于等于pivot
int partition(int array[], int low, int high) {
    int pivot = array[high]; // 取最后一个元素作为pivot
    int i = (low - 1); // 最小元素的位置

    for (int j = low; j <= high - 1; j++) {
        // 当前元素小于等于pivot时，将其交换到左边
        if (array[j] <= pivot) {
            i++;
            swap(&array[i], &array[j]);
        }
    }
    swap(&array[i + 1], &array[high]);
    return (i + 1);
}

// 快速排序
void quickSort(int array[], int low, int high) {
    if (low < high) {
        // 将数组分成两部分，递归地对两部分分别排序
        int pi = partition(array, low, high);
        quickSort(array, low, pi - 1);
        quickSort(array, pi + 1, high);
    }
}

// 测试快速排序算法
int main() {
    int array[] = { 64, 25, 12, 22, 11 };
    int n = sizeof(array) / sizeof(array[0]);

    printf("原数组：\n");
    for (int i = 0; i < n; i++) {
        printf("%d ", array[i]);
    }

    quickSort(array, 0, n - 1);

    printf("\n快速排序后的数组：\n");
    for (int i = 0; i < n; i++) {
        printf("%d ", array[i]);
    }

    return 0;
}

以上是用C语言写的快速排序算法。该算法通过选择一个pivot元素，将数组分为两部分，并递归地对两部分进行排序，最终实现整个数组的排序。在代码中，使用了`swap`函数来交换两个元素的值，`partition`函数用于分割数组，`quickSort`函数用于递归地对数组进行快速排序。在`main`函数中，我们定义了一个待排序的数组，然后调用`quickSort`函数进行排序，最后输出排序后的结果。