快速排序

https://baike.baidu.com/item/%E5%BF%AB%E9%80%9F%E6%8E%92%E5%BA%8F%E7%AE%97%E6%B3%95/369842?fromtitle=%E5%BF%AB%E9%80%9F%E6%8E%92%E5%BA%8F&fromid=2084344&fr=aladdin

 

#include <iostream>
#include <vector>
 
using namespace std;
 
void Qsort(int a[], int low, int high)
{
    if(low >= high)
    {
        return;
    }
    int first = low;
    int last = high;
    int key = a[first];/*用字表的第一个记录作为枢轴*/
 
    while(first < last)
    {
        while(first < last && a[last] >= key)
        {
            --last;
        }
 
        a[first] = a[last];/*将比第一个小的移到低端*/
 
        while(first < last && a[first] <= key)
        {
            ++first;
        }
         
        a[last] = a[first];    
/*将比第一个大的移到高端*/
    }
    a[first] = key;/*枢轴记录到位*/
    Qsort(a, low, first-1);
    Qsort(a, first+1, high);
}

void QuickSort(int arr[], int left, int right)
{
    if(left >= right)
    {
        return;
    }
    
    int i = left;
    int j = right;
    
    int key = arr[left];
    
    while(i < j)
    {
        while(i < j && arr[j] >= key)
        {
            j--;
        }
        
        arr[i] = arr[j];
        
        while(i < j && arr[i] <= key)
        {
            i++;
        }
        
        arr[j] = arr[i];
    }
            
    arr[i] = key;

    QuickSort(arr, left, i - 1);
    QuickSort(arr, left + 1, right);
    
}

void sort(int arr[], int len)
{
    if(len <= 0)
    {
        return;
    }
    
    QuickSort(arr, 0, len - 1);
}

class Solution {
public:
    void QSort(vector<int> &array) {
        int len = array.size();
        if(len == 0)
        {
            return ;
        }
        
        quicksork(array, 0, len - 1);
    }
    
    
    void quicksork(vector<int> &array, int first, int last)
    {
        if(first >= last)
        {
            return;
        }
        
        int key = array[first];
        while(first < last)
        {
            while(first < last && key <= array[last])
            {
                last--;
            }
            
            array[first] = array[last];
            
            while(first < last && key >= array[first])
            {
                first++;
            }
            
            array[last] = array[first];
        }
        
        array[first] = key;
        
        quicksork(array, 0, first - 1);
        quicksork(array, first + 1, last);
    }
    
};

int main()
{
    int A[] = {5, 6, 2, 1, 4, 3};
    //Qsort(A, 0, 5);
    vector<int> vec;
    vec.push_back(5);
    vec.push_back(6);    
    vec.push_back(2);    
    vec.push_back(1);    
    vec.push_back(4);
    vec.push_back(3);    
    
    sort(A, 6);
    
    Solution so;
    so.QSort(vec);
    
    return 1;
}