C++实现快速排序的两种不同写法

快排-quicksort

基本思想

首先选择一个轴值（povit，即比较的基准），并将待排序的记录划分成独立的两部分，左侧记录的关键码均小于等于轴值，右侧记录的关键码均大于或等于轴值

分别对两部分重复以上操作，知道整个序列都有序

快速排序中需要解决的关键问题

1·如何选择轴值

1. 第一种：直接选取第一个为关键码–如果待排序师正序或者逆序，就会将轴值以为的所有记录都分到轴值得一边，这是快速排序最坏得清空
2. 选取中间记录的关键码，或者每次划分之前比较待排序序列的第一个记录、最后一个记录和中间记录的关键码，选取中间关键码作为轴值并调换到第一个记录的位置。

2·在待排序-序列中如何划分

1. 将i和j分别指向待划分区间的最左侧记录和最右侧记录的位置
2. 重复下述过程，直到i==j
   1. 右侧扫描，直到记录j的关键码小于轴值记录的关键码
   2. 如果存在划分区间则将r[j]与r[i]进行交换，并执行i++
   3. 左侧扫描，直到记录i的关键码大于轴值记录的关键码
   4. 如果存在划分区间，则将r[i]与r[j]的值进行交换，并执行j—
3. 退出循环，说明i和j指向了轴值记录所在的位置，返回该位置

3·如何处理划分得到的两个子序列

划分完成之后继续划分，直到两个子序列各有一个元素

4·如何判别快速排序结束

子序列中只有一个元素，就结束递归

时间复杂度

1. 平均时间复杂度为n logn
2. 最坏为 n^2

适用场景

1. 待排记录个数很大且原始记录随机排列情况
2. 如果数据特别大且原始记录部分有序容易冲爆栈的空间

快速排序第一种写法

//
// Created by HANWENKE on 2022/8/30.
//
#include 
#include 
using  namespace std;
//第一种写法，带Mypartion函数
int Mypartion(vector<int>&nums,int &first,int &end){
    int i=first,j=end;
    while(i<j){
        while(i<j&&nums[i]<=nums[j]){//右侧扫描
            j--;
        }
        if(i<j){
            //将小的值放到前面
            int temp=nums[i];
            nums[i]=nums[j];
            nums[j]=temp;
            i++;
        }
        while(i<j&&nums[i]<=nums[j]){//左侧扫描
            i++;
        }
        if(i<j){
            int temp=nums[i];
            nums[i]=nums[j];
            nums[j]=temp;
            j--;
        }
        return i;
    }
}
void quicsort(vector<int>&nums,int first,int end){
    if(first<end){
        int pivot= Mypartion(nums,first,end);
        quicsort(nums,first,pivot-1);
        quicsort(nums,pivot+1,end);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

快速排序第二种写法

void quick_sort_Second(vector<int>&nums,int first,int end){
    if(first>end){
        return;
    }
    int left=first;
    int right=end;
    int temp=nums[left];
    //取左侧第一个值为基准值
    while(left<right){
        while(left<right&&nums[right]>temp){//从右侧扫描-直到遇到第一个比基准值小的值
            right--;
        }
        nums[left]=nums[right];//将较小的值放到前面
        while(left<right&&nums[left]<=temp){//从左侧扫描--直到遇到第一个比基准值大
            left++;
        }
        nums[right]=nums[left];//将大的交换到后面
    }
    nums[left]=temp;//将基准值放到--left==right的位置
    quick_sort_Second(nums,first,left-1);
    quick_sort_Second(nums,left+1,end);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

测试主程序

int main(){
    vector<int>arr;
    arr.reserve(20);
    for(int i=0;i<20;i++){
        arr.push_back(rand()%500);
    }
    for(int i=0;i<arr.size();i++){
        cout<<arr[i]<<" ";
    }
    cout<<endl;
    quick_sort_Second(arr,0,arr.size()-1);
    //quicsort(arr,0,arr.size()-1);
    for(int i=0;i<arr.size();i++){
        cout<<arr[i]<<" ";
    }
    cout<<endl;
    //quick_sort_Second(arr,0,arr.size()-1);
    quicsort(arr,0,arr.size()-1);
    for(int i=0;i<arr.size();i++){
        cout<<arr[i]<<" ";
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23