快速排序实现与优化(单路、二路、三路)

最新推荐文章于 2022-02-13 13:54:58 发布

英特纳雄耐尔就一定会实现

最新推荐文章于 2022-02-13 13:54:58 发布

阅读量244

点赞数

分类专栏：数据结构与算法文章标签：数据结构快速排序排序算法

本文链接：https://blog.csdn.net/qq_42584241/article/details/105435913

版权

数据结构与算法专栏收录该内容

12 篇文章 0 订阅

订阅专栏

一.快速排序的思想

快速排序的基本思路是在每一趟排序中，选择一个标定值，将小于标定值的元素放在该元素前面，大于标定值的元素放在该元素后面，即每一趟确定了一个元素的位置。然后递归执行标定元素左右两侧的区间。

二.快速排序的实现与优化

1.基础的快速排序实现（单路快速排序）

#include"iostream"
#include"time.h"
using namespace std;



template<typename T>
int __partition(T *arr,int l,int r){
	//随机选择一个元素作为标定元素  优化近似有序的数组 元素全部堆积在一侧的问题
    swap(arr[l],arr[rand()%(r-l+1)+l]); 

    T flag = arr[l];
    int j = l;	//j为小于flag的最后一个元素下标
    //arr[L+1]----arr[j]<flag arr[j+1]---arr[i-1]>=flag
    for (int i = l+1; i <= r; i++)
    {
        if(arr[i]<flag)
            swap(arr[++j],arr[i]);  
    }
    
    swap(arr[l],arr[j]);
    return j;
}

template<typename T>
void __quickSort(T *arr,int l,int r){
    if(l>=r)
        return;

    int p = __partition(arr,l,r);
    __quickSort(arr,l,p-1);
    __quickSort(arr,p+1,r);
}

template<typename T>
void quickSort(T *arr,int n){
    srand(time(NULL));
    __quickSort(arr,0,n-1);
}

存在问题：与标定元素 flag 相同的元素总是被归为一侧，当存在大量相同元素时退化为o(n^2)

2.双路快速排序

#include"iostream"
#include"time.h"
using namespace std;



template<typename T>
int __partition2(T *arr,int l,int r){
    swap(arr[l],arr[rand()%(r-l+1)+l]);

    T flag = arr[l];
    int i = l+1;       //双路快速排序  
    int j = r;		   //与标定元素相同的元素会随机交换至标定元素左右两侧 而不是固定在其后面
    
    while(true){
        while(arr[i]<flag && i<=r) i++;
        while(arr[j]>flag && j>=l+1) j--;
        if(i>j) break;
        swap(arr[i++],arr[j--]);
    }

    swap(arr[l],arr[j]);
    return j;
}

template<typename T>
void __quickSort2(T *arr,int l,int r){
    if(r-l<=15){
        insertionSortR(arr,l,r);
        return ;
    }

    int p = __partition2(arr,l,r);
    __quickSort2(arr,l,p-1);
    __quickSort2(arr,p+1,r);
}

template<typename T>
void quickSort2(T *arr,int n){
    srand(time(NULL));
    __quickSort2(arr,0,n-1);
}

存在问题：与标定元素相同的元素随机交换，不固定在了标定元素的后面，但是还是需要处理

3.三路快速排序

#include"iostream"
#include"time.h"
using namespace std;




template<typename T>
void __quickSort3Ways(T *arr,int l,int r){
    if(r-l<=15){
        insertionSortR(arr,l,r);
        return ;
    }

    swap(arr[l],arr[rand()%(r-l+1)+l]);
    T v = arr[l];      //标定元素v
    int lt = l,ht=r+1; //[l+1,lt]<v [lt+1,i)==v [ht,r]>v  将原本区间分为三个区间 简称 1 2 3
    int i = l+1;       //i表示当前正在处理的元素下标

    while (i<ht)        
    {
        if(arr[i]<v){
            swap(arr[i],arr[lt+1]);    //当前元素小于v时 将1区间长度+1 将该元素放在1区间的末位
            lt++;                      //i++ 开始处理下一个元素
            i++;
        }else if(arr[i]>v){
            swap(arr[i],arr[ht-1]);    //当前元素大于v时，将3区间长度+1 将该元素放在3区间的首位
            ht--;                      //交换之后，此时i所指元素还未处理，所以i不做改变
        }else
            i++;                       //相同时，2区间长度+1
    }

    swap(arr[l],arr[lt]);              //首位与下标为lt的元素(即1区间的最后一个元素)交换位置

    __quickSort3Ways(arr,l,lt-1);      //递归
    __quickSort3Ways(arr,ht,r);
}

template<typename T>
void quickSort3Ways(T *arr,int n){
    srand(time(NULL));
    __quickSort3Ways(arr,0,n-1);
}