【PTA】排序算法

最新推荐文章于 2023-11-28 10:43:17 发布
原创 最新推荐文章于 2023-11-28 10:43:17 发布 · 2k 阅读 · 10 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #c语言 #数据结构

本文详细展示了冒泡排序、优化后的冒泡排序、插入排序、希尔排序、选择排序、堆排序、归并排序（递归与非递归两种方式）和快速排序的C++实现。这些排序算法在计算机科学中有着广泛的应用，理解并掌握它们对于提升编程技能至关重要。
部署运行你感兴趣的模型镜像

 

 

在PTA例子中的体现：

一、冒泡排序

//1：没有优化的冒泡排序
#include <iostream>
#define MAXN 100001
using namespace std;

int a[MAXN];

void Bubble_Sort(int* a,int N){
    //N-1趟
    for(int k=N-1;k>0;k--){
        for(int i=0;i<k;i++){
            if(a[i]>a[i+1]){
                int tmp=a[i];
                a[i]=a[i+1];
                a[i+1]=tmp;
            }
        }
    }
}


//2：优化后的冒泡排序
#include <iostream>
#define MAXN 100001
using namespace std;

int a[MAXN];

void Bubble_Sort(int* a,int N){
    //N-1趟
    for(int k=N-1;k>0;k--){
        int flag=0;
        for(int i=0;i<k;i++){
            if(a[i]>a[i+1]){
                int tmp=a[i];
                a[i]=a[i+1];
                a[i+1]=tmp;
                flag=1;
            }
        }
        if(!flag) return;
    }
}

二、插入排序

#include <iostream>
#define MAXN 100001
using namespace std;

int a[MAXN];

void Insert_Sort(int* a,int N){
   int j;
   for(int i=1;i<N;i++){
       int tmp=a[i];
       for(j=i-1;j>=0;j--){
           if(a[j]>tmp) a[j+1]=a[j];//往后挪
           else break;
       }
       a[j+1]=tmp;//一定要一开始就存一下a[i]，不然第一次挪位置a[i]就丢了
   }
}

三、希尔排序

#include <iostream>
#define MAXN 100001
using namespace std;

int a[MAXN];

void Shell_Sort(int* a,int N){
   int j,D,Si;
   int Sedgewick[] = {929, 505, 209, 109, 41, 19, 5, 1, 0};
   for(Si=0;Sedgewick[Si]>=N;Si++);
    /* 初始的增量Sedgewick[Si]不能超过待排序列长度 */

    for(D=Sedgewick[Si];D>0;D=Sedgewick[++Si]){
         for(int i=D;i<N;i++){
            //每次第0张已经在手上，从第D张开始
                int tmp=a[i];
                for(j=i-D;j>=0;j-=D){
            //第D张前面一张开始比较
                    if(a[j]>tmp){
                        a[j+D]=a[j];
                    }else break;
                }
                a[j+D]=tmp;
         }
    }
   
}

 四、选择排序

#include <iostream>
#define MAXN 100001
using namespace std;

int a[MAXN];

void Select_Sort(int* a,int N){
    for(int i=0;i<N;i++){
        //FindMin
        int min=a[N-1],minId=N-1;
        for(int j=i;j<N;j++){
            if(a[j]<min){
                min=a[j];
                minId=j;
            }
        }
        //SwapMin
        int t=a[minId];
        a[minId]=a[i];
        a[i]=t;
    }
}

五、堆排序 

#include <iostream>
#define MAXN 100001
using namespace std;

int a[MAXN];

//没有哨兵，a[i]中i是从0到N-1
void PerDown(int i,int N){
    int tmp=a[i];
    int parent,child;
    for(parent=i;(parent*2+1)<N;parent=child){
        child=parent*2+1;
        if((child!=N-1) && a[child+1]>a[child]){
            child++;
        }
        if(a[child]>tmp)    a[parent]=a[child];
        else                break;
    }
    a[parent]=tmp;
}

void Heap_Sort(int* a,int N){
//1:Build MaxHeap
    for(int i=N/2;i>=0;i--){
        PerDown(i,N);
    }
    for(int i=N-1;i>0;i--){
//2:swap Max to the end
        int t=a[i];
        a[i]=a[0];
        a[0]=t;
//3:adjust MaxHeap
//改变一个点只会改变一条路径
        PerDown(0,i);
    }
    
}

六、归并排序

Merge函数：实现两个内部有序的子序列的归并

//1：递归版
#include <iostream>
#define MAXN 100001
using namespace std;

int a[MAXN];

//两个有序子列的归并
void Merge(int* A,int* TmpA,int Left,int Right,int RightEnd){
    int LeftEnd=Right-1;
    int num=RightEnd-Left+1;
    int TmpA_p=Left;

    while ( Left<=LeftEnd && Right<=RightEnd){
        if(A[Left]<A[Right]) TmpA[TmpA_p++]=A[Left++];
        else                 TmpA[TmpA_p++]=A[Right++];
    }

    while(Left<=LeftEnd){
        TmpA[TmpA_p++]=A[Left++];
    }
    while(Right<=RightEnd){
        TmpA[TmpA_p++]=A[Right++];
    }

    for(int i=0;i<num;i++,RightEnd--){
        A[RightEnd]=TmpA[RightEnd];
    }
}

//分而治之
void MSort(int* A,int* TmpA,int Left,int RightEnd){
    int center;
    if(Left<RightEnd){
        center=(Left+RightEnd)/2;
        MSort(A,TmpA,Left,center);
        MSort(A,TmpA,center+1,RightEnd);
        Merge(A,TmpA,Left,center+1,RightEnd);
    }
}

void Merge_Sort(int* a,int N){
    int* TmpA=new int[N];
    if(TmpA){
        MSort(a,TmpA,0,N-1);
    }
    else printf("空间不足\n");  
}

//2：非递归版
#include <iostream>
#define MAXN 100001
using namespace std;

int a[MAXN];

void Merge1(int* A,int* TmpA,int Left,int Right,int RightEnd){
    int LeftEnd=Right-1;
    int num=RightEnd-Left+1;
    int TmpA_p=Left;

    while ( Left<=LeftEnd && Right<=RightEnd){
        if(A[Left]<A[Right]) TmpA[TmpA_p++]=A[Left++];
        else                 TmpA[TmpA_p++]=A[Right++];
    }

    while(Left<=LeftEnd){
        TmpA[TmpA_p++]=A[Left++];
    }
    while(Right<=RightEnd){
        TmpA[TmpA_p++]=A[Right++];
    }

//Merge1不用做Merge中将元素贴回原数组A的这一步
//归并结果存储在TmpA中

    /*for(int i=0;i<num;i++,RightEnd--){
        A[RightEnd]=TmpA[RightEnd];
    }*/
}

void Merge_pass(int* A,int* TmpA,int N,int length){
    int i;
//i是新子序列的首元素
    for(i=0;i<=N-2*length;i+=2*length){
        Merge1(A,TmpA,i,i+length,i+2*length-1);
    }
//最后是不是比一个length还多
//只要比一个length多1就是两个子列，可以归并
//第二个子列最后一个元素一定是A[N-1]
//不然的话只有一个子列只能贴在末尾(内部有序)
//等待最后一步使整个序列完全有序
    if(i+length<N){
        Merge1(A,TmpA,i,i+length,N-1);
    }else{
        for(int j=i;j<N;j++) TmpA[j]=A[j];
    }
}

void Merge_Sort(int* A,int N){
    int length=1;//初始化子序列长度

    int* TmpA=new int[N];
    if(TmpA){
        while(length<N){
            Merge_pass(A,TmpA,N,length);
            length*=2;
            Merge_pass(TmpA,A,N,length);
            length*=2;
        }
        delete(TmpA);
    }
    else printf("空间不足\n");  
}

七、快速排序

#include <iostream>
#define MAXN 100001
using namespace std;

//或者直接用库函数swap(int,int)也行
void swap1(int* a,int* b){
    int t=*a;
    *a=*b;
    *b=t;
}

void Insertion_Sort(int* a,int N){
    int j;
    int tmp;
    for(int i=1;i<N;i++){
        tmp=a[i];
        for(j=i-1;j>=0;j--){
            if(a[j]>tmp) a[j+1]=a[j];
            else         break;
        }
        a[j+1]=tmp;
    }
}


int Median3(int* a,int Left,int Right){
    int center=(Left+Right)/2;
    if(a[center]<a[Left])  swap1(&a[center],&a[Left]);
    if(a[Left]>a[Right])   swap1(&a[Left],&a[Right]);
    if(a[center]>a[Right]) swap1(&a[center],&a[Right]);
    
    swap1(&a[Right-1],&a[center]);
    return a[Right-1];
}

void QSort(int* a,int Left,int Right){
    int Cutoff=200;
//Cutoff不能取1，算High会越界
    if(Cutoff<=Right-Left){
        int Pivot=Median3(a,Left,Right);
        //Pivot主元的值
        int Low=Left,High=Right-1;
        while(1){
            while(a[++Low]<Pivot) ;
            while(a[--High]>Pivot);
            if(Low<High) swap1(&a[Low],&a[High]);
            else break;
        }
        //Low是正确的主元位置
        swap1(&a[Low],&a[Right-1]);
        
        QSort(a,Left,Low-1);
        QSort(a,Low+1,Right);
    }
    else Insertion_Sort(a+Left,Right-Left+1);
}

void Quick_Sort(int* a,int N){
    QSort(a,0,N-1);
}
#include<stdio.h>
#include<stdlib.h>
int a[1010];
int n;
void partition(int begin,int last){
 if(begin>=last) return;
    
 int key=a[begin];
 int left=begin,right=last;
 while(1){
    while(a[right]>key){
        if((right-1)>=begin) right--;
        else break;
    }
    while(a[left]<=key){
        if(left+1<=last) left++;
        else break;
    }
    if(left<right){
        int t=a[left];
        a[left]=a[right];
        a[right]=t;
    }else break;
 }
 a[begin]=a[right];
 a[right]=key;


 for(int i=0;i<n;i++){
        printf("%d ",a[i]);
 }
 printf("\n");
 
 partition(begin,right-1);
 partition(right+1,last);
}

int main(){
 scanf("%d",&n);
 for(int i=0;i<n;i++){
  scanf("%d",&a[i]); 
 }

 
 partition(0,n-1);
  
  for(int i=0;i<n;i++){
     printf("%d ",a[i]);
}
 
 return 0;
}

八、基数排序

  

//版本1：只适用于0和正整数大小，没法比较负数
#include <iostream>
#define MAXN 100001
using namespace std;

#define MaxDigit 10//最大MaxDigit位数，最多MaxDigit个关键字
#define Radix 10  //进制基数,桶数量

struct node
{
    int key;
    node* next;
};

struct HeadNode{
    node* head;
    node* tail;
};
typedef HeadNode Bucket[Radix];//Radix个桶

int GetDigit(int x,int D){
//获取x第D次位上的数
    int d;
    for(int i=1;i<=D;i++){
        d=x%Radix;
        x/=Radix;
    }
    return d;
}

void Radix_LSD_Sort(int* a,int N){
    Bucket B;
    //初始化每个桶为空链表
    for(int i=0;i<Radix;i++){
        B[i].head=B[i].tail=NULL;
    }
    //将初始待排序列逆序存入初始链表List
    node* List=NULL;
    node* tmp;
    for(int i=0;i<N;i++){
        tmp=new node;
        tmp->key=a[i];
        tmp->next=List;
        List=tmp;
    }

    //开始排序
    int Di;
    for(int D=1;D<=MaxDigit;D++){//对每个次位依次处理
        node* p=List;
        while(p){
            //获得当前元素(p->key)的当前位(D)上数字
            Di=GetDigit(p->key,D);
            //从List中摘除,此时p为头结点，只需要指向下一个就行了
            tmp=p;p=p->next;
            tmp->next=NULL;
            //插入B[Di]号桶尾
            if(B[Di].head==NULL) B[Di].head=B[Di].tail=tmp;//当为空桶时
            else{
                B[Di].tail->next=tmp;
                B[Di].tail=tmp;
            }
        }
        //收集本轮排序结果过程
        List=NULL;//重复利用List
        for(int Di=Radix-1;Di>=0;Di--){
            //如果桶不为空,整桶倒插进List
            if(B[Di].head){
                B[Di].tail->next=List;
                List=B[Di].head;
                B[Di].head=B[Di].tail=NULL;
            }
        }
    }
    //将最终排序结果List倒入a,并释放空间
    for(int i=0;i<N;i++){
        tmp=List;
        List=List->next;
        a[i]=tmp->key;
        delete tmp;
    }

}

//版本2：支持负数的基数排序
//利用偏移量，注意修改最大位数
//为了防止溢出，可能还需要修改key的类型
#include <iostream>
#define MAXN 100001
using namespace std;

#define keyType long long int
#define OFFSET 10000000000
#define MaxDigit 13//最大MaxDigit位数，最多MaxDigit个关键字
#define Radix 10  //进制基数,桶数量

struct node
{
    keyType key;
    node* next;
};

struct HeadNode{
    node* head;
    node* tail;
};
typedef HeadNode Bucket[Radix];//Radix个桶

int GetDigit(keyType x,int D){
//获取x第D次位上的数
    int d;
    for(int i=1;i<=D;i++){
        d=x%Radix;
        x/=Radix;
    }
    return d;
}

void Radix_LSD_Sort(int* a,int N){
    Bucket B;
    //初始化每个桶为空链表
    for(int i=0;i<Radix;i++){
        B[i].head=B[i].tail=NULL;
    }
    //将初始待排序列逆序存入初始链表List
    node* List=NULL;
    node* tmp;
    for(int i=0;i<N;i++){
        tmp=new node;
        tmp->key=a[i]+OFFSET;
        tmp->next=List;
        List=tmp;
    }

    //开始排序
    int Di;
    for(int D=1;D<=MaxDigit;D++){//对每个次位依次处理
        node* p=List;
        while(p){
            //获得当前元素(p->key)的当前位(D)上数字
            Di=GetDigit(p->key,D);
            //从List中摘除,此时p为头结点，只需要指向下一个就行了
            tmp=p;p=p->next;
            tmp->next=NULL;
            //插入B[Di]号桶尾
            if(B[Di].head==NULL) B[Di].head=B[Di].tail=tmp;//当为空桶时
            else{
                B[Di].tail->next=tmp;
                B[Di].tail=tmp;
            }
        }
        //收集本轮排序结果过程
        List=NULL;//重复利用List
        for(Di=Radix-1;Di>=0;Di--){
            //如果桶不为空,整桶倒插进List
            if(B[Di].head){
                B[Di].tail->next=List;
                List=B[Di].head;
                B[Di].head=B[Di].tail=NULL;
            }
        }
    }
    //将最终排序结果List倒入a,并释放空间
    for(int i=0;i<N;i++){
        tmp=List;
        List=List->next;
        a[i]=tmp->key-OFFSET;
        delete tmp;
    }

}

int main(){
    int N;
    int a[MAXN];
    scanf("%d",&N);

    for(int i=0;i<N;i++){
        scanf("%d",&a[i]);
    }
    
    Radix_LSD_Sort(a,N);
    
    int flag=0;
    for(int i=0;i<N;i++){
        if(flag) printf(" %d",a[i]);
        else{
            printf("%d",a[i]);
            flag=1;
        }
    }
    
    system("pause");
    return 0;
}

您可能感兴趣的与本文相关的镜像

ACE-Step

ACE-Step

音乐合成
ACE-Step

ACE-Step是由中国团队阶跃星辰（StepFun）与ACE Studio联手打造的开源音乐生成模型。 它拥有3.5B参数量，支持快速高质量生成、强可控性和易于拓展的特点。 最厉害的是，它可以生成多种语言的歌曲，包括但不限于中文、英文、日文等19种语言

pta冒泡法排序
小缪的博客
11-29 3860
pta冒泡法排序 输入1个正整数n（1<=n<=10），然后输入n个整数并存放在数组中，将这n个整数从大到小排序后输出，相邻数字间有一个空格，行末不得有多余空格。 输入格式: 输入第一行给出一个不超过10的正整数n。第二行给出n个整数，其间以空格分隔。 输出格式: 在一行中输出从大到小有序的数列，相邻数字间有一个空格，行末不得有多余空格。 输入样例: 4 75 71 77 76 结尾无空行 输出样例: 77 76 75 71 结尾无空行 #include <stdio.h> in
PTA-冒泡排序法(C++)
LittleBiscu1t的博客
04-07 3738
本题要求使用冒泡法排序，将给定的n个整数从小到大排序后输出，并输出排序过程中每一步的中间结果。 冒泡排序的算法步骤描述如下： 第1步：在未排序的n个数（a[0]〜 a[n−1]）中，从a[0]起，依次比较相邻的两个数，若邻接元素不符合次序要求，则对它们进行交换。本次操作后，数组中的最大元素“冒泡”到a[n−1]； 第2步：在剩下未排序的n−1个数（a[0] 〜 a[n−2]）中，从a[0]起，依次...
PTA字符串冒泡排序（C语言版）
06-18
7-3 字符串的冒泡排序 (20分) 我们已经知道了将N个整数按从小到大排序的冒泡排序法。本题要求将此方法用于字符串序列，并对任意给定的K（<N），输出扫描完第K遍后的中间结果序列。 输入格式： 输入在第1行中给出N和K（1≤K<N≤100），此后N行，每行包含一个长度不超过10的、仅由小写英文字母组成的非空字符串。 输出格式： 输出冒泡排序法扫描完第K遍后的中间结果序列，每行包含一个字符串。 输入样例： 6 2 best cat east a free day 输出样例： best a cat day east free
7-27 冒泡法排序 (20分)
GJINW的博客
11-17 5871
将N个整数按从小到大排序的冒泡排序法是这样工作的：从头到尾比较相邻两个元素，如果前面的元素大于其紧随的后面元素，则交换它们。通过一遍扫描，则最后一个元素必定是最大的元素。然后用同样的方法对前N−1个元素进行第二遍扫描。依此类推，最后只需处理两个元素，就完成了对N个数的排序。 本题要求对任意给定的K（<N），输出扫描完第K遍后的中间结果数列。 输入格式： 输入在第1行中给出N和K（1≤K<N≤100），在第2行中给出N个待排序的整数，数字间以空格分隔。 输出格式： 在一行中输出冒泡排序法扫描完第K
PTA 排序（冒泡，插入，希尔，堆排序，归并排序）
abyss_miracle的博客
04-19 3052
介绍了五种常见排序方法，每种方法各有利弊。 1.冒泡排序 一个指针一开始指向最后一个位置，将之前两两比较出来的最大的那个值一步步交换到这个位置上。并且加入监控是否全程没有发生交换的变量flag，可以提前终止循环，代表完成了排序。 /*冒泡排序*/ void Bubble_sort(long a[], int N) { int flag;//一趟冒泡是否发生交换 for (int P = N -...
吉林大学数据结构pta排序算法
最新发布
02-28
### 吉林大学数据结构课程 PTA 平台排序算法练习题资源 #### 关于吉林大学数据结构课程PTA平台上的排序算法题目或资料的信息 在吉林大学的数据结构课程中，通过PTA平台进行编程实践是一个重要的组成部分。对于排序...
PTA 数据结构与算法 7-37 模拟EXCEL排序
番大白菜
04-27 2750
第一次写文章 不喜勿喷~ 写这个是因为自己在学习数据结构的时候去网上找的答案大部分都是C++的 但是没有C的 这让用C写的我非常崩溃 所以在写完之后想要把自己的C代码和大家分享一下 下面进入正题 7-37 Excel可以对一组纪录按任意指定列排序。现请编写程序实现类似功能。 输入格式: 输入的第一行包含两个正整数N(≤10 ​5 ​​ ) 和C，其中N是纪录的条数，C是指定排序的列号。之后有 N行...
算法学习:归并排序， pta归并排序（递归法）
RikkaNeko的博客
10-20 893
方法： 1、将序列中待排序的数字分为若干组，每个数字为一组 2、将这些组两两合并，使合并后的新序列是有序的 3、重复2的操作直到合并到最后一组 代码： void Merge(SqList L,int low,int m,int high) { int i,j,k; i=low; j=m+1; k=0; int * a; a=L.r; int * r=new int...
PTA(每日一题)7-21 递归算法实现冒泡排序算法的函数MpSort
会写bug的小邓程序员的博客
05-29 1898
定义一个函数MpSort实现对一组数据的从小大排序。编写程序，实现读入若干个整数存入合适的数据结构类型的对象中。再调用MpSort函数，对该对象中的元素进行排序后输出。
PTA 7-5 字符串排序 算法改进
m0_73989054的博客
03-15 2014
总体解析：此算法通过先选取一个参考值然后再分区，将比这个数大的数全放在它的右边，小于或等于全放在左边，再对左右区间重复分区，直至区间仅一个数。定义一个二维数组，由于题目自身只会给出五个字符串，为减少数组量，将一个数组既用于排序又用于存储缓存量，此外字符串最长为。定义一个二维数组，由于题目自身只会给出五个字符串，为减少数组量，将一个数组既用于排序又用于存储缓存量，此外字符串最长为。由前向后找比它大的数，找到后也挖出此数填到前一个坑。由后向前找比它小的数，找到后挖出此数填前一个坑。个不同整数，每个整数最小为。
PTA 排序（快速排序，基数排序）
abyss_miracle的博客
04-22 4504
快速排序 在一堆数中选取一个主元，以主元为中心将这堆数分为大小两部分，对这两部分递归调用快排，最后当规模最够小的时候（小于预设的阈值CutOff）将使用简单排序（如插入排序）。 /*快速排序*/ //取主元 get pivot long Median3(long a[], long Left, long Right) { int Center = (Right +Left)/2; if (a[...
PTA 排序 思路分析及代码解析
thexiaosi的博客
03-12 2234
介绍了 冒泡排序、插入排序、选择排序、希尔排序、合并排序、堆排序基本的实现思路
PTA 排序
mmmjtt的博客
02-22 4875
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-冒泡法排序
m0_74316503的博客
11-28 1612
总体来说，这是一个简单的冒泡排序实现，可以对数组的部分元素进行排序，并在排序后打印出这些元素。
PTA学习笔记-------------排序
qq_42217263的博客
03-17 438
6-11 求自定类型元素序列的中位数 （25 分) 本题要求实现一个函数，求N个集合元素A[]的中位数，即序列中第⌊N/2+1⌋大的元素。其中集合元素的类型为自定义的ElementType。 函数接口定义： ElementType Median( ElementType A[], int N ); 其中给定集合元素存放在数组A[]中，正整数N是数组元素个数。该函数须返回N个A[]元素的中位数，其...
PTA 天梯赛 7-41 PAT排名汇总 (25 point(s))
忘梦心的博客
09-01 2516
7-41 PAT排名汇总 (25 point(s)) 计算机程序设计能力考试（Programming Ability Test，简称PAT）旨在通过统一组织的在线考试及自动评测方法客观地评判考生的算法设计与程序设计实现能力，科学的评价计算机程序设计人才，为企业选拔人才提供参考标准（网址http://www.patest.cn）。 每次考试会在若干个不同的考点同时举行，每个考点用局域网，产生本考点的...
[PTA]7-27 冒泡法排序
Spring-_-Bear 的 优快云 博客
09-08 865
将 N 个整数按从小到大排序的冒泡排序法是这样工作的：从头到尾比较相邻两个元素，如果前面的元素大于其紧随的后面元素，则交换它们。通过一遍扫描，则最后一个元素必定是最大的元素。然后用同样的方法对前 N−1 个元素进行第二遍扫描。依此类推，最后只需处理两个元素，就完成了对 N 个数的排序。本题要求对任意给定的 K（< N），输出扫描完第 K 遍后的中间结果数列。
PTA 冒泡排序
diosamaehjs的博客
11-04 1899
首先代码从输入中读取一个整数n，表示要排序的元素数量，然后依次读取n个整数到数组a中。接下来，它执行三次冒泡排序，每次排序都将数组中的元素按升序排列，不正确就交换它们，通过不断地进行比较和交换，每次循环结束后，最大的元素就会被放置在数组的最右边。最后，程序就会输出三次的排列数组。输出三行，第一行为第一轮排序结果，第二行为第二轮排序结果，第三行为第三轮排序结果。本题目要求读入N个整数，采用冒泡排序（上升法，即每轮得到一个最小值）进行排序，输出前3轮排序后的结果。为简便起见，最后一个元素后也有一个空格。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值