【考研机试刷题】3 排序与查找

3 排序与查找

排序与查找可以说是计算机领域最经典的问题，在考研机试真题中经常出现，本章旨在讲解一些经典问题的解题方法，使读者在日后面对此类问题时能够做到游刃有余。

查找部分介绍了两种简单的方法，即线性查找和二分查找，更为高效的查找方式将在关于数据结构章节介绍。

1 排序

例题3.1 排序

题目：

题目地址

描述：
对输入的n个数进行排序并输出。

输入描述：
输入的第一行包括一个整数n(1<=n<=100)。 接下来的一行包括n个整数。

输出描述：
可能有多组测试数据，对于每组数据，将排序后的n个整数输出，每个数后面都有一个空格。 每组测试数据的结果占一行。

示例：
输入：
4
1 4 3 2
输出：
1 2 3 4

题解：

#define	 _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <cstdio>
using namespace std;

bool cmp(int num1, int num2) {	// 返回 不发生交换的条件
	return num1 > num2;	//>降序，<升序
}

int main() {
	int n;
	int arr[101];
	while (scanf("%d", &n) != EOF) {
		for (int i = 0; i < n; i++) {
			scanf("%d", &arr[i]);
		}

		//+n不是+n-1，默认升序，如果降序就加上第3个参数，cmp
		sort(arr, arr + n);	
		for (int i = 0; i < n; i++) {
			printf("%d ", arr[i]);
		}
		printf("\n");
	}
}

笔记：

1. c++ sort函数详解，sort( left, right )中right传入的是“尾后”，即一个不存在的、最后一个元素的后一个位置
2. sort默认升序，若降序可重写bool类型函数cmp，cmp返回 不发生交换的条件

习题3.2 整数奇偶排序

题目：

题目地址

描述
输入10个整数，彼此以空格分隔。重新排序以后输出(也按空格分隔)，要求: 1.先输出其中的奇数,并按从大到小排列； 2.然后输出其中的偶数,并按从小到大排列。

输入描述：
任意排序的10个整数（0～100），彼此以空格分隔。

输出描述：
可能有多组测试数据，对于每组数据，按照要求排序后输出，由空格分隔。 1. 测试数据可能有很多组，请使用while(cin>>a[0]>>a[1]>>…>>a[9])类似的做法来实现; 2. 输入数据随机，有可能相等。

示例
输入：
4 7 3 13 11 12 0 47 34 98
输出：
47 13 11 7 3 0 4 12 34 98

题解：

#define	 _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <cstdio>
using namespace std;

bool cmp(int num1, int num2) {
	if (num1 % 2 == 1 && num2 % 2 == 0) {	//如果左数为奇数，右数为偶数，则不发生交换
		return true;
	}
	else if (num1 % 2 == 1 && num2 % 2 == 1 && num1 > num2) {	//如果左右数都为奇数，则降序排列
		return true;
	}
	else if (num1 % 2 == 0 && num2 % 2 == 0 & num1 < num2) {	//如果左右数都为偶数，则升序排列
		return true;
	}
}

int main() {
	
	int arr[101];
	while (scanf("%d%d%d%d%d%d%d%d%d", 
		arr,arr+1,arr+2,arr+3,arr+4,arr+5,arr+6,arr+7,arr+8,arr+9) != EOF) {
		sort(arr, arr + 10, cmp);	//sort里cmp不加括号

		for (int i = 0; i < 10; i++) {
			printf("%d ", arr[i]);
		}
		printf("\n");
	}
}

笔记：

1. 解决方案：找到排序操作中“最原子的比较和交换的操作”，找出所有“不发生交换的条件”
2. 代码写长，方便改
3. 掌握sort用到的cmp函数的写法，所有排序问题的区别只有 比较和交换 不同
4. 机试的时候，没做过的题目一般做不出来，重头戏要把曾经做过的题目做对

例题3.2 成绩排序

题目：

题目地址

描述
用一维数组存储学号和成绩，然后，按成绩排序输出。

输入描述：
输入第一行包括一个整数N(1<=N<=100)，代表学生的个数。 接下来的N行每行包括两个整数p和q，分别代表每个学生的学号和成绩。

输出描述：
按照学生的成绩从小到大进行排序，并将排序后的学生信息打印出来。 如果学生的成绩相同，则按照学号的大小进行从小到大排序。

示例
输入：
3
1 90
2 87
3 92
输出：
2 87
1 90
3 92

题解：

#define	 _CRT_SECURE_NO_WARNINGS
#include <cstdio>
#include <algorithm>
using namespace std;

struct Student {
	int num;
	int grade;
};	//这个分号不能省略

bool comp(Student num1, Student num2) {	//左右手元素不再是整数，而是Student类型
	if (num1.grade < num2.grade) {	//如果左成绩小于右成绩，则不交换
		return true;
	}
	else if (num1.grade == num2.grade && num1.num < num2.num) {	//如果成绩相同，且学号已升序，则不交换
		return true;
	}
	else {
		return false;
	}
}
int main() {
	Student arr[101];

	int n;
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%d%d", &arr[i].num, &arr[i].grade);	//别忘&取地址
	}

	sort(arr, arr + n, comp);	//传入的仍是arr和arr+n
	for (int i = 0; i < n; ++i) {
		printf("%d %d\n", arr[i].num, arr[i].grade);
	}

}

另一种写法，用c：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
typedef struct student {
	int stunum;
	int score;
}stu, *pstu;

stu arr[100];
int cmp1(const void *a, const void *b)//拿空类型指针接住传的某参数
{
	pstu p1 = (pstu)a;//接住后强转成要用的类型
	pstu p2 = (pstu)b;
	if (p1->score == p2->score)
	{
		if (p1->stunum > p2->stunum) {
			return 1;
		}
		else if (p1->stunum < p2->stunum) {
			return -1;
		}
		else {
			return 0;
		}
	}
	else {
		if (p1->score > p2->score) {
			return 1;
		}
		else if (p1->score < p2->score) {
			return -1;
		}else{
            return 0;
        }
        
	}
}


int main()
{
	int n;
	while (scanf("%d", &n) != EOF)
	{
		for (int i = 0; i < n; i++)
		{
			scanf("%d%d", &arr[i].stunum, &arr[i].score);
		}
		qsort(arr, n, sizeof(stu), cmp1);
		for (int i = 0; i < n; i++) {
			printf("%d %d\n", arr[i].stunum, arr[i].score);
		}
	}
}

笔记：

1. 对结构体成员的输入输出
2. 对结构体类型的compare函数怎么写，仍找不交换的条件

例题3.3 成绩排序（稳定性）

题目：

题目地址

描述:
题目：输入任意（用户，成绩）序列，可以获得成绩从高到低或从低到高的排列,相同成绩
都按先录入排列在前的规则处理。
示例：
jack 70
peter 96
Tom 70
smith 67
从高到低 成绩
peter 96
jack 70
Tom 70
smith 67
从低到高
smith 67
jack 70
Tom 70
peter 96

输入描述：
注意一个case里面有多组样例，请用循环处理输入 输入多行，先输入要排序的人的个数，然后输入排序方法0（降序）或者1（升序）再分别输入他们的名字和成绩，以一个空格隔开。

输出描述：
按照指定方式输出名字和成绩，名字和成绩之间以一个空格隔开

示例1
输入：
3
0
fang 90
yang 50
ning 70
输出：
fang 90
ning 70
yang 50

题解：

#define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <cstdio>
using namespace std;

struct Student {
	char name[50];
	int score;
	int seq;	//表示录入顺序，用来实现排序的稳定性
};

bool comp1(Student left, Student right) {	//comp1用来实现升序
	if (left.score < right.score) {
		return true;
	}
	else if (left.score == right.score && left.seq < right.seq) {
		return true;
	}
	else {
		return false;
	}
}

bool comp2(Student left, Student right) {	//comp2用来实现降序
	if (left.score > right.score) {
		return true;
	}
	else if (left.score == right.score && left.seq < right.seq) {
		return true;
	}
	else {
		return false;
	}
}

int main(){
	int N;	//数组大小未知
	int order;	//升序or降序
	
	while (scanf("%d%d", &N, &order) != EOF) {
		Student stu[N];	//c++允许变量来初始化数组

		int seq = 0;	//记录录入的顺序
		for (int i = 0; i < N; i++) {
			//scanf读取字符串时以空格为分隔，遇到空格则认为字符串结束
			//name是字符数组名不用取地址
			scanf("%s%d", stu[i].name, &stu[i].score);	
			stu[i].seq = seq++;
		}
		if (1 == order) {
			sort(stu, stu + N, comp1);
		}
		else {
			sort(stu, stu + N, comp2);
		}
		for (int i = 0; i < N; i++)
		{
			printf("%s %d\n", stu[i].name, stu[i].score);
		}
	}
}

笔记：

1. 有选择性地排序，且要求稳定性
2. 想要排序的稳定性，可以补充一个额外的seq来记录信息录入的顺序，然后把它加入compare函数的考量
3. 排序题绝大情况只需要掌握sort函数的用法
4. 向stu[ i ].name输入时不用取地址，不过取地址也行，但要注意取地址后表示的是“数组”这种变量的地址，比如&a+1时会跨过整个数组
5. c++允许用变量来初始化数组（不然提交导致段错误，不知有无其他解决办法）

习题3.6 打印极值点下标（北京大学复试上机）

题目：

题目地址

描述
在一个整数数组上，对于下标为i的整数，如果它大于所有它相邻的整数， 或者小于所有它相邻的整数，则称该整数为一个极值点，极值点的下标就是i。

输入描述：
每个案例第一行为此数组元素个数k(4＜k＜80)，第二行是k个整数，每两个整数之间用空格分隔

输出描述：
每个案例输出为n个数字（其中n为该案例中极值点的个数）：每个数字对应相应数组的相应极值点下标值，下标值之间用空格分隔。

示例1
输入：
10
10 12 12 11 11 12 23 24 12 12
15
12 12 122 112 222 211 222 221 76 36 31 234 256 76 76
15
12 14 122 112 222 222 222 221 76 36 31 234 256 76 73
输出：
0 7
2 3 4 5 6 10 12
0 2 3 10 12 14

题解：

#include<iostream>
using namespace std;

int main(){
    int k,x;
    int s[81];
    int jizhi[81];//存放极值点

    while(scanf("%d",&k)!=EOF){
    for(int i=0;i<k;i++){
        scanf("%d",&s[i]);
    }

    int j=0;
    for(int i=0;i<k;i++){
        if(i==0){   //考虑左端点
            if(s[i+1]!=s[i])jizhi[j++]=i;
         }
        else if(i<k-1){ //非端点
            if((s[i-1]<s[i]&&s[i]>s[i+1])||(s[i-1]>s[i]&&s[i]<s[i+1])){
                jizhi[j++]=i;
            }
        }
        else if(s[i-1]!=s[i]){
            jizhi[j++]=i;  //考虑右端点
        }
    }
    //注意一些细节
    for(int i=0;i<j;i++){   //由于上面j++过了，所以边界为j-1
        if(i==j-1){ //如果是最后一个极值，则换行
            printf("%d\n",jizhi[i]);
        }
        else{
            printf("%d ",jizhi[i]);
        }
    }
        
    }
}

笔记：

1. 不同情况分开处理，左端点，内点，右端点
2. 注意一些细节，j的边界，以及单独处理什么时候换行

2 查找

例题3.5 查找（需要二分查找）

题目：

题目地址

描述
输入数组长度 n 输入数组 a[1…n] 输入查找个数m 输入查找数字b[1…m] 输出 YES or NO 查找有则YES 否则NO 。

输入描述：
输入有多组数据。 每组输入n，然后输入n个整数，再输入m，然后再输入m个整数（1<=m,n<=100）。

输出描述：
如果在n个数组中输出YES否则输出NO。

示例1
输入：
5
1 5 2 4 3
3
2 5 6
输出：
YES
YES
NO

题解：

#define _CRT_SECURE_NO_WARNINGS
#include <cstdio>
#include <algorithm>
using namespace std;

int arr[100];	//全局的数组，方便在不同的函数间共享

bool binarySearch(int n, int x) {	//在长度为n的有序数组里查找x
	int left = 0, right = n - 1;

	while (left <= right) {	//最容易出错的地方
		int mid = (left + right) / 2;
		if (arr[mid] == x) {	//先检查中间是不是x
			return true;
		}
		else if (arr[mid]>x) {	//下一次到左半边查找
			right = mid - 1;
		}
		else {	//下一次到右半边查找
			left = mid + 1;
		}
	}
	return false;
}

int main()
{
	int n, m;
	while (scanf("%d", &n) != EOF) {
		for (int i = 0; i < n; i++) {
			scanf("%d", &arr[i]);
		}
		//排序
		sort(arr, arr + n);

		//读取m个想要查找的数据
		scanf("%d", &m);
		for (int i = 0; i < m; i++) {
			int x;
			scanf("%d", &x);
			if (binarySearch(n, x)) {
				printf("YES\n");
			}
			else {
				printf("NO\n");
			}
		}
	}
}

笔记：

1. 只有最深层循环次数小于1w时，算法复杂度O(n方)不超时，否则不能暴力/线性查找
2. 如果只对序列单次查找，可以线性查找，如果是多次查找，时间复杂度为O（mn），当m大到一定程度时，二分查找远远优于线性查找
3. 二分查找最难的在于确定“循环继续的条件”，即while（left<=right）
4. 循环输入内，又输入多次，别乱套/搞错

题解2：

#define _CRT_SECURE_NO_WARNINGS
#include <cstdio>
#include <map>
using namespace std;

int main() {
	int n, m;
	int arr[101];
	map<int, int> findIndex;

	while (scanf("%d", &n) != EOF) {
		for (int i = 0; i < n; i++) {
			scanf("%d", &arr[i]);
			//将数组的元素作为键，下标作为值，插入到map当中
			findIndex[arr[i]] = i;
		}
		scanf("%d", &m);
		for (int i = 0; i < m; i++) {
			int findNum;	//待查找的元素
			scanf("%d", &findNum);

			//find函数会返回找到的那个元素的迭代器
			if (findIndex.find(findNum) == findIndex.end()){
				//在这个情况，是没有找到元素
				printf("NO\n");
			}
			else {
				printf("YES\n");
			}
		}
	}
}

笔记2：

1. 关联容器map与函数find用法
2. map底层是一个二叉排序/查找树，windows-AVL，Linux-红黑树
3. 构建map底层的树需要O(NlogN)，查找需要O(logN)，所以用map和自己排序后二分查找的时间效率是一样的，但使用map查找的代价是创建新的数据结构占内存空间