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;
}