PTA 09-排序1 排序

最新推荐文章于 2022-12-05 15:38:45 发布
最新推荐文章于 2022-12-05 15:38:45 发布
阅读量270 收藏 2
点赞数
分类专栏： 陈越PTA训练 文章标签： 排序算法 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/vivi_beea/article/details/119778146
版权

PTA 09-排序1 排序

文章目录


原题链接
给定N个（长整型范围内的）整数，要求输出从小到大排序后的结果。

本题旨在测试各种不同的排序算法在各种数据情况下的表现。各组测试数据特点如下：

数据1：只有1个元素；
数据2：11个不相同的整数，测试基本正确性；
数据3：103个随机整数；
数据4：104个随机整数；
数据5：105个随机整数；
数据6：105个顺序整数；
数据7：105个逆序整数；
数据8：105个基本有序的整数；
数据9：105个随机正整数，每个数字不超过1000。
输入格式:
输入第一行给出正整数N（≤10
5
），随后一行给出N个（长整型范围内的）整数，其间以空格分隔。

输出格式:
在一行中输出从小到大排序后的结果，数字间以1个空格分隔，行末不得有多余空格。

输入样例:
11
4 981 10 -17 0 -20 29 50 8 43 -5
结尾无空行
输出样例:
-20 -17 -5 0 4 8 10 29 43 50 981
结尾无空行

main+print_sort函数

//输出结果
void print_sort(int A[],int N){
    for(int i=0;i<N-1;i++)
        printf("%d ",A[i]);
    printf("%d",A[N-1]);
}
int main(){
    int N;
    cin>>N;
    int A[N];
    for(int i=0;i<N;i++){
        cin>>A[i];
    }
    //Bubble_sort(A,N);
    //Insertion_sort(A,N);
    //Shell_sort(A,N);
    //selection_sort(A,N);
    //Heap_sort(A,N);
    Merge_sort(A,N);
    return 0;
}

1.Bubble_Sort冒泡排序

思路

每次排序将最大的留到最后
优化：使用flag，查看是否发生交换，如果已经不发生交换，则已经排好序

时间复杂度

逆序：O(N^2)
顺序：O(N)
只要是两两元素互换的算法（逆序对原理），O（N^2）

//冒泡排序
void Bubble_sort(int A[],int N){
    for(int P=N-1;P>=0;P--){
        int flag=0;
        for(int i=0;i<P;i++){
            if(A[i]>A[i+1]){
                swap(A[i],A[i+1]);
                flag=1;//发生了交换
            }
        }
        if(flag==0)break;//不发生交换 -> 排好序了
    }
    print_sort(A,N);
}

在这里插入图片描述

2.Insertion_sort插入排序

思路

像打牌一样，抽到一张牌，和之前抽到的牌去做比较，插入
有点：不用swap，只需向后挪+新牌落位

时间复杂度

相较于冒泡排序的时间效率提高了很多，但比起后面的算法仍然过于缓慢。
逆序：O(N^2)
顺序：O(N)

冒泡排序和插入排序都是每次交换消除一个逆序对，即每次交换只能交换相邻的数据，所以时间复杂度才为O（N^2），希尔排序就是受此启发，从交换距离较远的两个数据，尽快使得数组基本有序

//插入排序
void Insertion_sort(int A[],int N){
    for(int P=1;P<N;P++){
        int temp=A[P];
        int i;
        for(i=P;i>0&&A[i-1]>temp;i--){
            A[i]=A[i-1];//向后挪
        }
        A[i]=temp;//加入新牌
    }
    print_sort(A,N);
}

在这里插入图片描述

3.希尔排序+Sedgewick增量

思路

Sedgewick+插入排序
类似与插入排序，但是每次比较的不是相邻的数，而是距离为某个值的两个元素。
要定义一个间隔序列： 从大到小，最后是1
如Sedgewick序列：
int Sedgewick[] = {929, 505, 209, 109, 41, 19, 5, 1, 0};
这个序列中的元素一般要是互质的，这样希尔排序性能才会并较好。

时间复杂度

希尔排序只用了54ms,比冒泡和插入的时间减少了很多
一般来说，这要这个序列选取的比较好，希尔排序的时间复杂度一定小于O（N^2）。

//希尔排序+Sedgewick增量
void Shell_sort(int A[],int N){
    int Sedgewick[8] = {929, 505, 209, 109, 41, 19, 5, 1};
    for(int i=0;i<8;i++){
        int D=Sedgewick[i];//希尔增量排序
        for(int P=D;P<N;P++){//插入排序
            int temp=A[P];
            int i;
            for(i=P;i>=D&&A[i-D]>temp;i-=D){
                A[i]=A[i-D];
            }
            A[i]=temp;
        }
    }
    print_sort(A,N);
}

在这里插入图片描述

4.selection_sort选择排序

思路

每次从未排序的序列中选出一个最小值，与未排序的序列的第一位进行交换。

时间复杂度

时间复杂度取决于每次从未排序的序列中选出一个最小值·
若是使用for循环寻找，则：O(N^2)
虽然都通过测试，但是耗时4523ms非常久。
优化：使用堆排序进行每次从未排序的序列中选出一个最小值·

//选择排序
void selection_sort(int A[],int N){
    for(int i=0;i<N;i++){
        int minpos=i;
        for(int j=i;j<N;j++){
            if(A[j]<A[minpos]){
                minpos=j;
            }
        }
        swap(A[i],A[minpos]);
    }
    print_sort(A,N);
}

在这里插入图片描述

5.Heap_sort堆排序（代码比较不熟）

思路

注意：堆排序从A[0]，即下标为0开始存储
因此左孩子为2i+1,右孩子为2i+2
父节点为floor(i-1)

整体：建堆->循环做（将0和i即最小值进行交换，向下调整）

1.建堆
从i=N/2-1开始向上调整（此时2*i+1=N,i是最后一个元素的父节点）
2.调整堆
从N-1开始向上调整堆
3.PercDown函数——向下调整成最大堆的函数
从start开始，只要孩子不超过N（给定的堆长度），一直向下调整（parent=child）
选择左右孩子中值较大的，与需要调整的A[start]进行比较，插入

时间复杂度

首先将数组中N个数调整为最大堆（O（N）时间）；
然后依次把堆顶元素和对应位置的元素交换，然后调整堆（O（NlogN）时间）。
总时间复杂度就是O（NlogN）

//堆排序
//{向下调整成最大堆的函数}
void PercDown(int A[],int start,int N){
    int temp=A[start];
    int parent,child;
    for(parent=start;(2*parent+1)<N;parent=child){
        child=2*parent+1;//左孩子
        if(child+1<N&&A[child+1]>A[child])child++;//有右孩子并且选择较大的孩子与parent进行比较
        if(temp<A[child]){
            A[parent]=A[child];
        }else{
            break;
        }
    }
    A[parent]=temp;
}
void Swap(int A[],int i,int j){
    int temp=A[i];
    A[i]=A[j];
    A[j]=temp;
}
//{调用接口}
void Heap_sort(int A[],int N){
    for(int i=N/2-1;i>=0;i--){
        PercDown(A,i,N);//建堆
    }
    for(int i=N-1;i>0;i--){
        Swap(A,0,i);//DeleteMax
        PercDown(A,0,i);
    }
    print_sort(A,N);
}

在这里插入图片描述

6.Merge_sort归并排序（递归）

思路

分而治之的思想。要将一个大数组排序，可以把它分成两部分，先将这两个小一点的数组排好序，然后再把它们归并成一个大的有序数组。
所以就可以递归的将数组分为两个部分，直到数组大小为1，然后再一步步归并上来。

时间复杂度

T(N) = 2T(N/2) + O(N)
利用主方法，可以求得时间复杂度为 O(NlogN)。
同时空间复杂度为O（N），用来保存临时数组。

//归并排序
//{归并两个子序列}
void Merge(int A[],int TmpA[],int L,int R,int RightEnd){
    int LeftEnd=R-1;//左序列的结束下标
    int NumberofElement=RightEnd-L+1;//多少个元素
    int temp=L;//Cptr
    while(L<=LeftEnd&&R<=RightEnd){
        if(A[L]<=A[R]){
            TmpA[temp++]=A[L++];
        }else{
            TmpA[temp++]=A[R++];
        }
    }
    //处理剩下的
    while(L<=LeftEnd){
        TmpA[temp++]=A[L++];
    }
    while(R<=RightEnd){
        TmpA[temp++]=A[R++];
    }
    //复制回A[]
    for(int i=0;i<NumberofElement;i++,RightEnd--){
        A[RightEnd]=TmpA[RightEnd];
    }
}
//{用于递归}
void MSort(int A[],int TmpA[],int L,int RightEnd){
    int Center;
    if(L<RightEnd){
        Center=(L+RightEnd)/2;
        MSort(A,TmpA,L,Center);//递归左边
        MSort(A,TmpA,Center+1,RightEnd);//递归右边
        Merge(A,TmpA,L,Center+1,RightEnd);//合并
    }
}
//{调用接口}
void Merge_sort(int A[],int N){
    int *TmpA;
    TmpA=(int*)malloc(N*sizeof(int));
    if(TmpA!=NULL){
        MSort(A,TmpA,0,N-1);
        print_sort(A,N);
        free(TmpA);
    }else{
        printf("空间不足\n");
    }
    
}

在这里插入图片描述

7.Merge_sort归并排序（非递归）代码不太熟

思路

1.Merge归并两个序列的函数不变
2.Merge_pass函数
将每个length进行Merge
如果最后有剩余的子序列
（1）还剩两个子序列,两个子序列的长度不足2*length
Merge剩余子序列
（2）仅剩一个子序列，直接复制到TmpA中
3.接口函数

while(len<N){
    Merge_pass(A,TmpA,N,len);
    len*=2;
    Merge_pass(TmpA,A,N,len);
    len*=2;
  }

时间复杂度

可以从结果看出，耗时比递归要少，但是内存空间比递归方法要大。空间换时间

//归并排序——循环（非递归）
//{归并两个子序列}
void Merge(int A[],int TmpA[],int L,int R,int RightEnd){
    int LeftEnd=R-1;//左序列的结束下标
    int NumberofElement=RightEnd-L+1;//多少个元素
    int temp=L;//Cptr
    while(L<=LeftEnd&&R<=RightEnd){
        if(A[L]<=A[R]){
            TmpA[temp++]=A[L++];
        }else{
            TmpA[temp++]=A[R++];
        }
    }
    //处理剩下的
    while(L<=LeftEnd){
        TmpA[temp++]=A[L++];
    }
    while(R<=RightEnd){
        TmpA[temp++]=A[R++];
    }
    //复制回A[]
    for(int i=0;i<NumberofElement;i++,RightEnd--){
        A[RightEnd]=TmpA[RightEnd];
    }
}
//{length为当前子序列长度}
void Merge_pass(int A[],int TmpA[],int N,int length){
    //两两归并相邻有序子列
    int i,j;
    for(i=0;i<=N-2*length;i+=2*length){
        Merge(A,TmpA,i,i+length,i+2*length-1);
    }
    if(i+length<N){//还剩两个子序列,两个子序列的长度不足2*length
        Merge(A,TmpA,i,i+length,N-1);
    }else{//仅剩一个子序列，直接复制
        for(j=i;j<N;j++){
           TmpA[j]=A[j];
        }
    }
}
//{接口}
void Merge_sort2(int A[],int N){
    int *TmpA=(int*)malloc(N*sizeof(int));
    int len=1;
    if(TmpA!=NULL){
        while(len<N){
            Merge_pass(A,TmpA,N,len);
            len*=2;
            Merge_pass(TmpA,A,N,len);
            len*=2;
        }
        print_sort(A,N);
        free(TmpA);
    }else{
        printf("空间不足\n");
    }
}

在这里插入图片描述

8.quicksort快速排序

思路

1.Median3选主元
顺序排好left,center,right值后，将center值藏在right-1，返回A[right-1]即pivot

2.递归选定主元所在位置
++low，小于pivot
–high，大于pivot
否则,如果low<high，位置互换，
否则，退出循环，即找到了pivot的最终位置low
（为什么最终位置是low?——++low,–high最后一轮时，low>high，A[low]是大于pivot的第一个位置）
交换low和right-1的值
进行左递归和右递归（此时pivot的位置为low）
左边为：left-low——1
右边为：low+1——right

3.完成接口

选择&对比

1.选主元
（1）A[0]——有可能遇上顺序序列，消耗O(N^2)
（2）rand()——函数消耗空间大
（3）median3()√
2.cutoff的选择
为什么设置cutoff?——当元素很小时，快速排序的效率不如插入排序来了高，所以设置一个合适的阈值
（1）50——62ms
在这里插入图片描述
（2）100——49ms
在这里插入图片描述
（3）200——67ms
在这里插入图片描述
（4）300——48ms
在这里插入图片描述
（5）400——72ms
在这里插入图片描述
cutoff最优值：
300>100>50>200>400

时间复杂度

最好：O(NlogN)
最坏：O(N^2)
空间：O(N)
不稳定

Code

#include<iostream>
#include<stdlib.h>
using namespace std;
//输出结果
void print_sort(int A[],int N){
    for(int i=0;i<N-1;i++)
        printf("%d ",A[i]);
    printf("%d",A[N-1]);
}
//插入排序
void Insertion_sort(int A[],int N){
    for(int P=1;P<N;P++){
        int temp=A[P];
        int i;
        for(i=P;i>0&&A[i-1]>temp;i--){
            A[i]=A[i-1];//向后挪
        }
        A[i]=temp;//加入新牌
    }
}

//快速排序quick sort
void Swap(int A[],int i,int j){
    int temp=A[i];
    A[i]=A[j];
    A[j]=temp;
}
//{获得主元pivot}
int Median3(int A[],int left,int right){
    int center=(left+right)/2;
    if(A[left]>A[center]){
        Swap(A,left,center);
    }
    if(A[left]>A[right]){
        Swap(A,left,right);
    }
    if(A[center]>A[right]){
        Swap(A,center,right);
    }
    Swap(A,center,right-1);//将pivot放到right-1
    return A[right-1];
}
//递归进行快速排序
void quicksort(int A[],int left,int right){
    int pivot,low,high,cutoff;
    cutoff=50;//修改值
    if(cutoff<=right-left){
        low=left;
        high=right-1;
        pivot=Median3(A,left,right);
        while(1){
            while(A[++low]<pivot){};
            while(A[--high]>pivot){};
            if(low<high){
                Swap(A,low,high);
            }else{
                break;
            }
        }
        Swap(A,low,right-1);//将pivot换到正确的位置，注意这部要跳出循环，此时的low为正确值
        quicksort(A,left,low-1);//递归解决左边
        quicksort(A,low+1,right);//递归解决右边
    }else{
        Insertion_sort(A+left,right-left+1);//元素太少，插入排序
    }
}
//{接口}
void Quick_sort(int A[],int N){
    quicksort(A,0,N-1);
}
int main(){
    int N;
    cin>>N;
    int A[N];
    for(int i=0;i<N;i++){
        cin>>A[i];
    }
    //Bubble_sort(A,N);
    //Insertion_sort(A,N);
    //Shell_sort(A,N);
    //selection_sort(A,N);
    //Heap_sort(A,N);
    //Merge_sort2(A,N);
    Quick_sort(A,N);
    print_sort(A,N);
    return 0;
}

总结

综上所述，时间效率和空间效率综合最优的算法是希尔排序和堆排序。

但是希尔排序和堆排序的结果都是不稳定的，存在稳定性需求的条件下，归并排序是一个不错的选择，仅需额外付出一定的空间开销。

Code合集

#include<iostream>
#include<stdlib.h>
using namespace std;
//输出结果
void print_sort(int A[],int N){
    for(int i=0;i<N-1;i++)
        printf("%d ",A[i]);
    printf("%d",A[N-1]);
}
//冒泡排序
void Bubble_sort(int A[],int N){
    for(int P=N-1;P>=0;P--){
        int flag=0;
        for(int i=0;i<P;i++){
            if(A[i]>A[i+1]){
                swap(A[i],A[i+1]);
                flag=1;//发生了交换
            }
        }
        if(flag==0)break;//不发生交换 -> 排好序了
    }
    print_sort(A,N);
}
//插入排序
void Insertion_sort(int A[],int N){
    for(int P=1;P<N;P++){
        int temp=A[P];
        int i;
        for(i=P;i>0&&A[i-1]>temp;i--){
            A[i]=A[i-1];//向后挪
        }
        A[i]=temp;//加入新牌
    }
    print_sort(A,N);
}
//希尔排序+Sedgewick增量
void Shell_sort(int A[],int N){
    int Sedgewick[8] = {929, 505, 209, 109, 41, 19, 5, 1};
    for(int i=0;i<8;i++){
        int D=Sedgewick[i];//希尔增量排序
        for(int P=D;P<N;P++){//插入排序
            int temp=A[P];
            int i;
            for(i=P;i>=D&&A[i-D]>temp;i-=D){
                A[i]=A[i-D];
            }
            A[i]=temp;
        }
    }
    print_sort(A,N);
}
//选择排序
void selection_sort(int A[],int N){
    for(int i=0;i<N;i++){
        int minpos=i;
        for(int j=i;j<N;j++){
            if(A[j]<A[minpos]){
                minpos=j;
            }
        }
        swap(A[i],A[minpos]);
    }
    print_sort(A,N);
}
//堆排序
//{向下调整成最大堆的函数}
void PercDown(int A[],int start,int N){
    int temp=A[start];
    int parent,child;
    for(parent=start;(2*parent+1)<N;parent=child){
        child=2*parent+1;//左孩子
        if(child+1<N&&A[child+1]>A[child])child++;//有右孩子并且选择较大的孩子与parent进行比较
        if(temp<A[child]){
            A[parent]=A[child];
        }else{
            break;
        }
    }
    A[parent]=temp;
}
void Swap(int A[],int i,int j){
    int temp=A[i];
    A[i]=A[j];
    A[j]=temp;
}
//{调用接口}
void Heap_sort(int A[],int N){
    for(int i=N/2-1;i>=0;i--){
        PercDown(A,i,N);//建堆
    }
    for(int i=N-1;i>0;i--){
        Swap(A,0,i);//DeleteMax
        PercDown(A,0,i);
    }
    print_sort(A,N);
}
//归并排序
//{归并两个子序列}
void Merge(int A[],int TmpA[],int L,int R,int RightEnd){
    int LeftEnd=R-1;//左序列的结束下标
    int NumberofElement=RightEnd-L+1;//多少个元素
    int temp=L;//Cptr
    while(L<=LeftEnd&&R<=RightEnd){
        if(A[L]<=A[R]){
            TmpA[temp++]=A[L++];
        }else{
            TmpA[temp++]=A[R++];
        }
    }
    //处理剩下的
    while(L<=LeftEnd){
        TmpA[temp++]=A[L++];
    }
    while(R<=RightEnd){
        TmpA[temp++]=A[R++];
    }
    //复制回A[]
    for(int i=0;i<NumberofElement;i++,RightEnd--){
        A[RightEnd]=TmpA[RightEnd];
    }
}
//{用于递归}
void MSort(int A[],int TmpA[],int L,int RightEnd){
    int Center;
    if(L<RightEnd){
        Center=(L+RightEnd)/2;
        MSort(A,TmpA,L,Center);//递归左边
        MSort(A,TmpA,Center+1,RightEnd);//递归右边
        Merge(A,TmpA,L,Center+1,RightEnd);//合并
    }
}
//{调用接口}
void Merge_sort(int A[],int N){
    int *TmpA;
    TmpA=(int*)malloc(N*sizeof(int));
    if(TmpA!=NULL){
        MSort(A,TmpA,0,N-1);
        print_sort(A,N);
        free(TmpA);
    }else{
        printf("空间不足\n");
    }
    
}
//快速排序quick sort
//{获得主元pivot}
int Median3(int A[],int left,int right){
    int center=(left+right)/2;
    if(A[left]>A[center]){
        Swap(A,left,center);
    }
    if(A[left]>A[right]){
        Swap(A,left,right);
    }
    if(A[center]>A[right]){
        Swap(A,center,right);
    }
    Swap(A,center,right-1);//将pivot放到right-1
    return A[right-1];
}
//递归进行快速排序
void quicksort(int A[],int left,int right){
    int pivot,low,high,cutoff;
    cutoff=400;//修改值
    if(cutoff<=right-left){
        low=left;
        high=right-1;
        pivot=Median3(A,left,right);
        while(1){
            while(A[++low]<pivot){};
            while(A[--high]>pivot){};
            if(low<high){
                Swap(A,low,high);
            }else{
                break;
            }
        }
        Swap(A,low,right-1);//将pivot换到正确的位置，注意这部要跳出循环，此时的low为正确值
        quicksort(A,left,low-1);//递归解决左边
        quicksort(A,low+1,right);//递归解决右边
    }else{
        Insertion_sort(A+left,right-left+1);//元素太少，插入排序
    }
}
//{接口}
void Quick_sort(int A[],int N){
    quicksort(A,0,N-1);
}
int main(){
    int N;
    cin>>N;
    int A[N];
    for(int i=0;i<N;i++){
        cin>>A[i];
    }
    //Bubble_sort(A,N);
    //Insertion_sort(A,N);
    //Shell_sort(A,N);
    //selection_sort(A,N);
    //Heap_sort(A,N);
    Merge_sort(A,N);
    Quick_sort(A,N);//Quick需要在main中printsort因为调用了插入排序
    return 0;
}
viV_ibeea
关注
专栏目录
PTA 09-排序1 排序 (25分)
mamabinbinbin的博客
05-02 842
排序题。先给出原题把！ 09-排序1 排序   (25分) 给定NN个（长整型范围内的）整数，要求输出从小到大排序后的结果。 本题旨在测试各种不同的排序算法在各种数据情况下的表现。各组测试数据特点如下： 数据1：只有1个元素； 数据2：11个不相同的整数，测试基本正确性； 数据3：103个随机整数； 数据4：10
[PTA7-1-1]简化的插入排序
JinLiQ的博客
05-23 2424
思路：创建一个动态数组，将键盘输入存入数组中，将输入的需插入的数据和数组元素进比较，然后将其插入数组。 代码如下： #include<stdio.h> int main() { int N,i,n,t; int a[100]; scanf("%d",&N); for(i=0;i<N;i++) scanf("%d",&a[i]);//将键盘输入存入数组 scanf("%d",&n);//需要插入的数据
09-排序1 排序
王寒寒的博客
05-19 682
09-排序1 排序 来自：PTA_数据结构_排序1 排序 给定N个（长整型范围内的）整数，要求输出从小到大排序后的结果。 本题旨在测试各种不同的排序算法在各种数据情况下的表现。各组测试数据特点如下： 数据1：只有1个元素； 数据2：11个不相同的整数，测试基本正确性； 数据3：10^3个随机整数； 数据4：10^4个随机整数； 数据5：10^5个随机整数； 数据6：10^5个顺序整数； 数据7：10^5个逆序整数； 数据8：10^5个基本有序的整数； 数据9：10^5个随机正整数，每个数字不超过1000。
数据结构：希尔排序
qq_35299223的博客
08-16 560
09-排序1 排序 (25 分) 给定N个（长整型范围内的）整数，要求输出从小到大排序后的结果。 本题旨在测试各种不同的排序算法在各种数据情况下的表现。各组测试数据特点如下： 数据1：只有1个元素； 数据2：11个不相同的整数，测试基本正确性； 数据3：103个随机整数； 数据4：104个随机整数； 数据5：105个随机整数； 数据6：105个顺序整数； 数据7：105个逆序整数； 数据8：105...
PTA数据结构题目集 第九周——排序（上）
cos的博客
08-27 1011
PTA数据结构题目集 第九周——排序（上），涉及各种排序算法（插入排序、归并排序、堆排序等），所用语言为c++。
数据结构-PTA09-排序1 排序 (25分)
sharemon的博客
12-12 684
给定N个（长整型范围内的）整数，要求输出从小到大排序后的结果。 本题旨在测试各种不同的排序算法在各种数据情况下的表现。各组测试数据特点如下： 数据1：只有1个元素； 数据2：11个不相同的整数，测试基本正确性； 数据3：103个随机整数； 数据4：104个随机整数； 数据5：105个随机整数； 数据6：105个顺序整数； 数据7：105个逆序整数； 数据8：105个基本有序的整数； 数据9：105...
PTA 09-排序1 排序（附全部算法实现及结果）
Invokar的博客
05-05 3949
PTA 09-排序1 排序（25 分） 题目地址：09-排序1 排序（25 分） 题目描述： 给定N个（长整型范围内的）整数，要求输出从小到大排序后的结果。 本题旨在测试各种不同的排序算法在各种数据情况下的表现。各组测试数据特点如下： 数据1：只有1个元素； 数据2：11个不相同的整数，测试基本正确性； 数据3：103个随机整数； 数据4：104个随机整数； 数据5...
PTA 6-1 结构体数组排序-根据成绩高低将学生记录排序
最新发布
m0_73896158的博客
12-05 4315
PTA 6-1 结构体数组排序-根据成绩高低将学生记录排序
PTA-部分排序
m0_62764023的博客
11-29 2006
对于一组数据，我们可以只对原先处在中间位置的那些元素进行排序。 输入格式: 在一行内输入n r a1 a2 ... an 其中，不大于200的正整数n表示该组数据的个数；不大于200的非负整数r表示该组数据两端各自留有r个数不参与排序，若r+r>=n，则该组数据无需排序。 整数a1 a2 ... an是该组的n个数据，且都在8位以内。 输出格式: 排序之后的序列，元素之间用一个空格间隔，最后一个元素之后不加空格。 输入样例： 5 1 6 5 4 3 2 输出样例： 6 3 4 5
c语言字符串的冒泡排序pta,PTA7-30 字符串的冒泡排序（20 分）通俗双解法
weixin_39639505的博客
05-17 1754
输出格式：输出冒泡排序法扫描完第K遍后的中间结果序列，每行包含一个字符串。输入样例：6 2bestcateastafreeday输出样例：bestacatdayeastfree这道题为什么有20分？一方面是涉及排序算法，另一方面估计是考察你在不用函数库提供的某些函数的情况下解决此题，如果此题不用函数库提供的一些函数，那么此题将会比用函数难上一个台阶。拿C语言来说，如果不用strcmp，你自己手动写...
PTA 排序
mmmjtt的博客
02-22 4199
PTA 排序 (25 分) 给定N个（长整型范围内的）整数，要求输出从小到大排序后的结果。 本题旨在测试各种不同的排序算法在各种数据情况下的表现。各组测试数据特点如下： 数据1：只有1个元素； 数据2：11个不相同的整数，测试基本正确性； 数据3：103个随机整数； 数据4：104个随机整数； 数据5：105个随机整数； 数据6：105个顺序整数； 数据7：105个逆序整数； 数据8：105个基本有序的整数； 数据9：105个随机正整数，每个数字不超过1000。 输入格式: 输入第一行给出正整数N（≤10^
PTA 6-6 快速排序
wcd278212784的博客
06-08 633
6-6 快速排序 int Partition(SqList &L,int low,int high){ L.r[0]=L.r[low]; int pivotekey=L.r[low].key; while(low<high){ while (low<high&&L.r[high].key>=pivotekey){ high--; } L.r[low]=L.r[high]; while(low<high&&L.r[hi
PTA KMP 串的模式匹配
viVi_beea的博客
08-26 1211
PTA KMP 串的模式匹配 给定两个由英文字母组成的字符串 String 和 Pattern，要求找到 Pattern 在 String 中第一次出现的位置，并将此位置后的 String 的子串输出。如果找不到，则输出“Not Found”。 本题旨在测试各种不同的匹配算法在各种数据情况下的表现。各组测试数据特点如下： 输出格式: 对每个 Pattern，按照题面要求输出匹配结果。 输入样例: abcabcabcabcacabxy 3 abcabcacab cabcabcd abcabcabcabcac
PTA 04-树7 二叉搜索树的操作集
viVi_beea的博客
08-07 605
PTA 04-树7 二叉搜索树的操作集 题目链接 思路 原文链接：https://blog.csdn.net/weixin_43893847/article/details/102647325 主要写一下Delete. 1.按顺序找，找到了空结点，表示树中没有这个节点。 2.比当前结点值小，找左子树。 3.比当前结点值大，找右子树。 4.等于当前结点值，要删除当前结点。 （1）左右孩子健全，最便捷的删除方式是用左子树最大结点或右子树最小结点的值替换该结点值，然后载左子树或右子树中删除这个值；（二叉搜索树的属
PTA 10-排序4 统计工龄
viVi_beea的博客
08-19 560
PTA 10-排序4 统计工龄 文章目录PTA 10-排序4 统计工龄思路code 原题链接 给定公司N名员工的工龄，要求按工龄增序输出每个工龄段有多少员工。 输入格式: 输入首先给出正整数N（≤10 5 ），即员工总人数；随后给出N个整数，即每个员工的工龄，范围在[0, 50]。 输出格式: 按工龄的递增顺序输出每个工龄的员工个数，格式为：“工龄:人数”。每项占一行。如果人数为0则不输出该项。 输入样例: 8 10 2 0 5 7 2 5 2 结尾无空行 输出样例: 0:1 2:3 5:2 7:1 10:
PTA 05-树9 Huffman Codes
viVi_beea的博客
08-10 558
PTA 05-树9 Huffman Codes 原题链接 题目理解 【来自陈越姥姥的讲解视频和PPT+自己的记录】 （1）Huffman编码不唯一 0和1可能互换 树的形状可能不一样 但是都是最优Huffman编码 注意：最优编码不一定通过Huffman算法得到！ 因此题意不能仅仅理解为：编码是否符合Huffman树 （2）HuffmanCodes的特点 1.最优编码——总长度（WPL）最小 2.无歧义解码——前缀码：数据仅存于叶子结点 3.没有度为1的结点——满足1,2则必然有3（题目不必单独判断） 满足
PTA 11-散列3 QQ帐户的申请与登陆
viVi_beea的博客
08-25 349
PTA 11-散列3 QQ帐户的申请与登陆 文章目录PTA 11-散列3 QQ帐户的申请与登陆注意Code 实现QQ新帐户申请和老帐户登陆的简化版功能。最大挑战是：据说现在的QQ号码已经有10位数了。 输入格式: 输入首先给出一个正整数N（≤10 5 ），随后给出N行指令。每行指令的格式为：“命令符（空格）QQ号码（空格）密码”。其中命令符为“N”（代表New）时表示要新申请一个QQ号，后面是新帐户的号码和密码；命令符为“L”（代表Login）时表示是老帐户登陆，后面是登陆信息。QQ号码为一个不超过10位、
PTA 10-排序5 PAT Judge
viVi_beea的博客
08-19 307
PTA 10-排序5 PAT Judge 文章目录PTA 10-排序5 PAT Judge思路注意Code 原题链接 The ranklist of PAT is generated from the status list, which shows the scores of the submissions. This time you are supposed to generate the ranklist for PAT. Input Specification: Each input file c
PTA 08-图9 关键活动
viVi_beea的博客
08-17 300
PTA 08-图9 关键活动 原题链接 假定一个工程项目由一组子任务构成，子任务之间有的可以并行执行，有的必须在完成了其它一些子任务后才能执行。“任务调度”包括一组子任务、以及每个子任务可以执行所依赖的子任务集。 比如完成一个专业的所有课程学习和毕业设计可以看成一个本科生要完成的一项工程，各门课程可以看成是子任务。有些课程可以同时开设，比如英语和C程序设计，它们没有必须先修哪门的约束；有些课程则不可以同时开设，因为它们有先后的依赖关系，比如C程序设计和数据结构两门课，必须先学习前者。 但是需要注意的是，对一
PTA 08-图7 公路村村通
viVi_beea的博客
08-13 297
PTA 08-图7 公路村村通 原题链接 现有村落间道路的统计数据表中，列出了有可能建设成标准公路的若干条道路的成本，求使每个村落都有公路连通所需要的最低成本。 输入格式: 输入数据包括城镇数目正整数N（≤1000）和候选道路数目M（≤3N）；随后的M行对应M条道路，每行给出3个正整数，分别是该条道路直接连通的两个城镇的编号以及该道路改建的预算成本。为简单起见，城镇从1到N编号。 输出格式: 输出村村通需要的最低成本。如果输入数据不足以保证畅通，则输出−1，表示需要建设更多公路。 输入样例: 6 15 1
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值