图文详解快速排序

• 一、快排思路
• 二、相关代码
• 小细节改进
• • 版本一
  • 版本二

还记得之前的荷兰国旗问题吗（快排的前身：详解荷兰国旗问题），快排其实就是借助这种思路，在每次遍历中以第一个数作为目标数，将数组排为一个该数左边的数都比它小，右边的数都比它大的数的数组，换句话说通过一轮这样的操作就找到了该数在数组顺序后的位置，重复这样的操作n次我们就找了该数组中每一个数的位置完成了排序，具体思路看下图：

遍历一个数组使其左边都是比第一个数小的数，其右边都是比它大的数：

如果理解了这个过程，我们来再看一个总体的排序过程图解，具体如下：

使用具体的步骤描述这个过程：

思路：

1. 以数组中第一个元素为flag
   设置两个下标 i=1 ; j=n-1；

2. 移动j直至找到第一个比flag小的元素；
   然后移动i,直至找到第一个比flag大的数；

3. 如果此时i,j的值时合法的，则交换a[i], a[j]（合法的意思就是i 如果不合法，说明我们将数组中的元素遍历完毕了。

4. 比较flag和a[i]的值，如果flag>a[i]那么交换a[0]和a[i]的值，否则交换a[0]和a[i-1]的值。这样就找到了a[0]在该数组中排序后的位置。

5. 使用以上四个步骤分别遍历找到位置的元素(a[i]或a[i-1])的左边所有元素和右边所有元素的子数组。

6. 重复以上操作，直至找到所有元素的位置。

int partition(int* arr, int n) {
    int key = arr[0];
    int i=1;
    int j=n-1;
    while(i=j) break;
        while(iarr[i]) ++i;
        if(i>=j) break;

        SWAP(arr[i], arr[j]);
        ++i;
        --j;
    }

    if(key > arr[i]) {
        return i;
    }else {
        return i-1;
    }
}

void quick_sort(int* arr, int n) {
    if(n<=1) return;
    int p = partition2(arr, n);
    SWAP(arr[0], arr[p]);
    quick_sort(arr, p);
    quick_sort(arr+p+1, n-p-1);
}

由于我们在最初的版本里面设置了的i=1，两者在比较的过程中设置每次在交换之后，移动i, j，但这使得在返回下表的时候还要对flag和a[i]进行比较，但事实上，我们可以直接让两个下表自己跑，满足条件则交换，具体如下：

int partition1(int* arr, int n) {
    int key = arr[0];
    int i = 0, j = n-1;

    while(i < j) {
        while(i= arr[i])  ++i;
        SWAP(arr[i], arr[j]);
    }

    arr[i] = key;
    return i;

}
void quick_sort(int* arr, int n) {
    if(n<=1) return;
    int p = partition2(arr, n);
    quick_sort(arr, p);
    quick_sort(arr+p+1, n-p-1);
}

我们将数组中的第一个元素存在了key里面，那么此时arr[0]可以作为交换两个数的中间变量，具体实现如下：

int partition2(int* arr, int n) {
    int key = arr[0];
    int i=0, j=n-1;
    while(i < j) {
        while(i= arr[i]) ++i;
        arr[j] = arr[i];
    }
    arr[i] = key;
    return i;
}

void quick_sort(int* arr, int n) {
    if(n<=1) return;
    int p = partition2(arr, n);
    quick_sort(arr, p);
    quick_sort(arr+p+1, n-p-1);
}