快速排序

大致思路是选择一个pivot元素， 然后比它的排在其右边，小的排左边。 

一般需要两个下标标记。

5 6 7 1 3 2   5 ：选择5为pivot。

                   i/big

5 6 7 1 3   2    5:

               i/big

5  6   7   1   3     2     5

         i                big          //swap(i, big)

5 6    2    1   3     7    5  

    i              big

5  3   2   1    6     7     5

              big                //swap(big, pivot)

1   3   2   5   6    7      5

               pivot         //最后递归

if(a[i] >= pivot)    if(i!=big) swap(arr[i], arr[big]); big--;

代码如下：

#include <iostream>
#include <vector>
using namespace std;
void swap(int &a, int &b)
{
    int tmp = a;
    a = b;
    b = tmp;

}

int sort(vector<int> &arr, int start, int end)
{
    int pivot = arr[start];
    int big = end;
    for(int i = end; i > start; i--)
    {
        cout << arr[i] << ",";
        if(arr[i]>= pivot) {
            if(big != i) {
                swap(arr[i], arr[big]);
            }
            big--;
        }
    }
    swap(arr[start], arr[big]);
    return big;
}


void quicksort(vector<int> &arr, int start, int end)
{
    //cout << ""
    if(start < end){
        int mid = sort(arr, start, end);
        cout << "mid:" << mid << endl;
        quicksort(arr, start, mid-1);
        quicksort(arr, mid+1, end);
    }
}

int main()
{
    vector<int> a{1,0,0,1,1,0,0,1,1};
    quicksort(a, 0, 8);
    for(int i = 0; i < 9; i++)
    cout << a[i] << ",";

}

第二种方法是两边设置快慢指针，如果左边指针元素大于pivot且右边小于pivot，两者调换，

但是判断边界条件的时候容易出错。

#include <vector>
#include <iostream>
using namespace std;
void swap(int &a, int &b)
{
    int tmp = a;
    a = b;
    b = tmp;
}

void quicksort(vector<int>&arr, int start, int end)
{
    if(start < end){
    int pivot = arr[start];
    int i = start+1;
    int j = end;
    while(i < j) {
        if(i < j && arr[i]<= pivot) {
            i++;
        }
        if(i < j && arr[j] > pivot) {
            j--;
        }
        if(i < j&& arr[i] > pivot && arr[j] <= pivot)
        {
            swap(arr[i], arr[j]);
            i++;
            j--;
            for(int i = 0; i < arr.size(); i++){
                cout << arr[i] << ",";
            }
            cout << endl;
        }
    }
//判断边界条件
    if(i == j) {
        if(arr[i] <= pivot) {
            swap(arr[i], arr[start]);
            quicksort(arr, start, i-1);
            quicksort(arr, i+1, end);
            
        } else {
            swap(arr[i-1], arr[start]);
            quicksort(arr, start, i-2);
            quicksort(arr, i, end);
        }
    } else {
        swap(arr[j], arr[start]);
        quicksort(arr, start, j-1);
        quicksort(arr, j+1, end);
    }        
    }

}