PTA basic 1045 快速排序 (25 分) c++语言实现(g++)

著名的快速排序算法里有一个经典的划分过程：我们通常采用某种方法取一个元素作为主元，通过交换，把比主元小的元素放到它的左边，比主元大的元素放到它的右边。 给定划分后的 N 个互不相同的正整数的排列，请问有多少个元素可能是划分前选取的主元？

例如给定 N=5, 排列是1、3、2、4、5。则：

• 1 的左边没有元素，右边的元素都比它大，所以它可能是主元；
• 尽管 3 的左边元素都比它小，但其右边的 2 比它小，所以它不能是主元；
• 尽管 2 的右边元素都比它大，但其左边的 3 比它大，所以它不能是主元；
• 类似原因，4 和 5 都可能是主元。

因此，有 3 个元素可能是主元。

输入格式：

输入在第 1 行中给出一个正整数 N（≤10​5​​）； 第 2 行是空格分隔的 N 个不同的正整数，每个数不超过 10​9​​。

输出格式：

在第 1 行中输出有可能是主元的元素个数；在第 2 行中按递增顺序输出这些元素，其间以 1 个空格分隔，行首尾不得有多余空格。

输入样例：

5
1 3 2 4 5

 

输出样例：

3

1 4 5

测试点0 　　　　测试用例通过 

测试点1 　　　　少量数据主元判断

测试点2　　　　0个主元时候的输出,要正确输出一个 0 和 一个空行

测试点3 4 5   大量数据主元判断是否正确

解题思路

1.题目本身是快速排序的主元选取,但是不需要手写快速排序,使用库函数sort()可以更快达到完成排序
2.其实题目考察的是观察主元特征,并准确判断特征的能力
3.主元的特征 (1)从待排序列头部到主元位置为止,主元一定是最大元素  (2) 待排序列的主元,已经在排序后的最终位置上 
4.边界处理,比如没有主元,要输出0个主元的信息,然后再输出一个空行
5.


AC代码

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
int main(){
    int n,i=0,flag;
    long max{0};
    scanf("%d",&n);
    vector<long>fast_sortList(n,0);
    vector<long>PivotList;
    for(int i=0;i<n;i++){
        scanf("%ld",&fast_sortList[i]);
    }
    vector<long>compare{fast_sortList};//将给定的数组拷贝到比较数组中
    sort(compare.begin(),compare.end());//比较数组按升序排列
    for(i=0;i<n;i++){
        flag=0;
        if(fast_sortList[i]>max){max=fast_sortList[i];flag=true;}//如果当前元素比max大,则赋值给max,标记这个元素是目前的最大元素
        if(compare[i]==fast_sortList[i]&&flag)PivotList.push_back(fast_sortList[i]);
        //如果这个元素的位置 处于 排序后的最终位置,那一定是主元
    }
    sort(PivotList.begin(),PivotList.end());//主元列表升序排列
    cout << PivotList.size()<<endl;
    if(PivotList.size()){//主元列表不为空时输出
        for(i=0;i<PivotList.size()-1;i++){//输出前n-1个元素
            cout << PivotList[i]<<" ";
        }
        cout << PivotList[i]<<endl;//最后一个输出结尾没有空格
    }else{
        cout<<endl;//0个主元时,要输出一个空行  测试点 2
    }
    return 0;
}

 

错误提交
1.第一次提交使用了快排逐个检查元素是否为主元,除了测试点1以外,都超时/错误了
2.第二次提交在快排基础上优化检查主元的方法,提交依然超时

//选取快排主元    // 初步思路是对每个元素进行一轮快排,位置不变的就是主元备选
//快排算法分两个部分,一个是递归划分子序列的部分,一个是子序列进行快排排序的部分,和归并类似,都是分而治之的思想

//递归划分部分
//递归子序列划分的基准在于pivot的选取,pivot由一轮快排排序产生,pivot之后和之前的元素分别构成两个序列,pivot前面和后面的一个元素分别成为子列的尾和头
//递归调用划分左右子序,直到low>=high
//一轮快排排序算法过程

//一轮快排排序中,首先记录pivot元素的位置index,暂存pivot元素为,严蔚敏版快排使用子序首元素作为pivot,所以pivot元素的位置默认为low
//然后以pivot为比较基准,从子序尾部开始比较,如果尾部比pivot大,则从后向前找(--high)到第一个比pivot小的元素的位置high
//将high位置的元素放入pivot元素的位置 也就是index(严蔚敏版 low )位置
//这个时候high位置就空了出来,
//然后比较头部元素和pivot,如果比pivot小,就从low位置开始向后找(low++),找到第一个比pivot元素大的元素的位置low
//将low位置的元素放入high位置
//循环结束条件为low>=high,这时两个标记相等,这个位置就是新的pivot位置 index
//将pivot放入index位置,index就是pivot在数列中最终的位置

//本题中要求出所有主元,如果一轮排序后选取的pivot的位置index没有发生变化,则说明这个元素是主元
//一个可能的思路
//
//
//
//快排的过程
//n个元素的序列中选取随机一个元素的位置k,标记当前位置k,并且暂存当前位置的数字为pivot,此时序列分为(0,k-1),k,(k+1,n-1)

//然后从后往前找比pivot小的数字放在temp位置,然后将标记向后移动一位
//严蔚敏版 快排一轮排序
//int partition(vector<int> presort,int low,int high){
//    int pivot=presort[low];
//    while(low<high){
//        while(presort[high]>pivot)--high;
//        presort[low]=presort[high];
//        while(presort[low]<pivot)++low;
//        presort[high]=presort[low];
//    }
//    presort[low]=pivot;
//    return low;
//}
//严蔚敏版 快排递归写法
//void quickSort(vector<int> preSort,int low,int high){
//    int pivot=partition(preSort,low,high);
//    quickSort(preSort,low, pivot-1);
//    quickSort(preSort, pivot+1, high);
//}

//第一次提交,不出意外的除了测试1全都超时了,接下来就是找技巧了
//第二步思路找到排序后的中间位置元素,用中间元素作为pivot,进行一轮快排,并与原数组进行比较,某个位置元素和原数组相等则说明是快排后位置不变,可能是主元
//第二次提交 测试点1通过, 测试点 2 3 4 5没有超时,但是答案错误,因此这个方法可行,但是需要增加正确率
//


#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;

long partition(vector<long>& presort,long low,long high,long index){
    long pivot=presort[index];
    while(low<high){
        while((low<high)&&(presort[high]>pivot))--high;
        presort[index]=presort[high];
        while((low<high)&&(presort[low]<pivot))++low;
        presort[high]=presort[low];
    }
    presort[low]=pivot;
    return low;//pivot的最终位置
}

bool ispivot(vector<long>&presort,long low,long high,long index){
    long pivot=presort[index];
    bool flag=false;
    while((low<high)&&(presort[high]>pivot))--high;
    while((low<high)&&(presort[low]<pivot))++low;
    if(low==high){
        flag=true;
    }
    return flag;
}

void markNumber(vector<long>preSort,long high,long pivotIndex,vector<long>&markList){
    vector<long>compare{preSort};
    partition(compare,0,high,pivotIndex);
    for(int i=0;i<high;i++){
        if(compare[i]!=preSort[i]){
            markList[i]=0;
        }
    }
}


int main(){
    int n,i=0;
    long temp;;
    int max,min,pivotIndex,diff,maxIndex=0,minIndex=0;
    scanf("%ld",&n);
    vector<long>fast_sortList(n,0);
    vector<long> markList(n,1);
    vector<long>compare(n,0);
    vector<long>PivotList;
    scanf("%ld",&temp);
    max=min=temp;
    fast_sortList[i]=temp;
    for(int i=1;i<n;i++){
        scanf("%ld",&temp);
//        if(temp>max){max=temp;maxIndex=i;}
//        if(temp<min){min=temp;minIndex=i;}
        fast_sortList[i]=temp;
    }
    compare=fast_sortList;
//判断是否为主元
//    for(i=1;i<n;i++){
//        long flag=partition(fast_sortList,0,n-1,i);
//        if(flag==i)PivotList.push_back(fast_sortList[i]);
//    }
    
    for(i=0;i<n;i++){
        if(ispivot(fast_sortList,0,n-1,i))PivotList.push_back(fast_sortList[i]);
    }
    //第二次尝试
//    long targetPivot=(max+min)/2;
//    diff=fast_sortList[0];
//    pivotIndex=0;
//    for(int i=0;i<n;i++){
//        if(diff>abs(fast_sortList[i]-targetPivot)){
//            diff=abs(fast_sortList[i]-targetPivot);
//            pivotIndex=i;
//        }
//    }
//
//    markNumber(fast_sortList,n-1,pivotIndex,markList);
//    markNumber(fast_sortList,n-1,maxIndex,markList);
//    markNumber(fast_sortList,n-1,minIndex,markList);
//
//    for(i=0;i<n;i++){
//        if(markList[i]){
//            PivotList.push_back(fast_sortList[i]);
//        }
//    }
    
    
    
    sort(PivotList.begin(),PivotList.end());
    cout << PivotList.size()<<endl;
    for(i=0;i<PivotList.size()-1;i++){
        cout << PivotList[i]<<" ";
    }
    cout << PivotList[i]<<endl;
    return 0;
}

 

第三次提交

//判断主元的方法 使用了快排的基本思路,如果在最终位置,则是主元

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;

bool ispivot(long *presort,int low,int high,int index){
    long pivot=presort[index];
    bool flag=false;
    while((low<high)&&(presort[high]>pivot))--high;
    while((low<high)&&(presort[low]<pivot))++low;
    if(low==high){
        flag=true;
    }
    return flag;
}
int compare(const void *l,const void *r){
    return *(int*)l-*(int *)r;
}

int main(){
    int n,i=0,j=0;
    long temp;
    scanf("%d",&n);
    long fast_sortList[n];
    long PivotList[n];
    scanf("%ld",&temp);
    fast_sortList[i]=temp;
    for(int i=1;i<n;i++){
        scanf("%ld",&temp);
        fast_sortList[i]=temp;
    }
    
    for(i=0;i<n;i++){
        if(ispivot(fast_sortList,0,n-1,i)){PivotList[j]=fast_sortList[i];j++;}
    }
    
    qsort(PivotList,j-1,sizeof(long),compare);
    cout << j <<endl;
    for(i=0;i<j-1;i++){
        printf("%ld ",PivotList[i]);
    }
    cout << PivotList[i]<<endl;
    return 0;
}