排序

最新推荐文章于 2022-04-27 23:04:16 发布
最新推荐文章于 2022-04-27 23:04:16 发布
阅读量98 收藏
点赞数
文章标签： 排序 C语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44979863/article/details/103103158
版权

排序

归并排序

void merge(int a[],int l1,int r1,int l2,int r2)//合并两个区间
{
    int i=l1;
    int j=l2;
    int temp[100];
    int index=0;
    while(i<=r1&&j<=r2)//分别从两端开始
    {
        if(a[i]<=a[j]) temp[index++]=a[i++];
        else temp[index++]=a[j++];
    }
    while(i<=r1) temp[index++]=a[i++];
    while(j<=r2) temp[index++]=a[j++];
    for(int i=0;i<index;i++)
    {
        a[l1+i]=temp[i];
    }
}
void mergesort(int a[],int left,int right)
{
    if(left<right) 
    {
        int mid=(left+right)/2;
        mergesort(a,left,mid);//递归二分
        mergesort(a,mid+1,right);
        merge(a,left,mid,mid+1,right);//合并
    }
}

快速排序

int position(int  a[],int left,int right)//寻找主元
{
int temp=a[left];//把最左边的元素给临时变量
while(left<right)//temp左边元素小于等于temp，右边元素大于temp
{
while(left<right&&temp<a[right]) right--;
a[left]=a[right];
while(left<right&&temp>=a[left]) left++;
a[right]=a[left];
}
a[left]=temp;
return left;返回left位置
}
void quicksort(int a[],int left,int right)
{
if(left<right)
{
int pos=postion(a,left,right);
quicksort(a,left,pos-1);//对左子区间递归排序
quicksort(a,pos+1,right);
}
}

快速排序题目-PAT

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

例如给定 N = 5 N = 5 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

代码：

#include <cstdio>
#include <algorithm>
#include <vector>
using namespace std;
int main()
{
    int N;
    int judge[100000][2]={0,0};//数组一维存数，二维判断
    vector<int>v;
    int min=0;
    int max=1000000001;
    scanf("%d",&N);
    for(int i=0;i<N;i++)
    {
        scanf("%d",&judge[i][0]);
        if(judge[i][0]>min)//若大于左边的数，二维++
        {
            min=judge[i][0];
            judge[i][1]++;
        }
    }
    for(int i=N-1;i>=0;i--)
    {
        if(judge[i][0]<max)//若小于右边的数，二维++
        {
            max=judge[i][0];
            judge[i][1]++;
        }
        if(judge[i][1]==2)//若满足条件，将此数入vector
        v.push_back(judge[i][0]);
    }
    sort(v.begin(),v.end());
    printf("%d\n",v.size());
    for(int i=0;i<v.size();i++)
    {
            printf("%d%c",v[i],i==v.size()-1?'\n':' ');
    }
    if(!v.size())
    printf("\n");
    return 0;
}

冒泡排序

1.	#include <cstdio>  
2.	void BubbleSort(int a[], int n)  
3.	{  
4.	    for (int i = 0; i < n - 1; i++)  
5.	    {  
6.	        for (int j = 0; j < n - i - 1; j++)  
7.	        {  
8.	            if (a[j] > a[j + 1])  
9.	            {  
10.	                int temp = a[j];  
11.	                a[j] = a[j + 1];  
12.	                a[j + 1] = temp;  
13.	            }  
14.	        }  
15.	    }  
16.	    return;  
17.	}  
18.	int main()  
19.	{  
20.	    int n;  
21.	    scanf_s("%d", &n);  
22.	    int a[100];  
23.	    for (int i = 0; i < n; i++)  
24.	    {  
25.	        scanf_s("%d", &a[i]);  
26.	    }  
27.	    BubbleSort(a, n);  
28.	    for (int i = 0; i < n; i++)  
29.	    {  
30.	        printf("%d\n", a[i]);  
31.	    }  
32.	    return 0;  
33.	}

选择排序

1.	#include <cstdio>  
2.	void SelectSort(int a[], int n)  
3.	{  
4.	    int k;  
5.	    for (int i = 0; i < n ; i++)  
6.	    {  
7.	        k = i;  
8.	        for (int j = i; j < n; j++)  
9.	        {  
10.	            if (a[j] < a[k])  
11.	            {  
12.	                k = j;  
13.	            }  
14.	        }  
15.	                int temp = a[i];  
16.	                a[i] = a[k];  
17.	                a[k] = temp;  
18.	    }  
19.	    return;  
20.	}  
21.	int main()  
22.	{  
23.	    int n;  
24.	    scanf_s("%d", &n);  
25.	    int a[100];  
26.	    for (int i = 0; i < n; i++)  
27.	    {  
28.	        scanf_s("%d", &a[i]);  
29.	    }  
30.	    SelectSort(a, n);  
31.	    for (int i = 0; i < n; i++)  
32.	    {  
33.	        printf("%d\n", a[i]);  
34.	    }  
35.	    return 0;  
36.	}

插入排序

1.	#include <cstdio>  
2.	void InsertSort(int a[], int n)  
3.	{  
4.	    int j; int temp;  
5.	    for (int i = 1; i < n ; i++)  
6.	    {  
7.	        j = i; temp = a[j];  
8.	        while (j > 0 && temp< a[j - 1])  
9.	        {  
10.	            a[j] = a[j - 1];  
11.	            j--;  
12.	        }  
13.	        a[j] = temp;  
14.	    }  
15.	    return;  
16.	}  
17.	int main()  
18.	{  
19.	    int n;  
20.	    scanf_s("%d", &n);  
21.	    int a[100];  
22.	    for (int i = 0; i < n; i++)  
23.	    {  
24.	        scanf_s("%d", &a[i]);  
25.	    }  
26.	    InsertSort(a, n);  
27.	    for (int i = 0; i < n; i++)  
28.	    {  
29.	        printf("%d\n", a[i]);  
30.	    }  
31.	    return 0;  
32.	}

STL标准模板库

#include <algorithm>
using namespace std;
bool cmp();
sort();

成绩排名

读入 n（>0）名学生的姓名、学号、成绩，分别输出成绩最高和成绩最低学生的姓名和学号。

输入格式：

每个测试输入包含 1 个测试用例，格式为

第 1 行：正整数 n
第 2 行：第 1 个学生的姓名 学号 成绩
第 3 行：第 2 个学生的姓名 学号 成绩
… … …
第 n+1 行：第 n 个学生的姓名 学号 成绩
其中姓名和学号均为不超过 10 个字符的字符串，成绩为 0 到 100 之间的一个整数，这里保证在一组测试用例中没有两个学生的成绩是相同的。

输出格式：

对每个测试用例输出 2 行，第 1 行是成绩最高学生的姓名和学号，第 2 行是成绩最低学生的姓名和学号，字符串间有 1 空格。

输入样例：

3
Joe Math990112 89
Mike CS991301 100
Mary EE990830 95

输出样例：

Mike CS991301
Joe Math990112

#include <cstdio>
struct student
{
    char name[11];
    char id[11];
    int score;
}stu[100],min,max;
int main()
{
    int n;
    max.score=-1;
    min.score=101;
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
        getchar();
        scanf("%s %s %d",stu[i].name,stu[i].id,&stu[i].score);
        if(stu[i].score<min.score) min=stu[i];
        if(stu[i].score>max.score) max=stu[i];
    }
    printf("%s %s\n%s %s",max.name,max.id,min.name,min.id);
    return 0;
}

德才论

宋代史学家司马光在《资治通鉴》中有一段著名的“德才论”：“是故才德全尽谓之圣人，才德兼亡谓之愚人，德胜才谓之君子，才胜德谓之小人。凡取人之术，苟不得圣人，君子而与之，与其得小人，不若得愚人。”

现给出一批考生的德才分数，请根据司马光的理论给出录取排名。

输入格式：

输入第一行给出 3 个正整数，分别为：N（≤10
​5
​​ ），即考生总数；L（≥60），为录取最低分数线，即德分和才分均不低于 L 的考生才有资格被考虑录取；H（<100），为优先录取线——德分和才分均不低于此线的被定义为“才德全尽”，此类考生按德才总分从高到低排序；才分不到但德分到线的一类考生属于“德胜才”，也按总分排序，但排在第一类考生之后；德才分均低于 H，但是德分不低于才分的考生属于“才德兼亡”但尚有“德胜才”者，按总分排序，但排在第二类考生之后；其他达到最低线 L 的考生也按总分排序，但排在第三类考生之后。

随后 N 行，每行给出一位考生的信息，包括：准考证号 德分 才分，其中准考证号为 8 位整数，德才分为区间 [0, 100] 内的整数。数字间以空格分隔。

输出格式：

输出第一行首先给出达到最低分数线的考生人数 M，随后 M 行，每行按照输入格式输出一位考生的信息，考生按输入中说明的规则从高到低排序。当某类考生中有多人总分相同时，按其德分降序排列；若德分也并列，则按准考证号的升序输出。

输入样例：

14 60 80
10000001 64 90
10000002 90 60
10000011 85 80
10000003 85 80
10000004 80 85
10000005 82 77
10000006 83 76
10000007 90 78
10000008 75 79
10000009 59 90
10000010 88 45
10000012 80 100
10000013 90 99
10000014 66 60

输出样例：

12
10000013 90 99
10000012 80 100
10000003 85 80
10000011 85 80
10000004 80 85
10000007 90 78
10000006 83 76
10000005 82 77
10000002 90 60
10000014 66 60
10000008 75 79
10000001 64 90

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
struct student
{
    int id;
    int de;
    int cai;
    int flag;
    int sum;
}stu[100010];
bool cmp(student a,student b)
{
    if(a.flag!=b.flag) return a.flag<b.flag;
    else if(a.sum!=b.sum) return a.sum>b.sum;
    else if(a.de!=b.de) return a.de>b.de;
    else return a.id<b.id;
}
int main()
{
    int n,l,h;
    scanf("%d%d%d",&n,&l,&h);
    int m=n;
    for(int i=0;i<n;i++)
    {
        scanf("%d %d %d",&stu[i].id,&stu[i].de,&stu[i].cai);
        stu[i].sum=stu[i].de+stu[i].cai;
        if(stu[i].de<l||stu[i].cai<l) 
        {
            stu[i].flag=5;
            m--;
        }
        else if(stu[i].de>=h&&stu[i].cai>=h) stu[i].flag=1;
        else if(stu[i].de>=h&&stu[i].cai<h) stu[i].flag=2;
        else if(stu[i].de>=stu[i].cai) stu[i].flag=3;
        else stu[i].flag=4;
    }
    sort(stu,stu+n,cmp);
    printf("%d\n",m);
    for(int i=0;i<m;i++)
    {
        printf("%d %d %d\n",stu[i].id,stu[i].de,stu[i].cai);
    }
    return 0;
}

PAT Ranking

Programming Ability Test (PAT) is organized by the College of Computer Science and Technology of Zhejiang University. Each test is supposed to run simultaneously in several places, and the ranklists will be merged immediately after the test. Now it is your job to write a program to correctly merge all the ranklists and generate the final rank.

Input Specification:

Each input file contains one test case. For each case, the first line contains a positive number N (≤100), the number of test locations. Then N ranklists follow, each starts with a line containing a positive integer K (≤300), the number of testees, and then K lines containing the registration number (a 13-digit number) and the total score of each testee. All the numbers in a line are separated by a space.

Output Specification:

For each test case, first print in one line the total number of testees. Then print the final ranklist in the following format:

registration_number final_rank location_number local_rank
The locations are numbered from 1 to N. The output must be sorted in nondecreasing order of the final ranks. The testees with the same score must have the same rank, and the output must be sorted in nondecreasing order of their registration numbers.

Sample Input:

2
5
1234567890001 95
1234567890005 100
1234567890003 95
1234567890002 77
1234567890004 85
4
1234567890013 65
1234567890011 25
1234567890014 100
1234567890012 85
Sample Output:
9
1234567890005 1 1 1
1234567890014 1 2 1
1234567890001 3 1 2
1234567890003 3 1 2
1234567890004 5 1 4
1234567890012 5 2 2
1234567890002 7 1 5
1234567890013 8 2 3
1234567890011 9 2 4

代码：

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
struct student
{
    char name[20];
    int score,locrank,rank,loc;
}stu[60000];
bool cmp(student a,student b)
{
    if(a.score!=b.score) return a.score>b.score;
    else return strcmp(a.name,b.name)<0;
}
int main()
{
    int n;
    scanf("%d",&n);
    int m;
    int num=0;
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&m);
        for(int j=0;j<m;j++)
        {
            scanf("%s%d",stu[num].name,&stu[num].score);
            stu[num].loc=i;
            num++;
        }
        sort(stu+num-m,stu+num,cmp);
        stu[num-m].locrank=1;
        for(int j=num-m+1;j<num;j++)
        {
            if(stu[j].score==stu[j-1].score)
            stu[j].locrank=stu[j-1].locrank;
            else stu[j].locrank=j+1-(num-m);
        }
    }
    printf("%d\n",num);
    sort(stu,stu+num,cmp);
    int r=1;
    for(int i=0;i<num;i++)
    {
        printf("%s ",stu[i].name);
        if(i>0&&stu[i].score!=stu[i-1].score)
        r=i+1;
        stu[i].rank=r;
        printf("%d %d %d\n",stu[i].rank,stu[i].loc,stu[i].locrank);
    }
    return 0;
}

注：上篇代码来自

版权声明：本文为CSDN博主「负负」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/m0_37377504/article/details/77898150

其中多数代码来自胡凡大神-《算法笔记》，抱着学习的态度总结排序，如有介意，联系删除

 Ywain Xu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
排序查询
12-14
排序查询按单个字段排序按表达式 / 别名排序按函数排序按多个字段排序 排序查询：SELECT 查询列表 FROM 表 WHERE 筛选条件 ORDER BY 排序列表(ASC/DESC) AEC/DESC = 升序/降序，默认为升序 ORDER BY 支持单个字段、...
《数据结构与算法分析python版》第七周编程作业
Fighting_Du的博客
05-01 558
《数据结构与算法分析python版》第七周编程作业 1、快速排序主元 题目内容： 著名的快速排序算法里有一个经典的划分过程：我们通常采用某种方法取一个元素作为主元（中值），通过交换，把比主元小的元素放到它的左边，比主元大的元素放到它的右边。 给定划分后的N个互不相同的正整数的排列，请问有多少个元素可能是划分前选取的主元 例如给定的排列是[1, 3, 2, 4, 5]。则： 1 的左边没有元素，右边...
六大排序算法：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序
HanMeng的博客
07-24 55万+
文章目录：1. 插入排序2.希尔排序 1. 插入排序 步骤： 1.从第一个元素开始，该元素可以认为已经被排序 2.取下一个元素tem，从已排序的元素序列从后往前扫描 3.如果该元素大于tem，则将该元素移到下一位 4.重复步骤3，直到找到已排序元素中小于等于tem的元素 5.tem插入到该元素的后面，如果已排序所有元素都大于tem，则将tem插入到下标为0的位置 6.重复步骤2~5 动图演示如下： 思路：   在待排序的元素中，假设前n-1个元素已有序，现将第n个元素插入到前面已经排好的序列中，使得前n个
C++ sort()排序详解
晴空๓
05-05 37万+
本文对C++中的sort()做了一个比较详细的说明，包括为什么选择使用sort()、sort()函数的实现原理、sort()的使用方法等等。
C语言——冒泡排序
记录学习点滴
03-13 41万+
冒泡排序的原理是：从左到右，相邻元素进行比较。每次比较一轮，就会找到序列中最大的一个或最小的一个。这个数就会从序列的最右边冒出来。 以从小到大排序为例，第一轮比较后，所有数中最大的那个数就会浮到最右边；第二轮比较后，所有数中第二大的那个数就会浮到倒数第二个位置……就这样一轮一轮地比较，最后实现从小到大排序。 代码如下 #include<stdio.h> void BBsort(int arr[], int size) { int j,i,tem; for (i = 0; i ..
快速排序详解
LiangXiay的博客
11-19 11万+
1.什么是快速排序 我们知道排序有很多种，常见的如希尔排序，插入排序，选择排序，堆排序等等，而快速排序也是排序家族中的一员。因为其在大多数情况下有着优秀的综合性能，快速排序的快速也算是实至名归，接下来就为大家讲解快速排序的思想与实现。 2.快速排序的核心思想 快速排序通过多次比较与交换来完成排序。而这个过程又被分为了多次重复单趟排序，接下来我们先从每一趟的排序讲起。 快速排序的单趟排序思想是： 在一个无序数组中取一个数key，每一趟排序的最终目的是：让key的左边的所有数小于key，key的右边都
常用十大排序算法
qq_51664685的博客
04-26 12万+
列举了常见的十大内部排序算法：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序，计数排序，桶排序。
【数据结构】八大排序(超详解+附动图+源码)
Edward_Asia的博客
11-21 7万+
前言 所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。 生活中各种地方都需要用到排序，所以学好排序算法是非常重要的。 排序分为 内部排序 和 外部排序。 内部排序：数据元素全部放在内存中的排序。外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。 这部分主要是内部排序。排序讲解都以升序为例。 常见的排序算法： // 排序实现的接口 // 插入排序 void InsertSort(int* arr..
C语言的5种简单排序算法
Finecsr的博客
04-27 5万+
基本概要： 本文主要介绍五种简单常用的排序算法：冒泡排序，快速排序，插入排序，选择排序，希尔排序，包括它们的基本思想和代码实现。值得一说的是：插入排序，冒泡排序，选择排序平均情况下的时间复杂度为，因此在排序数据较少的情况下较好；而希尔排序和快速排序的平均时间复杂度为，因此在排序数据较多的情况下较好，但是对于快速排序而言，数据基本有序时反而不好，接下来会详细阐述。 1.冒泡排序（Bubble Sort） 基本思想： 冒泡排序是一个非常好理解的排序，顾名思义——冒泡，此时将要排序的数据从上至下排列，从最
快速排序法（详解）
热门推荐
小白的博客
07-01 57万+
假设对以下10个数进行快速排序： 6 1 2 7 9 3 4 5 10 8 我们先模拟快速排序的过程：首先，在这个序列中随便找一个数作为基准数，通常为了方便，以第一个数作为基准数。 6 1 2 7 9 3 4 5 10 8 在初始状态下，数字6在序列的第1位。我们的目标是将6挪到序列中间的某个位...
十大经典排序算法-归并排序算法详解
qq_35344198的博客
06-19 11万+
一、什么是归并排序 1.概念 归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法，归并排序对序列的元素进行逐层折半分组，然后从最小分组开始比较排序，合并成一个大的分组，逐层进行，最终所有的元素都是有序的 2.算法原理 这是一个无序数列：4、5、8、1、7、2、6、3，我们要将它按从小到大排序。按照归并排序的思想，我们要把序列逐层进行拆分 序列逐层拆分如下 然后从下往上逐层合并，首先对第一层序列1（只包含元素4）和序列2（只包含元素5）进行合并 创建一个大序列，序列长度为两个小序列长度
冒泡排序_冒泡排序_
09-30
C++实现冒泡排序，多层次，快速实现排序算法
排序算法（直接插入排序、折半排序、直接选择排序、快速排序与归并排序）
04-04
提供五种排序算法的C++实现方法，输入（待排序元素个数、排序码上界（采用随机生成数组方式）），可选择输出（原始数组、排序后数组、原始数组有序度和无序度、排序过程中数据比较次数与数据移动次数、数组中出现...
关键字排序
06-02
多关键字排序
帆软：排序问题（通过帆软设置或者sql排序）
02-26
帆软：排序问题（通过帆软设置或者sql排序） 测试文件 + sql 脚本
什么是mysql安装配置教程以及学习mysql安装配置教程的意义
05-21
mysql安装配置教程
【光伏预测】基于BP神经网络实现光伏发电功率预测附Matlab代码.zip
最新发布
05-21
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
onlyoffice搭建及与alist使用的view.html
05-21
onlyoffice搭建及与alist使用的view.html
android-support-v7-recyclerview 添加错误
05-21
1.Project Structure中添加依赖时，容易添加不进去，所以使用本地添加，将android-support-v7-recyclerview放在对应项目的lib文件中，并add as library。如果在build.gradle中出现implementation files('libs\\android-support-v7-recyclerview.jar')就算是添加成功。 2.在布局文件中使用 androidx 的布局控件，在逻辑代码文件中导入androidx相关包。（取代android.support.v7） 3.在gradle.properties文件中，注释android.enableJetifier=true。(# android.enableJetifier=true) 最新way2：
javascript排序
10-09
引用:在排序算法中，选择排序是一种简单直观的排序算法。它的基本思想是每次从未排序的部分选择出最小（或最大）的元素，放到已排序部分的末尾。选择排序的时间复杂度为O(n^2)。 引用:插入排序是一种简单直观的排序算法。它的基本思想是将待排序的数组分为已排序和未排序两个部分，每次从未排序的部分选择一个元素，插入到已排序的部分的适当位置。插入排序的时间复杂度为O(n^2)。 引用:快速排序是一种高效的排序算法。它的基本思想是选择一个基准元素，将数组分成左右两个部分，使得左边的元素都小于等于基准元素，右边的元素都大于等于基准元素。然后对左右两个部分进行递归排序。快速排序的平均时间复杂度为O(nlogn)。 所以，你可以使用以上三种排序算法来进行Javascript排序。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值