经典算法之快速排序

适用场景：

子问题与原问题性质相同

子问题相互独立(区别于动态规划)

经典案例一：二分查找

基本思想：前提是给定一个有序数组，然后进行二分查找。

经典案例二：快速排序

基本思想：

1. 选择一个基准元素pivot(第一个元素)
2. 两个指针front/rear，分别指向开头和末尾
3. 移动rear查找第一次出现小于基准元素pivot的值
   移动front查找第一次出现大于基准元素pivot的值
   
4. 调换两元素值，继续挪动指针,目的旨在让最后重叠的指针左半部分全部小于基准元素pivot，有半部分全部大于基准元素pivot
   直到front==rear
   
5. 把当前指针所在的元素与pivot元素对调，使得左半部分全部小于基准元素pivot，有半部分全部大于基准元素pivot
   
6. 此时根据分治算法的思想，数组分成了[2, 3, 1] 和 [6, 7, 5, 8] 两部分，然后再次递归排序即可
   

代码实现

/*
    快排: 找到index后，快排转化成了分治算法
    1. 先找到中间索引 index
    2. quickSort(Array, 0, index - 1);
    3. quickSort(Array, index + 1, end)
*/
#include <stdio.h>
#include <stdlib.h>

int arr[] = {4,7,6,5,3,2,8,1};

int GetIndex(int* arr, int low, int hight) {
    int pivot = low;
    int front = low;
    int rear = hight;
    int tmp=0;
    while (front != rear)
    {
        if(arr[rear] > arr[pivot] ) {
            rear--;
        }
        else {
            if(arr[front] < arr[pivot]) {
                front++;
            }
            else {
                tmp = arr[front];
                arr[front] = arr[rear];
                arr[rear] = tmp;
                rear--;
            }
        }   
    }
    
    tmp = arr[pivot];
    arr[pivot] = arr[front];
    arr[front] = tmp;
    return front;
}

void quickSort(int* arr, int low, int hight) {
    if(low> hight) {
        return;
    }
    int index = GetIndex(arr, low, hight);
    quickSort(arr, low, index - 1);
    quickSort(arr, index + 1, hight);
}

int main() {
    quickSort(arr, 0, sizeof(arr)/sizeof(arr[0]) -1);
    for (int i = 0; i < sizeof(arr)/sizeof(arr[0]); ++i) {
        printf("%d\t",arr[i]);
    }
    printf("\n");
}

易犯错误

移动指针的时候，需先移动rear，后移动front。不然会造成数组中的部分元素顺序错误。

上图所示，如果先移动front，那么在最后交换pivot值的时候，6和4进行交换，那么此时的左半部分数组值就不全是小于pivot 4，所以不能先挪动front指针