实验13 内部排序2022

最新推荐文章于 2023-02-07 15:57:41 发布

要被ddl噶辣

最新推荐文章于 2023-02-07 15:57:41 发布

阅读量488

点赞数

分类专栏：数据结构实验文章标签： c++ 算法开发语言

本文链接：https://blog.csdn.net/weixin_62431082/article/details/128366013

版权

数据结构实验专栏收录该内容

13 篇文章 3 订阅

订阅专栏

A. DS内排—直插排序

给定一组数据，使用直插排序完成数据的升序排序。

--程序要求--

若使用C++只能include一个头文件iostream；若使用C语言只能include一个头文件stdio

程序中若include多过一个头文件，不看代码，作0分处理

不允许使用第三方对象或函数实现本题的要求

输入

数据个数n，n个数据

7 34 23 677 2 1 453 3

输出

直插排序的每一趟排序结果

23 34 677 2 1 453 3
23 34 677 2 1 453 3
2 23 34 677 1 453 3
1 2 23 34 677 453 3
1 2 23 34 453 677 3
1 2 3 23 34 453 677

代码：

#include<iostream>
using namespace std;
void print(int a[], int n) {
	for (int i = 1; i < n; i++) cout << a[i] << " ";
	cout << a[n] << endl;
}
void insertSort(int a[], int n) {
	int i = 0, j = 0;
	for (i = 2; i <= n; i++) {
		if (a[i] < a[i - 1]) {
			a[0] = a[i];
			for (j = i - 1; a[j] >= a[0]; j--) a[j + 1] = a[j];
			a[j + 1] = a[0];
		}
		print(a, n);
	}
}
int main() {
	int n;
	cin >> n;
	int* a = new int[n+1];
	for (int i = 1; i <= n; i++) cin >> a[i];
	insertSort(a, n);
}

B. DS排序--希尔排序

给出一个数据序列，使用希尔排序算法进行降序排序。

间隔gap使用序列长度循环除2直到1

输入

第一行输入t，表示有t个测试示例
第二行输入n，表示第一个示例有n个数据(n>1)
第三行输入n个数据，都是正整数，数据之间用空格隔开
以此类推

2
6
111 22 6 444 333 55
8
77 555 33 1 444 77 666 2222

输出

对每组测试数据，输出每趟排序结果。不同组测试数据间用空行分隔。

444 333 55 111 22 6
444 333 111 55 22 6

444 555 666 2222 77 77 33 1
666 2222 444 555 77 77 33 1
2222 666 555 444 77 77 33 1

代码：

#include<iostream>
using namespace std;
void print(int a[], int n) {
	for (int i = 1; i < n; i++) cout << a[i] << " ";
	cout << a[n] << endl;
}
void shellInsertSort(int a[], int gap, int m,int n) {
	int i, j;
	for (i = gap + m; i <= n; i += gap) {
			a[0] = a[i];
			for (j = i; j >=1; j -= gap) {
				if (a[0] < a[j]) break;
				a[j] = a[j-gap];
			}
				a[j+gap] = a[0];
	}
}
void shellSort(int a[], int n) {
	for (int gap = n / 2; gap >= 1; gap /= 2) {
		for (int m = 1; m <= gap; m++) {
			shellInsertSort(a, gap, m,n);
		}
		print(a, n);
	}
	cout << endl;
}
int main() {
	int t; cin >> t;
	while (t--) {
		int n; cin >> n;
		int* a = new int[n + 1]; a[0] = -9999;
		for (int i = 1; i <= n; i++) cin >> a[i];
		shellSort(a, n);
	}
}

C. DS排序--快速排序

给出一个数据序列，使用快速排序算法进行从小到大的排序

--程序要求--

若使用C++只能include一个头文件iostream；若使用C语言只能include一个头文件stdio

程序中若include多过一个头文件，不看代码，作0分处理

不允许使用第三方对象或函数实现本题的要求

输入

第一行输入t，表示有t个测试示例
第二行输入n，表示第一个示例有n个数据
第三行输入n个数据，都是正整数，数据之间用空格隔开
以此类推

2
6
111 22 6 444 333 55
8
77 555 33 1 444 77 666 2222

输出

每组测试数据，输出每趟快排的结果，即每次排好一个数字结果（长度为1的子序列，不用排，不用输出）。不同测试数据间用空行分隔。

55 22 6 111 333 444
6 22 55 111 333 444
6 22 55 111 333 444
6 22 55 111 333 444

1 33 77 555 444 77 666 2222
1 33 77 555 444 77 666 2222
1 33 77 77 444 555 666 2222
1 33 77 77 444 555 666 2222
1 33 77 77 444 555 666 2222

代码：

#include<iostream>
using namespace std;
int n;
void print(int a[], int n) {
	for (int i = 0; i < n - 1; i++) cout << a[i] << " ";
	cout << a[n-1] << endl;
}
int partition(int a[], int low, int high) {
	int pivot = a[low];
	while (low < high) {
		while ((low < high) && a[high] >= pivot) --high;
		a[low] = a[high];
		while ((low < high) && a[low] <= pivot) ++low;
		a[high] = a[low];
	}
	a[low] = pivot;
	print(a, n);
	return low;
}
void quickSort(int a[], int low, int high) {
	if (low < high) {
		int pivot = partition(a, low, high);
		quickSort(a, low, pivot - 1);
		quickSort(a, pivot + 1, high);
	}
}
int main() {
	int t; cin >> t;
	while (t--) {
		cin >> n;
		int* a = new int[n];
		for (int i = 0; i < n; i++) cin >> a[i];
		int low = 0, high = n - 1;
		quickSort(a, low, high);
		cout << endl;
	}
}

D. 大数据量的冒泡排序 (计次数)

给定一个包含从0到n-1各一次的数组，若使用冒泡排序将其排为升序，问其中需要进行多少次交换

输入

测试数据有多组，

每组由两行组成：第一行包含正整数n（n <= 5000）; 下一行包含从0到n-1的n个整数的序列。

10
1 3 6 9 0 8 5 7 4 2

输出

对于每组测试数据，输出一行，输出交换总次数

代码：

#include<iostream>
using namespace std;
void swap(int& a, int& b) {
	int temp = a;
	a = b;
	b = temp;
}
void print(int a[], int n) {
	for (int i = 0; i < n; i++)cout << a[i] << endl;
}
void bubbleSort(int a[], int n) {
	int count = 0;
	for (int i = 0; i < n; i++) {
		bool flag = true;
		for (int j = n-1; j > i; j--) {
			if (a[j] < a[j - 1]) {
				swap(a[j], a[j - 1]);
				count++;
				flag = false;
			}
		}
		if (flag) { cout << count<<endl; break; }
	}
}
int main() {
	int n; 
	while ((scanf("%d", &n)) != EOF) {
		int* a = new int[n];
		for (int i = 0; i < n; i++) cin >> a[i];
		bubbleSort(a, n);
	}
}

E. 奥运排行榜

每年奥运会各大媒体都会公布一个排行榜，但是细心的读者发现，不同国家的排行榜略有不同。比如中国金牌总数列第一的时候，中国媒体就公布“金牌榜”；而美国的奖牌总数第一，于是美国媒体就公布“奖牌榜”。如果人口少的国家公布一个“国民人均奖牌榜”，说不定非洲的国家会成为榜魁…… 现在就请你写一个程序，对每个前来咨询的国家按照对其最有利的方式计算它的排名。

输入

输入的第一行给出两个正整数N和M（≤224，因为世界上共有224个国家和地区），分别是参与排名的国家和地区的总个数、以及前来咨询的国家的个数。为简单起见，我们把国家从0 ~ N−1编号。之后有N行输入，第i行给出编号为i−1的国家的金牌数、奖牌数、国民人口数（单位为百万），数字均为[0,1000]区间内的整数，用空格分隔。最后面一行给出M个前来咨询的国家的编号，用空格分隔。

4 4
51 100 1000
36 110 300
6 14 32
5 18 40
0 1 2 3

输出

在一行里顺序输出前来咨询的国家的排名:计算方式编号。其排名按照对该国家最有利的方式计算；计算方式编号为：金牌榜=1，奖牌榜=2，国民人均金牌榜=3，国民人均奖牌榜=4。输出间以空格分隔，输出结尾不能有多余空格。

若某国在不同排名方式下有相同名次，则输出编号最小的计算方式。

1:1 1:2 1:3 1:4

代码：

#include<iostream>
#include<algorithm>
using namespace std;
int n, m;
int* Rank=new int[4];
double* b, * c, * d, * e;
bool cmp(double a, double b) {
	return a > b ? true : false;
}
int index(double* array, double num) {
	for (int i = 0; i < n; i++)
		if (num == array[i]) return i+1;
}
int rankWay(int* array) {
	int min = 0;
	for (int i = 1; i < 4; i++)
		if (array[i] < array[min]) min = i;
	return min;
}
int main() {
	cin >> n >> m;
	double** a=new double*[n];
	for (int i = 0; i < n; i++) {
		a[i] = new double[5];
		b = new double[n];
		c = new double[n];
		d = new double[n];
		e = new double[n];
		for (int j = 0; j < 3; j++) cin >> a[i][j];
	}
	for (int i = 0; i < n; i++) {
		b[i] = a[i][0];
		c[i] = a[i][1];
		d[i]=a[i][3] = a[i][0] / (a[i][2] * 1000000);
		e[i]=a[i][4] = a[i][1] / (a[i][2] * 1000000);
	}
	sort(b, b + n,cmp); sort(c, c + n,cmp); sort(d, d + n,cmp); sort(e, e + n,cmp);
	for (int i = 0; i < m; i++) {
		int num; cin >> num;
		Rank[0] = index(b, a[num][0]);
		Rank[1] = index(c, a[num][1]);
		Rank[2] = index(d, a[num][3]);
		Rank[3] = index(e, a[num][4]);
		if (i != m - 1) cout << Rank[rankWay(Rank)] << ":" << rankWay(Rank) + 1 << " ";
		else  cout << Rank[rankWay(Rank)] << ":" << rankWay(Rank)+1 << endl;
	}

}

F. 与零交换

将 { 0, 1, 2, ..., N-1 } 的任意一个排列进行排序并不困难，这里加一点难度，要求你只能通过一系列的 Swap(0, *) —— 即将一个数字与 0 交换 —— 的操作，将初始序列增序排列。例如对于初始序列 { 4, 0, 2, 1, 3 }，我们可以通过下列操作完成排序：

Swap(0, 1) ⟹ { 4, 1, 2, 0, 3 }
Swap(0, 3) ⟹ { 4, 1, 2, 3, 0 }
Swap(0, 4) ⟹ { 0, 1, 2, 3, 4 }

本题要求你找出将前 N 个非负整数的给定排列进行增序排序所需要的最少的与 0 交换的次数。

输入

输入在第一行给出正整数 N (≤105)；随后一行给出{ 0, 1, 2, ..., N-1 } 的一个排列。数字间以空格分隔。

10
3 5 7 2 6 4 9 0 8 1

输出

在一行中输出将给定序列进行增序排序所需要的最少的与 0 交换的次数。

代码：

#include<iostream>
using namespace std;
bool isup(int* a, int n) {
	bool flag = true;
	for(int i=0;i<n-1;i++)
		if (a[i] > a[i + 1]) {
			flag = false; break;
		}
	return flag;
}
void swap(int& a, int& b) {
	int temp = a;
	a = b;
	b = temp;
}
int basicindex(int* a,int n) {
	int count = 0;
	for (int i = 0; i < n; i++)
		if (a[i] != i) count++;
	return count;
}
int findnextindex(int* a, int begin, int n) {
	for (int i = begin; i < n; i++)
		if (a[i] != i) return a[i];
	return -1;
}
int main() {
	int n; cin >> n;
	int count = 0;
	int circle=0;
	int flag;
	int* a = new int[n];
	for (int i = 0; i < n; i++) cin >> a[i];
	if (a[0] == 0) flag = 1;
	else flag = 0;
	int next = findnextindex(a, 0, n);
	int basic = basicindex(a, n);
	int old;
	while (next != -1) {
		while (true) {
			if (a[next] != next) {
				old = next;
				swap(a[next], next);
			}
			else break;
		}
		circle++;
		next = findnextindex(a, old, n);
	}
	if (circle == 0) count = 0;
	if (flag == 0)count = basic + circle - 2;
	else count = basic + circle;
	cout << count << endl;
}

G. DS内排—堆排序

给定一组数据，使用堆排序完成数据的降序排序。（建小顶堆)。

输入

数据个数n，n个整数数据

8 34 23 677 2 1 453 3 7

输出

初始创建的小顶堆序列

每趟交换、筛选后的数据序列，输出格式见样例

8 1 2 3 7 23 453 677 34
8 2 7 3 34 23 453 677 1
8 3 7 453 34 23 677 2 1
8 7 23 453 34 677 3 2 1
8 23 34 453 677 7 3 2 1
8 34 677 453 23 7 3 2 1
8 453 677 34 23 7 3 2 1
8 677 453 34 23 7 3 2 1

代码：

#include<iostream>
using namespace std;
void print(int* a, int n) {
	cout << n << " ";
	for (int i = 1; i < n; i++) cout << a[i] << " ";
	cout << a[n] << endl;
}
void heapAdjust(int* a, int i, int n) {
	a[0] = a[i];
	for (int j = 2 * i; j <= n; j *= 2) {
		if (j < n && a[j] > a[j + 1]) j++;
		if (a[0] <= a[j]) break;
		else {
			a[i] = a[j];
			i = j;
		}
	}
	a[i] = a[0];
}
void buildMinHeap(int* a, int n) {
	for (int i = n / 2; i > 0; i--) 
		heapAdjust(a, i,n);
	print(a, n);
}
void heapSort(int* a, int n) {
	buildMinHeap(a, n);
	for (int i = n; i > 1; i--) {
		swap(a[i], a[1]);
		heapAdjust(a, 1, i - 1);
		print(a, n);
	}
}
int main() {
	int n; cin >> n;
	int* a = new int[n+1];
	for (int i = 1; i <= n; i++) cin >> a[i];
	heapSort(a, n);
}

H. DS内排—2-路归并排序

输入一组字符串，用2-路归并排序按字典顺序进行降序排序。

输入

测试次数t

每组测试数据：数据个数n，后跟n个字符串，字符串不含空格。

2
6 shenzhen beijing guangzhou futian nanshan baoan
10 apple pear peach grape cherry dew fig haw lemon marc

输出

对每组测试数据，输出2-路归并排序的每一趟排序结果。每组测试数据的输出之间有1空行。

shenzhen beijing guangzhou futian nanshan baoan
shenzhen guangzhou futian beijing nanshan baoan
shenzhen nanshan guangzhou futian beijing baoan

pear apple peach grape dew cherry haw fig marc lemon
pear peach grape apple haw fig dew cherry marc lemon
pear peach haw grape fig dew cherry apple marc lemon
pear peach marc lemon haw grape fig dew cherry apple

代码：

#include<iostream>
using namespace std;
int n;
string* a, * b;
void print(string* a, int n) {
	for (int i = 1; i < n ; i++) cout << a[i] << " ";
	cout << a[n] << endl;
}
void Merge(int low, int mid, int high) {
	int i = low, j = mid + 1, k = low;
	while (i <= mid && j <= high)
		if (a[i] >= a[j]) b[k++] = a[i++];
		else b[k++] = a[j++];
	while (i <= mid) b[k++] = a[i++];
	while (j <= high) b[k++] = a[j++];
}
void MergeSort(int low, int high) {
	int mid,step, i;
	for (step = 1; step < n; step *= 2) {
		for (low = 1; low <= n; low += 2 * step) {
			mid = low + step - 1;
			if (mid > n) break;
			high = low + 2 * step - 1;
			if (high > n) high = n;
			Merge(low, mid, high);
		}
		for (int i = 1; i <= n; i++) a[i] = b[i];
		print(a, n);
	}
}
int main() {
	int t; cin >> t;
	while (t--) {
		cin >> n;
		a = new string[n+1];
		b = new string[n + 1];
		for (int i = 1; i <=n; i++) cin >> a[i];
		MergeSort(1, n);
		cout << endl;
	}
}

I. 基数排序（内部排序）

给定一组数据，对其进行基数升序排序。

输入

测试次数t

每组测试数据一行：数字个数n，后跟n个数字（整数）

注：如果序列中有负数，则每个数字加上最小负数的绝对值，使序列中的数均大于等于0。排序后再减去最小负数的绝对值。

2
10 278 109 63 930 589 184 505 269 8 83
6 57 0 93 19 18 99

输出

对每组测试数据，输出每趟分配、收集的结果。若分配中该位没有数字，输出NULL。具体输出格式见样例。每组测试数据间以空行分隔。

如果序列中有负数，最后输出减去最小负数绝对值的序列值。

0:->930->^
1:NULL
2:NULL
3:->63->83->^
4:->184->^
5:->505->^
6:NULL
7:NULL
8:->278->8->^
9:->109->589->269->^
930 63 83 184 505 278 8 109 589 269
0:->505->8->109->^
1:NULL
2:NULL
3:->930->^
4:NULL
5:NULL
6:->63->269->^
7:->278->^
8:->83->184->589->^
9:NULL
505 8 109 930 63 269 278 83 184 589
0:->8->63->83->^
1:->109->184->^
2:->269->278->^
3:NULL
4:NULL
5:->505->589->^
6:NULL
7:NULL
8:NULL
9:->930->^
8 63 83 109 184 269 278 505 589 930

0:->0->^
1:NULL
2:NULL
3:->93->^
4:NULL
5:NULL
6:NULL
7:->57->^
8:->18->^
9:->19->99->^
0 93 57 18 19 99
0:->0->^
1:->18->19->^
2:NULL
3:NULL
4:NULL
5:->57->^
6:NULL
7:NULL
8:NULL
9:->93->99->^
0 18 19 57 93 99

代码：

#include<iostream>
#include<vector>
using namespace std;
void print(int *num,vector<vector<int>> number,int n) {
	int temp = 0;
	for (int i = 0; i < 10; i++) {
		cout << i << ":";
		if (number[i].empty()) cout << "NULL" << endl;
		else {
			for (int j = 0; j < number[i].size(); j++) {
				cout << "->" << number[i][j];
				num[temp++] = number[i][j];
			}
			cout << "->^" << endl;
		}
	}
	for (int i = 0; i < n; i++) {
		if (i != n - 1)cout << num[i] << " ";
		else cout << num[i] << endl;
	}
}
void radix_sort(int num[], int n) {
	int digit=9;
	for (int i = 0; i < n; i++) while (num[i] > digit) digit = digit * 10 + 9;
	int te = 10;
	while (te < digit*10) {
		vector<vector<int>> number;
		for (int i = 0; i < 10; i++) {
			vector <int>temp;
			number.push_back(temp);
		}
		for (int i = 0; i < n; i++) {
			int index = num[i];
			index = index % te;
			index =index/ (te / 10);
			number[index].push_back(num[i]);
		}
		print(num, number, n);
		te *= 10;
	}
}
int main() {
	int t; cin >> t;
	while (t--) {
		int n; cin >> n;
		int* num = new int[n];
		for (int i = 0; i < n; i++) cin >> num[i];
		radix_sort(num, n);
		cout << endl;
	}
}

J. 插入排序还是归并排序

根据维基百科的定义：

插入排序是迭代算法，逐一获得输入数据，逐步产生有序的输出序列。每步迭代中，算法从输入序列中取出一元素，将之插入有序序列中正确的位置。如此迭代直到全部元素有序。

归并排序进行如下迭代操作：首先将原始序列看成 N 个只包含 1 个元素的有序子序列，然后每次迭代归并两个相邻的有序子序列，直到最后只剩下 1 个有序的序列。

现给定原始序列和由某排序算法产生的中间序列，请你判断该算法究竟是哪种排序算法？

输入

输入在第一行给出正整数 N (≤100)；随后一行给出原始序列的 N 个整数；最后一行给出由某排序算法产生的中间序列。这里假设排序的目标序列是升序。数字间以空格分隔。

10
3 1 2 8 7 5 9 4 6 0
1 2 3 7 8 5 9 4 6 0

输出

首先在第 1 行中输出Insertion Sort表示插入排序、或Merge Sort表示归并排序；然后在第 2 行中输出用该排序算法再迭代一轮的结果序列。题目保证每组测试的结果是唯一的。数字间以空格分隔，且行首尾不得有多余空格。

Insertion Sort
1 2 3 5 7 8 9 4 6 0

#include<iostream>
#include<algorithm>
using namespace std;
void print(int* a, int n) {
	for (int i = 0; i < n; i++) cout << a[i] << " ";
}
int main() {
	int n; cin >> n;
	int* a = new int[n];
	int* b = new int[n];
	for (int i = 0; i < n; i++) cin >> a[i];
	for (int i = 0; i < n; i++) cin >> b[i];
	int i, j;
	for (i = 0; i < n - 1 && b[i] <= b[i + 1]; i++);
	for (j = i + 1; j < n && b[j] == a[j]; j++);
	if (j == n) {
		cout << "Insertion Sort" << endl;
		sort(a, a + i + 2);
	}
	else {
		cout << "Merge Sort" << endl;
		bool flag = true; int gap = 1;
		while (flag) {
			flag = false;
			for (int i = 0; i < n; i++)
				if (a[i] != b[i]) flag = true;//相等时说明排到这步了
			gap = gap * 2;
			for (int i = 0; i < n / gap; i++)
				sort(a + i * gap, a + (i + 1) * gap);
			sort(a + n / gap * gap, a + n);
		}
	}
	print(a, n);
}

K. 关于堆的判断

将一系列给定数字顺序插入一个初始为空的小顶堆H[]。随后判断一系列相关命题是否为真。命题分下列几种：

x is the root：x是根结点；
x and y are siblings：x和y是兄弟结点；
x is the parent of y：x是y的父结点；
x is a child of y：x是y的一个子结点。

输入

每组测试第1行包含2个正整数N（≤ 1000）和M（≤ 20），分别是插入元素的个数、以及需要判断的命题数。下一行给出区间[−10000,10000]内的N个要被插入一个初始为空的小顶堆的整数。之后M行，每行给出一个命题。题目保证命题中的结点键值都是存在的。

5 4
46 23 26 24 10
24 is the root
26 and 23 are siblings
46 is the parent of 23
23 is a child of 10

输出

对输入的每个命题，如果其为真，则在一行中输出T，否则输出F。

F
T
F
T

#include<iostream>
using namespace std;
int main() {
	int n, m; cin >> n >> m;
	int* a = new int[n+1];
	for (int i = 1; i <= n; i++) cin >> a[i];
	for (int i = 1; i <= n; i++) {
		int index = i;
		while (index > 1 && a[index] < a[index / 2]) {
			swap(a[index], a[index/2]);
			index /= 2;
		}
	}
	while (m--) {
		int x1, y1,x2,y2;
		string s1,s2,s3,s4;
		cin >> x1 >> s1;
		if (s1 == "and") {
			cin >> y1>> s2 >> s3;
			for (int i = 1; i <= n; i++) {
				if (a[i] == x1) x2 = i;
				if (a[i] == y1) y2 = i;//找到两者的下标
			}
			if (a[x2 / 2] == a[y2 / 2]) cout << "T" << endl;
			else cout << "F" << endl;
		}
		else {
			cin >> s2;
			if (s2 == "a") {
				cin >> s3 >> s4 >> y1;
				for (int i = 1; i <= n; i++) {
					if (a[i] == x1) x2 = i;
					if (a[i] == y1) y2 = i;
				}
				if (a[x2 / 2] == a[y2]) cout << "T" << endl;
				else cout << "F" << endl;
			}
			else {
				cin >> s3;
				if (s3 == "root") {
					if(x1==a[1])cout << "T" << endl;
					else cout << "F" << endl;
				}
				else {
					cin >> s4 >> y1;
					for (int i = 1; i <= n; i++) {
						if (a[i] == x1) x2 = i;
						if (a[i] == y1) y2 = i;
					}
					if (a[x2] == a[y2 / 2]) cout << "T" << endl;
					else cout << "F" << endl;
				}
			}
		}
	}
}

L. 寻找大富翁

胡润研究院的调查显示，截至2017年底，中国个人资产超过1亿元的高净值人群达15万人。假设给出N个人的个人资产值，请快速找出资产排前M位的大富翁。

输入

输入首先给出两个正整数N（≤106）和M（≤10），其中N为总人数，M为需要找出的大富翁数；接下来一行给出N个人的个人资产值，以百万元为单位，为不超过长整型范围的整数。数字间以空格分隔。

8 3
8 12 7 3 20 9 5 18

输出

在一行内按非递增顺序输出资产排前M位的大富翁的个人资产值。数字间以空格分隔，但结尾不得有多余空格。

20 18 12

#include<iostream>
#include<algorithm>
using namespace std;
bool cmp(int a, int b) {
	return a > b ? true : false;
}
int main() {
	int n, m; cin >> n >> m;
	int* a = new int[n];
	for (int i = 0; i < n; i++) cin >> a[i];
	sort(a, a + n,cmp);
	for (int i = 0; i < m - 1; i++) cout << a[i] << " ";
	cout << a[m-1] << endl;
}

要被ddl噶辣

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
实验13 内部排序2022

输入的第一行给出两个正整数N和M（≤224，因为世界上共有224个国家和地区），分别是参与排名的国家和地区的总个数、以及前来咨询的国家的个数。之后有N行输入，第i行给出编号为i−1的国家的金牌数、奖牌数、国民人口数（单位为百万），数字均为[0,1000]区间内的整数，用空格分隔。将 { 0, 1, 2, ..., N-1 } 的任意一个排列进行排序并不困难，这里加一点难度，要求你只能通过一系列的 Swap(0, *) —— 即将一个数字与 0 交换 —— 的操作，将初始序列增序排列。具体输出格式见样例。
复制链接

扫一扫