笔记-快速排序递归和非递归的写法-CSDN博客

本文链接：https://blog.csdn.net/zr1996106/article/details/125589091

快排属于分治算法，分治算法都有三步：

分成子问题
递归处理子问题
子问题合并

快排递归模板1：

void quickSort(int q[], int l, int r)
{
    if(l >= r) return; //递归终止情况：L>R越界了退出,L==R表示只有一个数不需要排序
    //第一步：分成子问题
    int i = l - 1, j = r + 1; 
//i和j指向边界的二层即i=l-1,j=r+1,因为下面是先加i和减j在进行和划分值的判断
     int x = arr[L+(R-L+1)/2]; 
//取中点时候:L+(R-L)/2对，而L+(R-L+1)/2错
    // int x = arr[L+rand()%(R-L+1)]; 
//用rand时候:L+rand()%(R-L)和L+rand()%(R-L+1)都可以
    while(i < j)
    {
        while(q[++i]<x); //二个比较如果写成<= >=报段错误
        while(q[--j]>x);
        if(i < j) swap(q[i], q[j]);
    }
    //第二步：递归处理子问题
    quickSort(q, l, j);  //推荐写成j，如果换成i那就要换三次看下面
    quickSort(q, j+ 1, r);
    //第三步：子问题合并.快排这一步不需要操作，但归并排序的核心在这一步骤
//计算x时：x = q[1+l+(r-l)/2];+1表向上取整，不能取到l的边界，二个数出现死循环如1，2
    //quickSort(q,l,i-1);
    //quickSort(q,i,r);
} 
while循环结束后，q[l..j] <= x,q[j+1..r] >= x
注:q[l..j] <= x意为q[l],q[l+1]...q[j-1],q[j]的所有元素都<= x

快速排序递归模板2：

using  namespace  std;
const int N = 1e5+10;
int n;
int arr[N];
int partition(int *arr,int L,int R){
    int i = L,j  = R;
    int temp = arr[R]; //用数组最后一个位置的元素当作划分值
    if(L<R){
        while (i<j){
            while (i<j &&arr[i] <temp) ++i;
            if(i<j){
                arr[j] = arr[i];
                --j;
            }
            while (i<j  && arr[j] > temp) --j;
            if(i<j){
                arr[i] = arr[j];
                ++i;
            }
        }
    } //循环退出时候i==j,这个位置就是temp应该放的位置，左边小于等于划分值，右边大于等于划分值
    arr[i] = temp;
    return  i;
}
int randomPartition(int *arr,int L,int R){
    int i = L + rand()%(R-L);
    swap(arr[i],arr[R]);
    //在L和R中随机选择一个位置，将这个位置的元素和最后一个位置元素交换
    partition(arr,L,R);
}
void quickSort(int *arr,int L,int R){
    if(L>=R){
        return;
    }
    int pivot = randomPartition(arr,L,R); //选出轴点
    quickSort(arr,L,pivot-1);//对轴点左边进行随机快速排序
    quickSort(arr,pivot+1,R);//对轴点右边进行随机快速排序
}
int main(){
    ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    cin>>n;
    for(int i = 0;i<n;++i){
        cin>>arr[i];
    }
    quickSort(arr,0,n-1);
    for(int i = 0;i<n;++i){
        cout<<arr[i]<<" ";
    }
    return  0;
}

快速排序递归模板3：

如果数组中有很多重复的元素，那么可以选择这个版本，对于重复元素处理为一个等于区域，然后再等于区的左边进行快速排序，右边进行快速排序，提高了效率；

using  namespace  std;
const int N = 1e5+10;
int n;
int arr[N];
//partition函数:用arr[R]做划分值，小于划分值的放到左边，等于划分值的在中间，大于划分值的在右边
std::pair<int,int> partition(int *arr,int L,int R){
    //返回等于区:开始位置和结束位置构成的pair
    if(L>R) return std::make_pair(-1,-1); //不是有效范围
    if(L==R) return std::make_pair(L,L);
    int lessR = L-1,moreL = R,index = L;
    //arr[R]当作划分值,从L开始遍历
    //lessR是小于区右边界的前一个位置，moreL是大于区左边界的后一个位置
    while (index < moreL){//对L到R-1位置上的元素进行划分，R位置元素是划分值;当前位置index不能和大于区左边界撞上
        if(arr[index] < arr[R]){
            //1)当前位置元素小于划分值，当前位置元素和lessR下一个位置元素交换，小于区右移动一个位置，当前位置跳下一个
            swap(arr[index++],arr[++lessR]);
        }else if(arr[index] > arr[R]){
            //2)当前位置元素大于划分值，当前位置元素和moreL前一个位置元素交换，当前位置不变(因为后面的数交换到当前位置来了，而那个数字没有判断)
            swap(arr[index],arr[--moreL]);
        }else {
            ++index; //3)当前位置元素等于划分值，那么当前位置直接跳下一个
        }
    }
    //最后将划分值arr[R]放到中间位置，这里选择放到大于区的前面
    swap(arr[moreL],arr[R]); //将划分值和大于区第一个元素交换，那么moreL位置就变成等于区的结束位置了
    return  std::make_pair(lessR+1,moreL); //返回等于区左边界和右边界
}
void quickSort(int *arr,int L,int R){//对有很多重复元素的数组来说，这个划分操作省去了很多判断，因此这个快速排序效率高点
    if(L>=R){ return; }
    swap(arr[L+rand()%(R-L)],arr[R]);
    std::pair<int,int> p = partition(arr,L,R);
    quickSort(arr,L,p.first-1);
    quickSort(arr,p.second+1,R);
}
int main(){
    ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    cin>>n;
    for(int i = 0;i<n;++i){
        cin>>arr[i];
    }
    quickSort(arr,0,n-1);
    for(int i = 0;i<n;++i){
        cout<<arr[i]<<" ";
    }
    return  0;
}

快速排序非递归写法：

非递归就是我们手写栈来模拟系统栈，这里的partition操作还是调用上面的模板3：

using  namespace  std;
const int N = 1e5+10;
int n;
int arr[N];
//partition函数:用arr[R]做划分值，小于划分值的放到左边，等于划分值的在中间，大于划分值的在右边
std::pair<int,int> partition(int *arr,int L,int R){
    //返回等于区:开始位置和结束位置构成的pair
    if(L>=R) return std::make_pair(L,L);
    int lessR = L-1,moreL = R,index = L;
    //arr[R]当作划分值,从L开始遍历
    //lessR是小于区右边界的前一个位置，moreL是大于区左边界的后一个位置
    while (index < moreL){//对L到R-1位置上的元素进行划分，R位置元素是划分值;当前位置index不能和大于区左边界撞上
        if(arr[index] < arr[R]){
            //1)当前位置元素小于划分值，当前位置元素和lessR下一个位置元素交换，小于区右移动一个位置，当前位置跳下一个
            swap(arr[index++],arr[++lessR]);
        }else if(arr[index] > arr[R]){
            //2)当前位置元素大于划分值，当前位置元素和moreL前一个位置元素交换，当前位置不变(因为后面的数交换到当前位置来了，而那个数字没有判断)
            swap(arr[index],arr[--moreL]);
        }else {
            ++index; //3)当前位置元素等于划分值，那么当前位置直接跳下一个
        }
    }
    //最后将划分值arr[R]放到中间位置，这里选择放到大于区的前面
    swap(arr[moreL],arr[R]); //将划分值和大于区第一个元素交换，那么moreL位置就变成等于区的结束位置了
    return  std::make_pair(lessR+1,moreL); //返回等于区左边界和右边界
}
void quickSort(int *arr,int L,int R){
    if(L>=R) return;
    stack<int> s;
    swap(arr[L+rand()%(R-L)],arr[R]);
    //在L到R范围上随机一个位置元素和最后一个位置元素交换(因为partition是用最后一个位置元素做划分值的)
    std::pair<int,int> p = partition(arr,L,R); //partiton返回等于区的左边界和右边界
    s.push(L);s.push(p.first-1);//左范围进栈
    s.push(p.second-1);s.push(R);//右范围进栈
    while (!s.empty()){
        int r = s.top();s.pop();
        int l = s.top();s.pop();
        //出栈一个范围
        if(l<r){//如果l<r才继续进行
            swap(arr[l+rand()%(r-l)],arr[r]);//不要忘记对l..r范围随机选择划分值
            p = partition(arr,l,r);
            s.push(l);s.push(p.first-1);
            s.push(p.second+1);s.push(r);
        }
    }

}
int main(){
    ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    cin>>n;
    for(int i = 0;i<n;++i){
        cin>>arr[i];
    }
    quickSort(arr,0,n-1);
    for(int i = 0;i<n;++i){
        cout<<arr[i]<<" ";
    }
    return  0;
}