【常用排序算法】以最简单的方式理解快速排序

本小白觉得快速排序是最难理解的排序算法，特别是程序代码的实现，花了两个小时终于给看懂了…

思想分析：

首先是设定了一个基准pivot，默认是第一个或者最后一个，（假设是第一个数）然后和后面的数进行比较，要是大于基准，就在原地不变，要是小于基准，就放在基准后面，按照比较顺序将后面小于基准的数字逐一排列，等遍历了一轮之后会发现，局势演变成了：基准【小于基准】【小于基准的最后一个元素】【大于基准】这样的结构，还没完，然后把基准和小于基准的最后一个元素交换位置，这样就完成了一轮。

可以看到，每一轮都是完成基准的归位，等所有的数被当成基准归位之后，这个数串就是正序的了。

程序分析：

这里是以最后一个元素作为基准，形成【小于基准】【大于基准】基准，这样的结构。

代码实现：

#include <stdio.h>

// 分类 ------------ 内部比较排序
// 数据结构 --------- 数组
// 最差时间复杂度 ---- 每次选取的基准都是最大（或最小）的元素，导致每次只划分出了一个分区，需要进行n-1次划分才能结束递归，时间复杂度为O(n^2)
// 最优时间复杂度 ---- 每次选取的基准都是中位数，这样每次都均匀的划分出两个分区，只需要logn次划分就能结束递归，时间复杂度为O(nlogn)
// 平均时间复杂度 ---- O(nlogn)
// 所需辅助空间 ------ 主要是递归造成的栈空间的使用(用来保存left和right等局部变量)，取决于递归树的深度，一般为O(logn)，最差为O(n)       
// 稳定性 ---------- 不稳定

void Swap(int A[], int i, int j)
{
    int temp = A[i];
    A[i] = A[j];
    A[j] = temp;
}

int Partition(int A[], int left, int right)  // 划分函数
{
    int pivot = A[right];               // 这里每次都选择最后一个元素作为基准
    int tail = left - 1;    //最开始tail的值是-1，tail为小于基准的子数组最后一个元素的索引
    for (int i = left; i < right; i++)  // 遍历基准以外的其他元素
    {
        if (A[i] <= pivot)              // 把小于等于基准的元素放到前一个子数组末尾
        {
            Swap(A, ++tail, i);
        }
    }
    Swap(A, tail + 1, right);           // 最后把基准放到前一个子数组的后边，剩下的子数组既是大于基准的子数组
                                        // 该操作很有可能把后面元素的稳定性打乱，所以快速排序是不稳定的排序算法
    return tail + 1;                    // 返回基准的索引
}

void QuickSort(int A[], int left, int right)
{
    if (left >= right)
        return;
    int pivot_index = Partition(A, left, right); // 基准的索引
    QuickSort(A, left, pivot_index - 1);
    QuickSort(A, pivot_index + 1, right);
}//每一轮都是完成对基准的归位，基准把数字分成两部分，分别用递归实现

int main()
{
    int A[] = { 5, 2, 9, 4, 7, 6, 1, 3, 8 }; // 从小到大快速排序
    int n = sizeof(A) / sizeof(int);
    QuickSort(A, 0, n - 1);
    printf("快速排序结果：");
    for (int i = 0; i < n; i++)
    {
        printf("%d ", A[i]);
    }
    printf("\n");
    return 0;
}

上面那个代码比较难理解，但是符合我所分析的。
然后贴一个容易理解的，另一种思考方式：

思想分析：

设置两个哨兵，一个基准，假设把第一个元素当做基准，然后一个哨兵j从右边开始寻找比基准大的，另一个哨兵i从左边开始寻找比基准小的，直到两个哨兵相遇。这里要注意一点，从右向左找比基准大的哨兵j一定要先行动，有两点：1.因为到最后相遇的时候所在的元素比基准大，那么它待在原地不动，遇到哨兵i的时候就退出循环，假如是i先行动，交换了之后就已经完成布局，i就位于比基准大的模块；2.假如是比基准小的，那么后面就会直接和基准实现交换。

    #include <stdio.h> 
    int a[101],n;//定义全局变量，这两个变量需要在子函数中使用 
    void quicksort(int left,int right) 
    { 
        int i,j,t,temp; 
        if(left>right) 
           return; 

        temp=a[left]; //temp中存的就是基准数 
        i=left; 
        j=right; 
        while(i!=j) 
        { 
                       //顺序很重要，要先从右边开始找 
                       while(a[j]>=temp && i<j) 
                                j--; 
                       //再找右边的 
                       while(a[i]<=temp && i<j) 
                                i++; 
                       //交换两个数在数组中的位置 
                       if(i<j) 
                       { 
                                t=a[i]; 
                                a[i]=a[j]; 
                                a[j]=t; 
                       } 
        } 
        //最终将基准数归位 
        a[left]=a[i]; 
        a[i]=temp; 

        quicksort(left,i-1);//继续处理左边的，这里是一个递归的过程 
        quicksort(i+1,right);//继续处理右边的 ，这里是一个递归的过程 
    } 
    int main() 
    { 
        int i,j,t; 
        //读入数据 
        scanf("%d",&n); 
        for(i=1;i<=n;i++) 
                       scanf("%d",&a[i]); 
        quicksort(1,n); //快速排序调用 

        //输出排序后的结果 
        for(i=1;i<=n;i++) 
            printf("%d ",a[i]); 
        getchar();getchar(); 
        return 0; 
    }