PTA 09-排序1 排序

最新推荐文章于 2023-03-15 22:55:54 发布
最新推荐文章于 2023-03-15 22:55:54 发布
阅读量241 收藏 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
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PTA 09-排序1 排序 (25分)
mamabinbinbin的博客
05-02 830
排序题。先给出原题把！ 09-排序1 排序   (25分) 给定NN个（长整型范围内的）整数，要求输出从小到大排序后的结果。 本题旨在测试各种不同的排序算法在各种数据情况下的表现。各组测试数据特点如下： 数据1：只有1个元素； 数据2：11个不相同的整数，测试基本正确性； 数据3：103个随机整数； 数据4：10
英文单词排序 （25 分）PTA
10-21
实验11-1-1 英文单词排序 （25 分） 本题要求编写程序，输入若干英文单词，对这些单词按长度从小到大排序后输出。如果长度相同，按照输入的顺序不变。 输入格式： 输入为若干英文单词，每行一个，以#作为输入结束...
09-排序1 排序
王寒寒的博客
05-19 654
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 514
09-排序1 排序 (25 分) 给定N个（长整型范围内的）整数，要求输出从小到大排序后的结果。 本题旨在测试各种不同的排序算法在各种数据情况下的表现。各组测试数据特点如下： 数据1：只有1个元素； 数据2：11个不相同的整数，测试基本正确性； 数据3：103个随机整数； 数据4：104个随机整数； 数据5：105个随机整数； 数据6：105个顺序整数； 数据7：105个逆序整数； 数据8：105...
PTA数据结构题目集 第九周——排序（上）
cos的博客
08-27 760
PTA数据结构题目集 第九周——排序（上），涉及各种排序算法（插入排序、归并排序、堆排序等），所用语言为c++。
数据结构-PTA09-排序1 排序 (25分)
sharemon的博客
12-12 664
给定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 3861
PTA 09-排序1 排序（25 分） 题目地址：09-排序1 排序（25 分） 题目描述： 给定N个（长整型范围内的）整数，要求输出从小到大排序后的结果。 本题旨在测试各种不同的排序算法在各种数据情况下的表现。各组测试数据特点如下： 数据1：只有1个元素； 数据2：11个不相同的整数，测试基本正确性； 数据3：103个随机整数； 数据4：104个随机整数； 数据5...
PTA 09-排序3 Insertion or Heap Sort
viVi_beea的博客
08-18 189
PTA 09-排序3 Insertion or Heap Sort 题目原链接 According to Wikipedia: Insertion sort iterates, consuming one input element each repetition, and growing a sorted output list. Each iteration, insertion sort removes one element from the input data, finds the locati
PTA 09-排序2 Insert or Merge
viVi_beea的博客
08-18 169
PTA 09-排序2 Insert or Merge 文章目录PTA 09-排序2 Insert or Merge题意思路注意Code 原题链接 According to Wikipedia: Insertion sort iterates, consuming one input element each repetition, and growing a sorted output list. Each iteration, insertion sort removes one element from
PTA 09-排序2 Insert or Merge（25 分）
Invokar的博客
05-05 835
09-排序2 Insert or Merge（25 分） 题目地址：09-排序2 Insert or Merge（25 分） 题目描述： According to Wikipedia: Insertion sort iterates, consuming one input element each repetition, and growing a sorted output ...
PTA 7-5 字符串排序 算法改进
m0_73989054的博客
03-15 1495
总体解析：此算法通过先选取一个参考值然后再分区，将比这个数大的数全放在它的右边，小于或等于全放在左边，再对左右区间重复分区，直至区间仅一个数。定义一个二维数组，由于题目自身只会给出五个字符串，为减少数组量，将一个数组既用于排序又用于存储缓存量，此外字符串最长为。定义一个二维数组，由于题目自身只会给出五个字符串，为减少数组量，将一个数组既用于排序又用于存储缓存量，此外字符串最长为。由前向后找比它大的数，找到后也挖出此数填到前一个坑。由后向前找比它小的数，找到后挖出此数填前一个坑。个不同整数，每个整数最小为。
冒泡排序pta.docx
01-08
冒泡排序pta
冒泡排序_冒泡排序_
09-30
1. **初始化**：首先，定义一个整型数组，存储待排序的元素。然后，设置两个循环变量，一个表示外层循环的轮数，一个表示内层循环的比较次数。 2. **外层循环**：从数组的第一个元素开始，到倒数第二个元素结束，...
PTA字符串冒泡排序（C语言版）
06-18
输入在第1行中给出N和K（1≤K≤100），此后N行，每行包含一个长度不超过10的、仅由小写英文字母组成的非空字符串。 输出格式： 输出冒泡排序法扫描完第K遍后的中间结果序列，每行包含一个字符串。 输入样例： 6 2 ...
480474460754866PTA1-12次练习编程题答案.zip
05-14
这些文件名为“480474460754866PTA1-12次练习编程题答案.zip”的压缩包内容是关于编程练习的答案，涵盖从第2次到第12次的练习。每个练习都有一个对应的`.docx`文档，这种格式通常是Microsoft Word用于存储文档的。在...
PTA KMP 串的模式匹配
viVi_beea的博客
08-26 1137
PTA KMP 串的模式匹配 给定两个由英文字母组成的字符串 String 和 Pattern，要求找到 Pattern 在 String 中第一次出现的位置，并将此位置后的 String 的子串输出。如果找不到，则输出“Not Found”。 本题旨在测试各种不同的匹配算法在各种数据情况下的表现。各组测试数据特点如下： 输出格式: 对每个 Pattern，按照题面要求输出匹配结果。 输入样例: abcabcabcabcacabxy 3 abcabcacab cabcabcd abcabcabcabcac
PTA 04-树7 二叉搜索树的操作集
viVi_beea的博客
08-07 535
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 512
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 505
PTA 05-树9 Huffman Codes 原题链接 题目理解 【来自陈越姥姥的讲解视频和PPT+自己的记录】 （1）Huffman编码不唯一 0和1可能互换 树的形状可能不一样 但是都是最优Huffman编码 注意：最优编码不一定通过Huffman算法得到！ 因此题意不能仅仅理解为：编码是否符合Huffman树 （2）HuffmanCodes的特点 1.最优编码——总长度（WPL）最小 2.无歧义解码——前缀码：数据仅存于叶子结点 3.没有度为1的结点——满足1,2则必然有3（题目不必单独判断） 满足
c语言pta6-1 字符串排序
最新发布
06-16
在C语言中，字符串排序通常涉及到数组或字符指针的处理。如果是指对一维字符数组按照字典序（ASCII值）进行升序或降序排序，可以使用标准库函数如qsort()或者自定义排序算法，比如冒泡排序、选择排序、插入排序或快速排序等。 以下是一个简单的使用qsort()函数对字符串数组进行排序的例子，假设我们有一个包含字符串的数组： ```c #include <stdio.h> #include <stdlib.h> #include <string.h> // 自定义比较函数，用于qsort() int compare(const void *a, const void *b) { return strcmp(*(char **)a, *(char **)b); } void sortStrings(char strings[][50], int n) { qsort(strings, n, sizeof(char*), compare); } int main() { char words[] = {"apple", "banana", "cherry", "date", "elderberry"}; int numWords = sizeof(words) / sizeof(words); // 排序数组 sortStrings(words, numWords); // 输出排序后的结果 for (int i = 0; i < numWords; i++) { printf("%s\n", words[i]); } return 0; } ``` 在这个例子中，`compare`函数是qsort()的核心，它比较两个字符串并返回相应的排序顺序。`sortStrings()`函数则调用qsort()对字符串数组进行排序。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值