快速排序－QuickSort

快速排序主要应用了分治的思想。

分治算法也叫分治策略，把输入分为若干个部分，递归的解每一个问题，最后将这些子问题合并成为一个全局解

分治模型在每一层递归上都有三个步骤：
－分解（Divide)：将原问题分解成一系列子问题。
－解决(Conquer)：递归的解各个子问题。若子问题足够小，则直接求解。
－合并(Combine)：将子问题的结果合并成原问题的解。

快速排序的递归方法：

//分治的解决部分:partition函数

int partition(vector<int> &vec,int low,int high){
    int comp=vec[low];
    while(lowwhile(low= comp){
            high--;
        }
        vec[low]=vec[high];
        while(lowreturn low;
}

//分治的分解和合并：quickSort递归调用

void quickSort(vector<int> &vec,int low,int high){
    if(low < high) {
        int middle = partition(vec, low, high);
        quickSort(vec, low, middle - 1);
        quickSort(vec, middle + 1, high);
    }
}

快速排序的非递归方法：

//partition函数不变
……

//quickSort变成非递归
方法一、用栈模拟递归

void quickSort(vector<int> &vec,int low,int high){
    stack<int> st;
    int middle,l,h;
    if(lowwhile(!st.empty()){
        h = st.top();
        st.pop();
        l = st.top();
        st.pop();
        middle = patition(vec, l, h);
        if(l1){
            st.push(l);
            st.push(middle-1);
        }
        if(middle+1 < h){
            st.push(middle+1);
            st.push(h);
        }
    }
}

方法二、用数组模拟栈，从而实现递归

void quickSort(int *a, int l, int h){
    if (l>=h)
        return;

    int *s = new int[h-l+1];     //实现栈够用，因为存储的l,h索引在数组a的长度以内
    int p = 0;
    s[p++] = l;
    s[p++] = h;

    int low,high,mid;
    while (p>0){
        high = s[--p];
        low = s[--p];
        if(lowif(low < mid-1){
                s[p++] = low;
                s[p++] = mid -1;
            }
            if(mid+1 < high){
                s[p++] = mid+1;
                s[p++] = high;
            }
        }
    }
    delete []s;

}