对于快速排序算法的递归栈深度的一点改进

　　前几天有人问了我一个关于快速排序的问题。起因是严蔚敏版数据结构第277页的一句话：“如果改写算法10.7，在一趟排序之后比较分割所得两部分的长度，且先对长度短的子序列中的记录进行快速排序，则栈的最大深度可降为O(logn)。”（注：这里的logn是log2n的简写）。

　　因为对于原地排序而言，额外的空间复杂度应该是常数，但由于快速排序的实现一般是递归的方式，所以快速排序的额外空间复杂度不是常数，而是和递归深度相关。

　　回到一开始的问题上来，刚看到那句话还觉得奇怪，因为话里的栈的深度是指函数递归调用的深度，这个和处理两个子序列的顺序应该是无关的，除非还在递归方面有其它改进，例如回溯到上上级。顺着这个思路来想，觉得改进栈的最大深度是有可能的。

　　这个改进的主要思想应该是：用没处理的子节点代替父节点，以减少栈的深度。

　　假设父节点A，子节点B、C。处理完B后，并不直接处理C而是回溯回A，并把C交到A这一级来处理。通过这种方法的确可以将栈的最大深度降到O(logn)。详细的数学证明就不写了。

　　下面是具体的实现代码。代码里把两种快速排序都列出来了，以方便对比。实验结果也证实是在递归深度是在logn以内。

/***
*对于快速排序递归函数栈的深度的改进
*author：Allen
*date：2012-11-01
*说明：
*由于只是简单实现算法，对于代码风格没太在意。
*原快速排序算法的代码是从网上找的，并做了一点修改。
*/
#include <iostream>
#include<ctime>
using namespace std;
const int a_size = 128;//带排序数列长度
int a[a_size];
void swap(int *pLeft,int *pRight)
{
    int temp;
    temp = *pLeft;
    *pLeft= *pRight;
    *pRight = temp;
}
//原快速排序
void qs(int begin,int end)
{
    static int deep = 0;//递归深度
    static int allnum =0;//函数调用总次数
    static int mostDeep = 0;//最大递归深度
    ++allnum;
    ++deep;
    if(deep>mostDeep){
        mostDeep=deep;
    }
    int compare=a[begin], left =begin,right = end;
    if(abs(right-left)<=1)
    {
        --deep;
        if(left<right && a[left]>a[right]){
            swap(a[right],a[left]);
        }
        return;
    }
    while (left <right)
    {
        while ((left <right) && a[right]>=compare)
            right--;
        swap(a[left],a[right]);
        while ((left <right) &&(a[left] <compare))
            left++;
        swap(a[right],a[left]);
    }
    a[right] = compare;
    qs(begin,right-1);
    qs(right+1,end);
    --deep;
    if(deep<=0){
        cout<<"函数调用总次数:"<<allnum<<endl;
        cout<<"最大递归深度数:"<<mostDeep<<endl;
    }
}
//改进快排，每次递归函数中还剩一组未排序列，即回溯到上级。
//优先排短的序列
//递归函数参数表里还要保留两个未排序列的参数，返回给上级递归处理
//可以认为是下级递归函数（B）完成一半原来任务（C）后，即将自身的函数栈释放，将另一半任务（D）仍交给上级函数（A）
//由此另一半任务(D)执行时，所使用的函数栈深度和下级递归函数(B)的深度是一样的都是上级函数（A）+1
//但是要注意顶级部分的函数仍然要处理掉C、D两个任务。
void qs(int p_begin,int p_end,int &p_unBegin,int &p_unEnd)
{
    static int deep = 0;//递归深度
    static int allnum =0;//函数调用总次数
    static int mostDeep = 0;//最大递归深度
    ++allnum;
    ++deep;
    if(deep>mostDeep){
        mostDeep=deep;
    }
    //    cout<<"递归深度:"<<deep << ' ' <<p_begin <<' ' <<p_end<<' ' <<p_unBegin<<' ' <<p_unEnd<<' ' <<endl;
    int compare=a[p_begin], left =p_begin,right = p_end;
    if(abs(right-left)<=1)
    {
        --deep;
        if(left<right && a[left]>a[right]){
            swap(a[right],a[left]);
        }
        p_unBegin=-1;
        p_unEnd=-1;
        return;
    }
    while (left <right)
    {
        while ((left <right) && a[right]>=compare)
            --right;
        
        swap(a[left],a[right]);
        while ((left <right) &&(a[left] <compare))
            ++left;
        
        swap(a[right],a[left]);
    }
    a[right] = compare;
    
    int newBegin;
    int newEnd;
    int unBegin=p_begin;
    int unEnd=p_end;
    
    if( (right-1)-p_begin <= p_end-(right+1) ){
        newBegin=p_begin;
        newEnd=right-1;
        p_unBegin=right+1;
        p_unEnd=p_end;
        qs(newBegin,newEnd,unBegin,unEnd);
        while(unBegin!=-1&&unEnd!=-1){
            qs(unBegin,unEnd,unBegin,unEnd);
        }
        if(deep>1){
            --deep;
            return;
        }
    }else{
        p_unBegin=p_begin;
        p_unEnd=right-1;
        newBegin=right+1;
        newEnd=p_end;
        qs(newBegin,newEnd,unBegin,unEnd);
        while(unBegin!=-1&&unEnd!=-1){
            qs(unBegin,unEnd,unBegin,unEnd);
        }    
        if(deep>1){
            --deep;
            return;
        }
    }        
    //另一部分
    qs(p_unBegin,p_unEnd,unBegin,unEnd);
    while(unBegin!=-1&&unEnd!=-1){
        qs(unBegin,unEnd,unBegin,unEnd);
    }
    --deep;
    if(deep<=0){
        cout<<"函数调用总次数:"<<allnum<<endl;
        cout<<"最大递归深度数:"<<mostDeep<<endl;
    }    
}

void printArray(const int * p_arr,const int size){
    for (int i=0;i<size;i++)
    {
//        cout<<"array["<<i<<"] = "<<p_arr[i]<< ' ';
        cout<< p_arr[i]<< ' ';
    }
    cout<<endl;
}

int main()
{    
    int i=0;
    srand(time(0));
    int b[a_size];//原数列数组
    for (i =0;i< a_size;i++)
    {
        b[i] =rand()%a_size;
        //    b[i] =a_size-i;
        //    b[i] =i;
    }
    cout<<"排序前"<<endl;
    printArray(b,a_size);
    for (i= 0;i<a_size;i++)
    {
        a[i]=b[i];
    }
    cout<<"原来的排序后"<<endl;
    qs(0,a_size-1);
    printArray(a,a_size);
    //下面为改进的
    for (i= 0;i<a_size;i++)
    {
        a[i]=b[i];
    }
    cout<<"改进的排序后"<<endl;
    int st=0;
    int en=a_size-1;
    qs(0,a_size-1,st,en);
    printArray(a,a_size);
    system("pause");
    return 0;
}

　　另外今天是万圣节。