快排，歸併排序遞歸和非遞歸寫法

前幾天面試，問道快排非遞歸，我說我不會！！！！
我太菜了，面試題都不會。
比賽一直用sort，屢試不爽，所以排序算法的代碼很生疏！
！！快排分區間的時候很容易寫錯，最好能記住它的寫作格式
遞歸版的：

void qsort(int l,int r)
{
    if(l>=r)return ;
    int L=l,R=r;
    int k=a[l];

    while(l<r)
    {
       while(l<r&&a[r]>=k)r--;
       a[l]=a[r];
       while(l<r&&a[l]<=k)l++;
       a[r]=a[l];
    }
    a[l]=k;
    qsort(L,l-1);
    qsort(l+1,R);
}

然後非遞歸的用棧模擬遞歸過程可以達到跟遞歸一樣的效果。
遞歸的時候是兩個參數，所以棧裏面也是兩個參數（左區間和右區間）
其實寫法跟用隊列實現廣搜一模一樣，擦，沒想到這麼簡單！
原因：
快排是相當於先序遍歷的，所以它用棧很容易模擬出來。像後續遍歷這種遞歸改成棧就沒那麼容易了，但是有其他方法的

stack<int>st;
void _qsort(int n)
{
    st.push(0);
    st.push(n-1);
    while(!st.empty())
    {
        int R=st.top();
        st.pop();
        int L=st.top();
        st.pop();
        if(R<=L)continue;
        int k=a[L],l=L,r=R;
        while(l<r)
        {
            while(l<r&&a[r]>=k)r--;
            a[l]=a[r];
            while(l<r&&a[l]<=k)l++;
            a[r]=a[l];
        }
        a[l]=k;
        st.push(l+1);st.push(R);
        st.push(L);st.push(l-1);
    }
}

歸併排序：

首先寫一個歸併函數：Merge

int temp[100];
void Merge(int l,int mid,int r)
{
    int p1=l,p2=mid+1,k=0;
    while(p1<=mid&&p2<=r)
    {
        temp[k++]=a[p1]<a[p2]?a[p1++]:a[p2++];
    }
    while(p1<=mid)
        temp[k++]=a[p1++];
    while(p2<=r)
        temp[k++]=a[p2++];
    for(int i=l; i<=r; i++)
        a[i]=temp[i-l];
}

接下來是遞歸版的歸併：

void mergesort(int l,int r)
{
    if(l==r)
        return;
    int mid=(l+r)/2;
    mergesort(l,mid);
    mergesort(mid+1,r);
    Merge(l,mid,r);
}

思路清晰瞭然

接下來看下非遞歸的怎麼搞
從歸併算法中可以發現第一趟是1個1個數歸併，第二趟是2個2個一起，第i趟是2^（i-1）個 一起歸併。所以直接自底向上枚舉每次歸併的長度就可以了
這樣就可以不用棧來模擬遞歸了！

void _mergesort(int n)
{
    int len=1;
    while(len<n)
    {
        len*=2;
        for(int i=0; i<n; i+=len)
        Merge(i,i+len/2-1,min(i+len,n)-1);
        
    }
}

注意：這種枚舉方法跟遞歸版的計算順序不一樣。
如果把每次劃分看成二叉樹的兩個分叉，那麼
遞歸版的計算順序可以說是後續遍歷的深度優先，非遞歸版的計算順序是從葉子結點開始的廣度優先！