使用函数的递归实现快速排序

两种方法，其实差不多。注释我写得很多，就不另外给大家解释了。

方法1：

#include <stdio.h>

/*快排是通过递归方式实现的*/
/*1.以第一个元素为基准元素，比它小的放左边，比它大的放右边-->得到两个无序的序列*/
/*2.*/
void swap(int *x, int *y)
{
    int t = *x;
    *x = *y;
    *y = t;
}

void QuickSortRecursive(int arr[], int start, int end)
{
    if (start >= end)
        return;

    int mid = arr[end]; // 数组最后一个元素为基准值pivot
    int left = start;   /*左边是开始*/
    int right = end - 1;

    /*利用双指针将小于基准值的元素放在左边，大于等于基准值的元素放在右边*/
    while (left < right) /*这个循环，通过左右两个指针，把小于mid的放mid左边，把大于mid的放mid右边*/
    {
        while (arr[left] < mid && left < right)
            left++;
        while (arr[right] >= mid && left < right)
            right--;
        /*当left和right都不满足比mid小和比mid大时，就交换数据*/

        swap(&arr[left], &arr[right]); /*左数和右数交换*/
    }                                  /*当两个指针重合了就不满足了*/

    /****到这里，一轮比较完成，对mid来说，左右都是有序的****/

    /************************************/

    /*处理将基准元素正确放置在排序后的位置（就是左或者右指针指向的位置），并更新左指针。*/
    /*经过双指针的比较和交换后，基准元素 mid 的位置已经被确定。
    而在这段代码中，它被放置在了数组的最右边，即 arr[end] 的位置。*/
    if (arr[left] >= arr[end])
        /*交换 arr[left] 和 arr[end] 的值，将基准元素放置到左指针的位置上。*/
        swap(&arr[left], &arr[end]);
    else
        left++;

    if (left)
        /*************************************/
        /*分别对基准元素的子表进行排序-->递归！！*/
        QuickSortRecursive(arr, start, left - 1);

    QuickSortRecursive(arr, left + 1, end);
}

void QuickSort(int arr[], int len)
{
    QuickSortRecursive(arr, 0, len - 1);
}

int main()
{
    // 需要归并排序的数组
    int arr[] = {1, 1, 4, 5, 1, 4, 19, 19, 810};
    // 传入数组arr的首地址进行排序
    QuickSort(arr, sizeof(arr) / sizeof(int));

    // 排序完成后顺序输出排序结束后的arr数组
    for (int i = 0; i < 9; i++)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}

方法2：

#include <stdio.h>

/*快排是通过递归方式实现的*/
 
/*Partition返回划分位置（左边那堆比返回值小，右边比找到并返回的值大）*/
int Partition(int arr[], int low, int high)
{
    int pivot = arr[low];
    while (low < high)
    {
        while (low < high && arr[high] >= pivot)
            high--;
        arr[low] = arr[high];
        while (low < high && arr[low] <= pivot)
            low++;
        arr[high] = arr[low];
    }

    arr[low] = pivot; /*或者a[high] = *pivot ,return high;*/
    return low;
}

void QuickSort(int arr[], int low, int high)
{
    if (low < high)
    {
        int pivotpos = Partition(arr, low, high); /*把排好序的中间值的数组下标赋值给pivotpos，
           简单来说就是找到子表的中间位置*/
        /*先整体排完左边，再排右边，每次partition完都能确定一个数放在靠近pivotpos的位置*/
        QuickSort(arr, low, pivotpos - 1);  /*对0  到  中间值（pivotpos-1） 那个序列进行排序*/
        QuickSort(arr, pivotpos + 1, high); /*对 中间值（pivotpos-1） 到0那个序列进行排序*/

        /*在递归中，变量的值是随着递归的进行而不断改变的。每次递归调用都会创建一个新的函数执行上下文，
        这些函数执行上下文中的变量是独立的，并且每个递归层级都有自己的变量副本。*/
    }
}

int main()
{
    // 需要归并排序的数组
    int arr[] = {1, 4,2, 5,    4, 19, 19, 51};
    // 传入数组arr的首地址进行排序
    QuickSort(arr, 0, (sizeof(arr) / sizeof(int)-1));

    // 排序完成后顺序输出排序结束后的arr数组
    for (int i = 0; i < (sizeof(arr) / sizeof(int)); i++)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}