快速排序－QuickSort

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

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

分治模型在每一层递归上都有三个步骤：

－分解（Divide)：将原问题分解成一系列子问题。

－解决(Conquer)：递归的解各个子问题。若子问题足够小，则直接求解。

－合并(Combine)：将子问题的结果合并成原问题的解。

快速排序的递归方法：

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

int partition(vector<int> &vec,int low,int high){
int comp=vec[low];
while(low<high){
while(low<high && vec[high] >= comp){
high--;
}
vec[low]=vec[high];
while(low<high && vec[low] <= comp){
low++;
}
vec[high]=vec[low];
}
vec[low]=comp;
return 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(low<high){
st.push(low);
st.push(high);
}
while(!st.empty()){
h = st.top();
st.pop();
l = st.top();
st.pop();
middle = patition(vec, l, h);
if(l<middle-1){
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(low<high) {
mid = partition(a, low, high);
if(low < mid-1){
s[p++] = low;
s[p++] = mid -1;
}
if(mid+1 < high){
s[p++] = mid+1;
s[p++] = high;
}
}
}
delete []s;

}