数据结构与算法A 排序

1.统计工龄

给定公司N名员工的工龄，要求按工龄增序输出每个工龄段有多少员工。
输入格式
输入首先给出正整数N（≤105），即员工总人数；随后给出N个整数，即每个员工的工龄，范围在[0, 50]。
输出格式
按工龄的递增顺序输出每个工龄的员工个数，格式为：“工龄:人数”。每项占一行。如果人数为0则不输出该项。
输入样例
8
10 2 0 5 7 2 5 2
输出样例
0:1
2:3
5:2
7:1
10:1
代码

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int n;
int a[100005];
int b[100005];

int main()
{
	scanf("%d", &n);
	int min = 0;
	for (int i = 0; i < n; i++)
	{
		scanf("%d", &a[i]);
		b[a[i]]++;
		if (a[i] > min)
		{
			min = a[i];
		}
	}
	for (int i = 0; i < min + 1; i++)
	{
		if (b[i] != 0)
		{
			printf("%d:%d\n", i, b[i]);
		}
	}
	return 0;
}

---

2.寻找大富翁

胡润研究院的调查显示，截至2017年底，中国个人资产超过1亿元的高净值人群达15万人。假设给出N个人的个人资产值，请快速找出资产排前M位的大富翁。
输入格式
输入首先给出两个正整数N（≤106）和M（≤10），其中N为总人数，M为需要找出的大富翁数；接下来一行给出N个人的个人资产值，以百万元为单位，为不超过长整型范围的整数。数字间以空格分隔。
输出格式
在一行内按非递增顺序输出资产排前M位的大富翁的个人资产值。数字间以空格分隔，但结尾不得有多余空格。
输入样例
8 3
8 12 7 3 20 9 5 18
输出样例
20 18 12
代码

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define max 1000005

int person[max];
int N, M;

void Swap(int a, int b)
{
	int key = person[a];
	person[a] = person[b];
	person[b] = key;
}
void Adj(int s, int m)
{
	int key = person[s];
	for (int i = 2 * s; i <= m; i *= 2)
	{
		if (i < m && person[i] < person[i + 1])
		{
			i++;
		}
		if (!(key < person[i]))
		{
			break;
		}
		person[s] = person[i];
		s = i;
	}
	person[s] = key;
}
void Sort()
{
	for (int i = N / 2; i > 0; i--)
	{
		Adj(i, N);
	}
	for (int i = N; i > 1; i--)
	{
		Swap(1, i);
		Adj(1, i - 1);
	}
}

int main()
{
	scanf("%d %d", &N, &M);
	for (int i = 1; i <= N; i++)
	{
		scanf("%d", &person[i]);
	}
	Sort();
        if(M > N)
        {
            M = N;
        }
	for (int i = N; i > N - M; i--)
	{
		if (i == N - M + 1)
		{
			printf("%d\n", person[i]);
		}
		else
		{
			printf("%d ", person[i]);
		}
	}
	return 0;
}

---

3.点赞狂魔

微博上有个“点赞”功能，你可以为你喜欢的博文点个赞表示支持。每篇博文都有一些刻画其特性的标签，而你点赞的博文的类型，也间接刻画了你的特性。然而有这么一种人，他们会通过给自己看到的一切内容点赞来狂刷存在感，这种人就被称为“点赞狂魔”。他们点赞的标签非常分散，无法体现出明显的特性。本题就要求你写个程序，通过统计每个人点赞的不同标签的数量，找出前3名点赞狂魔。
输入格式
输入在第一行给出一个正整数N（≤100），是待统计的用户数。随后N行，每行列出一位用户的点赞标签。格式为“Name K F1​⋯FK​”，其中Name是不超过8个英文小写字母的非空用户名，1≤K≤1000，Fi​（i=1,⋯,K）是特性标签的编号，我们将所有特性标签从 1 到 107 编号。数字间以空格分隔。
输出格式
统计每个人点赞的不同标签的数量，找出数量最大的前3名，在一行中顺序输出他们的用户名,其间以1个空格分隔,且行末不得有多余空格。如果有并列，则输出标签出现次数平均值最小的那个，题目保证这样的用户没有并列。若不足3人，则用-补齐缺失，例如mike jenny -就表示只有2人。
输入样例
5
bob 11 101 102 103 104 105 106 107 108 108 107 107
peter 8 1 2 3 4 3 2 5 1
chris 12 1 2 3 4 5 6 7 8 9 1 2 3
john 10 8 7 6 5 4 3 2 1 7 5
jack 9 6 7 8 9 10 11 12 13 14
输出样例
jack chris john

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<malloc.h>
typedef struct node {
	char name[11];
	int *expression;
	int count;//记录有效个数
	int K;//输入次数
}node;
node Like[101];
int main()
{
	int i, j, N, num, k, label;
	node snap;
	scanf("%d", &N);
	for (i = 0; i < N; i++)
	{
		scanf("%s %d", Like[i].name, &Like[i].K);
		Like[i].expression = (int *)malloc(sizeof(int) * Like[i].K);
		for (j = 0; j < Like[i].K; j++)//模仿c++的set容器，进行筛选
		{
			scanf("%d", &num);
			label = 0;
			for (k = 0; k < Like[i].count; k++)
			{
				if (Like[i].expression[k] == num)
				{
					label++;
					break;
				}
			}
			if (!label)
			{
				Like[i].count++;
				Like[i].expression[k] = num;
			}
			label = 0;
		}
	}
	for (i = 0; i < N; i++)//全排序
	{
		for (j = 1; j < N - i; j++)
		{
			if (Like[j - 1].count <= Like[j].count)
			{
				if (Like[j - 1].count == Like[j].count)
				{
					int num = Like[j - 1].K > Like[j].K ? j : j - 1;
					snap = Like[num];
					Like[num] = Like[(num == j ? j - 1 : j)];
					Like[(num == j ? j - 1 : j)] = snap;
				}
				else
				{
					snap = Like[j - 1];
					Like[j - 1] = Like[j];
					Like[j] = snap;
				}
			}
		}
	}
	for (i = 0; i<3; i++)
	{
		if (i >= N)
			printf(" -");
		else
		{
			if (i == 0)
				printf("%s", Like[i].name);
			else
				printf(" %s", Like[i].name);
		}
	}
	
	return 0;
}

---

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

根据维基百科的定义：
插入排序是迭代算法，逐一获得输入数据，逐步产生有序的输出序列。每步迭代中，算法从输入序列中取出一元素，将之插入有序序列中正确的位置。如此迭代直到全部元素有序。
归并排序进行如下迭代操作：首先将原始序列看成 N 个只包含 1 个元素的有序子序列，然后每次迭代归并两个相邻的有序子序列，直到最后只剩下 1 个有序的序列。
现给定原始序列和由某排序算法产生的中间序列，请你判断该算法究竟是哪种排序算法？
输入格式
输入在第一行给出正整数 N (≤100)；随后一行给出原始序列的 N 个整数；最后一行给出由某排序算法产生的中间序列。这里假设排序的目标序列是升序。数字间以空格分隔
输出格式
首先在第 1 行中输出Insertion Sort表示插入排序、或Merge Sort表示归并排序；然后在第 2 行中输出用该排序算法再迭代一轮的结果序列。题目保证每组测试的结果是唯一的。数字间以空格分隔，且行首尾不得有多余空格
输入样例1
10
3 1 2 8 7 5 9 4 6 0
1 2 3 7 8 5 9 4 6 0
输出样例1
Insertion Sort
1 2 3 5 7 8 9 4 6 0
输入样例2
10
3 1 2 8 7 5 9 4 0 6
1 3 2 8 5 7 4 9 0 6
输出样例2
Merge Sort
1 2 3 8 4 5 7 9 0 6

//直接插入排序或者折半插入排序
//这里是非递归形式的归并排序
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define max 105

int a1[max];
int a11[max];
int a2[max];
int n;

void MergeSort(int left, int mid, int right)
{
	int i = left;
	int j = mid + 1;
	int t = 0;
	while (i <= mid && j <= right)
	{
		if (a1[i] <= a1[j])
		{
			a11[t++] = a1[i++];
		}
		else
		{
			a11[t++] = a1[j++];
		}
	}
	while (i <= mid)
	{
		a11[t++] = a1[i++];
	}
	while (j <= right)
	{
		a11[t++] = a1[j++];
	}
	t = 0;
	while (left <= right)
	{
		a1[left++] = a11[t++];
	}
}
int judge()//判断插入排序还是归并排序，我们只需要看从哪个位置破坏了序列的有序性，从而若从此位置
{          //后的中间序列与原序列相同，则为插入排序，反之则为归并排序，返回此位置坐标
	int index = 0;
	for (int i = 0; i < n; i++)
	{
		if (a2[i] > a2[i + 1])
		{
			index = i;
			break;
		}
	}
	for (int i = index + 1; i < n; i++)
	{
		if (a2[i] != a1[i])
		{
			index = 0;
			break;
		}
	}
	return index;
}
int main()
{
	scanf("%d", &n);
	for (int i = 0; i < n; i++)
	{
		scanf("%d", &a1[i]);
	}
	for (int i = 0; i < n; i++)
	{
		scanf("%d", &a2[i]);
	}
	int k = judge();
	if (k)
	{
		printf("Insertion Sort\n");
		if (a2[k + 1] < a2[k])
		{
			int j = k;
			int data = a2[k + 1];
			while (j >= 0 && data < a2[j])
			{
				a2[j + 1] = a2[j];
				j--;
			}
			a2[j + 1] = data;
		}
		for (int i = 0; i < n; i++)
		{
			if (i == n - 1)
			{
				printf("%d", a2[i]);
			}
			else
			{
				printf("%d ", a2[i]);
			}
		}
	}
	else
	{
		printf("Merge Sort\n");
		int len = 1;
		int flag = 1;
		while (flag == 1)//测试点6，我们需要判断中间序列到底进行了几次合并排序
		{
			flag = 0;
			for (int i = 0; i < n; i++)
			{
				if (a1[i] != a2[i])
				{
					flag = 1;
					break;
				}//如果不相等则进行下一次合并排序，进行下一次比较
			}//如果相等就再进行一次合并排序得到最后结果序列
			for (int k = 0; k + len <= n; k += len * 2)
			{
				int left = k, mid = k + len - 1, right = k + 2 * len - 1;
				if (right > n - 1)
				{
					right = n - 1;
				}
				MergeSort(left, mid, right);
			}
			len *= 2;
		}
		for (int i = 0; i < n; i++)
		{
			if (i == n - 1)
			{
				printf("%d", a1[i]);
			}
			else
			{
				printf("%d ", a1[i]);
			}
		}
	}
}

---

5.逆序对

给定一个长度为n的整数数列，请你计算数列中的逆序对的数量。
逆序对的定义如下：对于数列的第 i 个和第 j 个元素，如果满足 i < j 且 a[i] > a[j]，则其为一个逆序对；否则不是。
输入格式
第一行包含整数n，表示数列的长度；第二行包含 n 个整数，表示整个数列。（1≤n≤100000）
输出格式
输出一个整数，表示逆序对的个数。
输入样例
6
2 3 4 5 6 1
输出样例
5

//最坏的情况下每一对都是逆序对，所以为了防止int型溢出，s设为long long 型
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define max 100005

int arr1[max];
int arr2[max];
long long s = 0;

void Merge(int left, int mid, int right)
{
	int i = left;
	int j = mid + 1;
	int t = 0;
	while (i <= mid && j <= right)
	{
		if (arr1[i] <= arr1[j])
		{
			arr2[t++] = arr1[i++];
		}
		else
		{
			arr2[t++] = arr1[j++];
			s += mid + 1 - i;
		}
	}
	while (i <= mid)
	{
		arr2[t++] = arr1[i++];
	}
	while (j <= right)
	{
		arr2[t++] = arr1[j++];
	}
	t = 0;
	while (left <= right)
	{
		arr1[left++] = arr2[t++];
	}
}
void MSort(int left, int right)
{
	if (left < right)
	{
		int mid = (left + right) / 2;
		MSort(left, mid);
		MSort(mid + 1, right);
		Merge(left, mid, right);
	}
}
void MergeSort(int left, int right)
{
	MSort(left, right);
}
int main()
{
	int n;
	scanf("%d", &n);
	if (n == 1)
	{
		return 0;
	}
	for (int i = 0; i < n; i++)
	{
		scanf("%d", &arr1[i]);
	}
	MergeSort(0, n - 1);
	printf("%ld", s);
	return 0;
}

---

7.堆排序

给定一个整数序列，请按非递减序输出采用堆排序的各趟排序后的结果。
输入格式
测试数据有多组，处理到文件尾。每组测试数据第一行输入一个整数n（1≤n≤100），第二行输入n个整数。
输出格式
对于每组测试，输出若干行，每行是一趟排序后的结果，每行的每两个数据之间留一个空格。
输入样例
4
8 7 2 1
输出样例
7 1 2 8
2 1 7 8
1 2 7 8

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define max 105

typedef struct
{
	int data;
}SqListN;
typedef struct
{
	SqListN r[max];
	int length;
}SqList;


void Heap_Adjust(SqList* H, int s, int m)
{
	SqListN rc = H->r[s];
	for (int i = 2 * s; i <= m; i *= 2)
	{
		if (i < m && H->r[i].data < H->r[i + 1].data)
		{
			i++;
		}
		if (!(rc.data < H->r[i].data))
		{
			break;
		}
		H->r[s] = H->r[i];
		s = i;
	}
	H->r[s] = rc;
}
void Heap_Swap(SqListN* a, SqListN* b)
{
	int data = a->data;
	a->data = b->data;
	b->data = data;
}
void Heap_Sort(SqList* H)
{
	for (int i = H->length / 2; i > 0; i--)
	{
		Heap_Adjust(H, i, H->length);
	}
	for (int i = H->length; i > 1; i--)
	{
		Heap_Swap(&(H->r[1]), &(H->r[i]));
		Heap_Adjust(H, 1, i - 1); 
		for (int i = 1; i < H->length; i++)
		{
			printf("%d ", H->r[i]);
		}
		printf("%d\n", H->r[H->length].data);
	}
}
int main()
{
	SqList H;
	while (~scanf("%d", &H.length))
	{
		for (int i = 1; i <= H.length; i++)
		{
			scanf("%d", &H.r[i]);
		}
		Heap_Sort(&H);
	}
	return 0;
}

---

8.快速排序

给定一个整数序列，请按非递减序输出采用快速排序（递归法）的各趟排序后的结果。注意：每趟排序以排序区间的首元素为枢轴（支点）。
输入格式
测试数据有多组，处理到文件尾。每组测试数据第一行输入一个整数n（1≤n≤100），第二行输入n个整数。
输出格式
对于每组测试，输出若干行，每行是一趟排序后的结果，每行的每两个数据之间留一个空格。
输入样例
4
8 7 2 1
输出样例
1 7 2 8
1 7 2 8
1 2 7 8

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define max 105

typedef struct
{
	int key;
}SqNode;
typedef struct
{
	SqNode r[max];
	int length;
}SqList;

int Partition(SqList* L, int low, int high)
{
	L->r[0] = L->r[low];//第一个位置为枢轴位置
	int pivotkey = L->r[low].key;//枢轴记录
	while (low < high)
	{
		while (low < high && L->r[high].key >= pivotkey)
		{
			high--;
		}
		L->r[low] = L->r[high];
		while (low < high && L->r[low].key <= pivotkey)
		{
			low++;
		}
		L->r[high] = L->r[low];
	}
	L->r[low] = L->r[0];
	for (int i = 1; i <= L->length; i++)
	{
		if (i == L->length)
		{
			printf("%d\n", L->r[i].key);
		}
		else
		{
			printf("%d ", L->r[i].key);
		}
	}
	return low;
}

void QSort(SqList* L, int low, int high)
{
	if (low < high)
	{
		int pivotloc = Partition(L, low, high);
		QSort(L, low, pivotloc - 1);
		QSort(L, pivotloc + 1, high);
	}
}

void QuickSort(SqList* L, int low, int high)
{
	QSort(L, low, high);
}

int main()
{
	SqList* L;
	L = (SqList*)malloc(sizeof(SqList));
	while (~scanf("%d", &L->length))
	{
		for (int i = 1; i <= L->length; i++)
		{
			scanf("%d", &L->r[i].key);
		}
		QuickSort(L, 1, L->length);
	}
	return 0;
}

---

9.归并排序

知识点：归并排序
给定你一个长度为 n 的整数数列。
请你使用归并排序对这个数列按照从小到大进行排序。
并将排好序的数列按顺序输出。
输入格式
输入共两行，第一行包含整数 n(1≤n≤100000)。
第二行包含 n 个整数（所有整数均在 1∼10^9 范围内），表示整个数列。
输出格式
输出共一行，包含 n 个整数，表示排好序的数列。
输入样例
5
3 1 2 4 5
输出样例
1 2 3 4 5

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define max 100005

int arr1[max];
int arr2[max];

void Merge(int left, int mid, int right)
{
	int i = left;
	int j = mid + 1;
	int t = 0;
	while (i <= mid && j <= right)
	{
		if (arr1[i] <= arr1[j])
		{
			arr2[t++] = arr1[i++];
		}
		else
		{
			arr2[t++] = arr1[j++];
		}
	}
	while (i <= mid)
	{
		arr2[t++] = arr1[i++];
	}
	while (j <= right)
	{
		arr2[t++] = arr1[j++];
	}
	t = 0;
	while (left <= right)
	{
		arr1[left++] = arr2[t++];
	}
}
void MSort(int left, int right)
{
	if (left < right)
	{
		int mid = (left + right) / 2;
		MSort(left, mid);
		MSort(mid + 1, right);
		Merge(left, mid, right);
	}
}
void MergeSort(int left, int right)
{
	MSort(left, right);
}
int main()
{
	int n;
	scanf("%d", &n);
	for (int i = 0; i < n; i++)
	{
		scanf("%d", &arr1[i]);
	}
	MergeSort(0, n - 1);
	for (int i = 0; i < n; i++)
	{
		printf("%d ", arr1[i]);
	}
	return 0;
}

---

10.逆序对的数量

知识点：归并排序
给定一个长度为 n 的整数数列，请你计算数列中的逆序对的数量。
逆序对的定义如下：对于数列的第 i 个和第 j 个元素，如果满足 i<j 且 a[i]>a[j]，则其为一个逆序对；否则不是。
输入格式
第一行包含整数 n(1≤n≤100000)，表示数列的长度。
第二行包含 n 个整数，表示整个数列,数列中的元素的取值范围 [1~10^9]。
输出格式
请在这里描述输出格式。例如：对每一组输入，在一行中输出A+B的值。
输入样例
6
2 3 4 5 6 1
输出样例
5

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define max 100005

int arr1[max];
int arr2[max];
long long s = 0;

void Merge(int left, int mid, int right)
{
	if (left == right)
	{
		return;
	}
	int i = left;
	int j = mid + 1;
	int t = 0;
	while (i <= mid && j <= right)
	{
		if (arr1[i] <= arr1[j])
		{
			arr2[t++] = arr1[i++];
		}
		else
		{
			arr2[t++] = arr1[j++];
			s += mid + 1 - i;
		}
	}
	while (i <= mid)
	{
		arr2[t++] = arr1[i++];
	}
	while (j <= right)
	{
		arr2[t++] = arr1[j++];
	}
	t = 0;
	while (left <= right)
	{
		arr1[left++] = arr2[t++];
	}
}
void MSort(int left, int right)
{
	if (left < right)
	{
		int mid = (left + right) / 2;
		MSort(left, mid);
		MSort(mid + 1, right);
		Merge(left, mid, right);
	}
}
void MergeSort(int left, int right)
{
	MSort(left, right);
}
int main()
{
	int n;
	scanf("%d", &n);
	if (n == 1)
	{
		return 0;
	}
	for (int i = 0; i < n; i++)
	{
		scanf("%d", &arr1[i]);
	}
	MergeSort(0, n - 1);
	printf("%ld", s);
	return 0;
}