快速排序递归与非递归实现

算法概述：

分而治之。

选出一个元素作为主元，它可以把集合中的元素分成两部分，一部分都是大于它的，一部分都小于它的。

我们先用伪代码描述。

void QuickSort(ElementType A[],int N){   //如果只剩一个元素了直接返回   if(N<2) return;   pivot=从A[]选出一个主元;   将S={ A[]\pivot }分成两个独立的子集;     A1={ a∈S | a≤ pivot }和A2={ a∈S | a≥ pivot};   A[]=QuickSort(A1,N1)∪ pivot ∪ QuickSort(A2,N2);}

选主元

选主元一定要慎重。如果是下面这种情况
共有5个元素，1 2 3 4 5
选1作为主元那么比1小的为空，比1大的有4个。这样进行的快排是一点也不快的。
取头，中，尾的三个元素比较，选出中间大小的元素作为主元

ElementType Median(ElementType A[],int left, int right){   int center=(left+right)/2;   if(A[left]>A[center])   {       Swap(&A[left],&A[center]);   }   if(A[left]>A[right])   {      Swap(&A[left],&A[right]);   }   if(A[center]>A[right])   {      Swap(&A[center],&A[right]);   }   //将pivot放到right-1的位置，我们知道A[left]肯定小于主元A[right]肯定大于主元   //只需要考虑A[left+1]~A[right-2]   Swap(&A[center],&A[right-1]);   return A[right-1];}

子集划分

6是主元，被放在最右端。

当i对应的元素大于主元，j对应的元素小于主元，停下来，进行交换

当i>j时，停止交换。并把主元与i位置元素交换。选出来的主元，在完成一次子集划分后，主元会被放到最终应在的位置。

小规模数据的处理

因为使用了递归，对于小规模的数据，可能快排还没有如插入排序的简单排序快。
所以我们可以设定一个阈值Cutoff，当递归时的数据规模足够小，我们就停止递归了，直接调用简单排序。

递归

代码：

#include<iostream>#include<stdio.h>#include<stdlib.h>#include<string.h>#include<algorithm>using namespace std;int median(int* arr, int left, int right){    int center = (left + right) / 2;    if (arr[left] > arr[center]){        swap(arr[left],arr[center]);    }    if (arr[left] > arr[right]){        swap(arr[left],arr[right]);    }    if (arr[center] > arr[right]){        swap(arr[center],arr[right]);    }    swap(arr[center],arr[right-1]);    return arr[right - 1];}void insertSort(int* arr,int n){    int tmp;    for (int i = 1; i < n; i++){        tmp = arr[i];        int j;        for (j = i; j>0 && arr[j - 1] > tmp; j--){            arr[j] = arr[j - 1];        }        arr[j] = tmp;    }}int cutoff = 5;void quickSort(int* arr,int left,int right){    if (cutoff <= (right - left)){        int pivot = median(arr,left,right);        int i = left;        int j = right - 1;        while (1){            while (arr[++i] < pivot){            }            while (arr[--j]>pivot){            }            if (i < j){                swap(arr[i],arr[j]);            }            else{                break;            }        }        swap(arr[i],arr[right-1]);        quickSort(arr,left,i-1);        quickSort(arr,i+1,right);    }    else{        insertSort(arr+left,right-left+1);    }}int main(){    int arr[20] = {20,19,18,10,17,16,15,14,13,9,5,6,7,8,1,2,3,11,4,12};    quickSort(arr,0,19);    system("pause");    return 0;}

非递归，手动利用栈来存储每次分块时快排的起始点。这种写法的执行效率低于递归算法。

#include<iostream>#include<stdio.h>#include<stdlib.h>#include<algorithm>#include<stack>using namespace std;struct Node{    int low;    int high;};//存放待排子列的区间void insertSort(int* arr, int n){    int tmp;    for (int i = 1; i<n; i++){        tmp = arr[i];        int j;        for (j = i; j>0 && arr[j - 1] >= tmp; j--){            arr[j] = arr[j - 1];        }        arr[j] = tmp;    }}int median(int* arr, int left, int right){    int center = (left + right) / 2;    if (arr[left] > arr[center]){        swap(arr[left],arr[center]);    }    if (arr[left] > arr[right]){        swap(arr[left],arr[right]);    }    if (arr[center] > arr[right]){        swap(arr[center],arr[right]);    }    swap(arr[center],arr[right-1]);    return arr[right - 1];}int partition(int* arr,int left,int right){    int pivot = median(arr,left,right);    int i = left;    int j = right - 1;    while (i<j){        while (arr[++i] < pivot){}        while (arr[--j] > pivot){}        if (i < j){            swap(arr[i],arr[j]);        }        else{            break;        }    }    swap(arr[i],arr[right-1]);    return i;}void quickSort(int* arr,int left,int right){    stack<Node> s;    int pivot;    Node node;    node.low = left;    node.high = right;    s.push(node);    while (!s.empty()){        node = s.top();        s.pop();        pivot = partition(arr,node.low,node.high);        if (pivot - 1 > node.low){            Node node1;            node1.low = node.low;            node1.high = pivot - 1;            s.push(node1);        }        if (pivot + 1 < node.high){            Node node2;            node2.low = pivot + 1;            node2.high = node.high;            s.push(node2);        }    }}int main(){    int arr[20] = { 20, 19, 18, 10, 17, 16, 15, 14, 13, 9, 5, 6, 7, 8, 1, 2, 3, 11, 4, 12 };    quickSort(arr, 0, 19);    system("pause");    return 0;}