置顶 |

C语言考研复试

C语言考研复试刷题计划

第一节 顺序表基础

1.有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？都是多少

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include<stdio.h>
int main(){
	int sum = 0;
	int i,j,k;
	for(i=1;i<5;i++){
		for(j=1;j<5;j++){
			for(k=1;k<5;k++){
				if(i!=j &&i!=k && j!=k){
					printf("%d,%d,%d\n",i,j,k);
					sum++;
				}
			}
		
		}
	}
	printf("总共有%d个数字\n",sum);
	return 0;
}

2.输入某年某月某日，判断这一天是这一年的第几天？注意：是否是闰年闰年 可以被4整除同时不可以被100整除 或者可以被400整除

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include<stdio.h>
int isleapyear(int year){
	if((year%4==0 && year %100 !=0)|| (year%100==0)){
		return 1;
	}	
}

int main(){
	int year,month,day;
	int daymonth[] = {31,28,31,30,31,30,31,31,30,31,30,31};
	printf("请输入一下信息：");
	scanf("%d,%d,%d",&year,&month,&day);
	
	if(isleapyear(year)){
		daymonth[1] = 29;
	}
	
	int i;
	int totalday=0;
	for(i=1;i<month;i++){
		totalday = totalday + daymonth[i];
	}
	totalday = totalday+day;
	printf("所输入的时间是这一年的第%d天\n",totalday);
	return 0;	
}

3.有一种特殊的细胞分裂现象。最初有一个细胞，这个细胞在第一个周期和第二个周期不会分裂。
从第三个周期开始，每个周期这个细胞都会分裂出一个新细胞。新产生的细胞同样在前两个周期不分裂，
从第三个周期起每个周期又会分裂出一个新细胞。假设细胞都不会死亡，那么每个周期结束时细胞的总数分别是多少呢？
输出20个周期
周期：1 2 3 4 5 6 7 8 9 10

(斐波那契 例如：1,1,2,3,5,8,13,21,34,55,…) 

1
2
3
4
5
6
7
8
9
10
11
12
#include<stdio.h>
int main(){
	int a=1,b=1;
	for(int i=1;i<=20;i++){
		int temp;
		temp = a;
		a = b;
		b = a+temp;
		printf("第%d个周期结束时细胞的总数为：%d\n",i+3,a+b);
	}
	return 0;
}

4.判断101到200之间的素数=质数：只有1和它本身

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include<stdio.h>
int main(){
	int i,j;
	int count=0;
	for(i=101;i<=200;i++){
		for(j=2;j<i;j++){
			if(i%j ==0){
				break;
			}
		}
		if(j==i){
			count++;
			printf("第%d个素数，分别为%d\n",count,i);
		}
	}
	return 0;
}

5.打印出所有的”水仙花数”，所谓”水仙花数”是指一个三位数，其各位数字立方和等于该数本身。
例如：153是一个”水仙花数”，因为153=1的三次方＋5的三次方＋3的三次方

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include<stdio.h>
void main(){
	int num,g,s,b;
	printf("请输入一个数：");
	scanf("%d",&num);
	g = num%10;       //取到个位数
	s = (num/10)%10;  //取到十位数
	b = (num/100)%100;//取到百位数
	//printf("%d,%d,%d",g,s,b);
	int sum = g*g*g+s*s*s+b*b*b;
	if(num ==sum){
		printf("yes\n");
	}else{
		printf("no\n");
	}
}

6.输入两个正整数m和n，求其最大公约数和最小公倍数。
最大公约数：转转相除法（欧几里得算法）
假设求1997和615两个正整数的最大公约数。
1997/615=3（余152）
615/152=4（余7）
152/7=21（余5）
7/5=1（余2）
5/2=1（余1）
2/1=2（余0） 当前除数为最大公约数

最小公倍数：两个数的积/最大公约数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include<stdio.h>
int main(){
	int m,int n;
	printf("请输入m和n:");
	scanf("%d %d",&m,&n);

	if(m<n){
		int t=m;
		m=n;
		n=t;
	}
	int yushu=m%n;
	int a = m*n;


	while(yushu !=0){
		m=n;
		n=yushu;
		yushu=m%n;
	}
	printf("最大公约数为：%d\n",n);
	printf("最小公倍数为：%d\n",a/n);
	return 0;
}

7.输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数
a-z之间对应的ASCII码：97-122
注意getchar是每次接收一个字符
char c;
printf(“请输入一个字符：”);
c=getchar();
while(c != ‘\n’){
printf(“%c”,c);
c=getchar();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include<stdio.h>
int main(){
	char c;
	int letter = 0;
	int number = 0;
	int space = 0;
	int others = 0;
	c = getchar();

	while(c!='\n'){
		if((c>='a' && c<='z')  || (c>='A' && c<='Z')){
			letter++;
		}else if(c>='0'&& c<='9'){
			number++;
		}else if(c == ' '){
			space++;
		}else{
			others++;
		}
		c = getchar();
	}

	printf("其中的字母有%d个,数字有%d个，空格有%d个,其他有%d个\n",letter,number,space,others);
	return 0;
}

8.求 s=a+aa+aaa+aaaa+aa…a 的值，其中 a 是一个数字，例如 2+22+222+2222+22222=24690此时共有5个数相加)
几个数相加有键盘控制 1.如何控制 2.如何表示a aa aaa aaaa..每次用一个for循环不太现实，因此用一个控制条件 3.求和

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include<stdio.h>
int main(){
	int base; //那个数去加呢
		int n;//总共相加的有几个数

	int sum =0;    
	printf("请输入基值base和相加的个数n：");
	scanf("%d %d",&base,&n);
	int temp=base; //每次另加的个位数值   此处一定要在输入行的下面


	while(n>0){
		sum+=base;//sum=2  2+22  2+22+222
		base*=10;//base=20  220    2220
		base+=temp;//base=22  222   2222
		n--;
		printf("n=%d,base=%d\n",n,base);
	}
	printf("sum=%d\n",sum);
	return 0;

}

9.一个数如果恰好等于它的因子之和，这个数就称为”完数”，例如 6=1＋2＋3 ，请编程找出 1000 以内的所有完数。
找到所有能够整除的数=余数为0

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include<stdio.h>
int main(){
	int i,j,sum;
	for(i=2;i<=1000;i++){  //6
		sum = 0;           //注意：每次都要将sum置为0
		for(j=1;j<i;j++){  //1 2 3
			if(i%j==0){
				sum+=j;
			}
		}if(sum==i){
			printf("1000以内的完数有:%d\n",j);
		}
	}
	return 0;
}

10.一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？ 299.60938 0.09766
t=1;h=100;
2 50*2
*3 25 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
#include<stdio.h>
void main(){
	double h=100.0;
	double sum=100.0;
	h/=2.0;
	for(int i=2;i<=2;i++){
		 
		 sum+=2*h;//每次都是往返
		 h/=2.0;
		 printf("第%d次反弹有%.5f米高\n",i,h);
	}
	printf("第十次落地总共经过%.5f米，反弹%.5f米高\n",sum,h);
}

11.两个乒乓球队进行比赛，各出三人，甲队为 a、b、c 三人，乙队为 x、y、z 三人。抽签决定比赛名单，
有人向队员打听比赛的名单：a 说他不和 x 比，c 说他不和 x、z 比，请编写代码找出三队赛手的名单（每个人比赛对手不一致）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <stdio.h>
int main() {
    char a, b, c;  // 甲队的成员
    char x = 'x', y = 'y', z = 'z';  // 乙队的成员

    // 枚举 a、b、c 的对手
    for (a = 'x'; a <= 'z'; a++) {
        for (b = 'x'; b <= 'z'; b++) {
            if (a != b) {  // a 和 b 的对手不能相同
                for (c = 'x'; c <= 'z'; c++) {
                    if (a != c && b != c) {  // a、b、c 的对手必须互不相同
                        // 根据题目条件筛选
                        if (a != 'x' && c != 'x' && c != 'z') {
                            printf("a 对手 %c, b 对手 %c, c 对手 %c\n", a, b, c);
                        }
                    }
                }
            }
        }
    }

    return 0;
}

12.有5个人坐在一起，问第五个人多少岁？他说比第4个人大2岁。问第4个人岁数，他说比第3个人大2岁。
问第三个人，又说比第2人大两岁。问第2个人，说比第一个人大两岁。最后问第一个人，他说是10岁。请问第五个人多大？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include<stdio.h>

int func(int n){
	if(n==1){
		return 10;
	}else{
		return func(n-1)+2;
	}
}


int main(){
	int n=5;
	int num=func(5);
	printf("%d\n",num);
	return 0;
}

13.一个5位数，判断它是不是回文数。即12321是回文数，个位与万位相同，十位与千位相同。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include<stdio.h>
int main(){
	int ge,shi,qian,wan;
	int num;
	printf("请输入一个数：");
	scanf("%d",&num);

	ge = num%10;
	shi =(num/10)%10;

	qian = (num/1000)%10;
	wan = (num/10000)%10;
	if(ge==wan && shi==qian){
		printf("%d是一个回文数！\n",num);
	}else{
		printf("%d不是一个回文数！\n",num);
	}
	return 0;
}

14.利用递归函数将字符串反转abcd——>dcba

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//方法一
#include<stdio.h>

void func(int n){
	char c;
	if(n==1){
		c = getchar(); //注意这里是一个字符
		putchar(c);
	}else{                    //反向输出字符
		c = getchar(); 
		func(n-1);
		putchar(c);	
	}
}

int main(){
	void func(int n);              //先申明一下函数
	func(	if(s[len-1]=='\n'){           //"\n"是错误的
		s[len-1] ='\0';      //将换行符换成结束符
		len--;
	}6);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
//方法二

#include<stdio.h>
#include<string.h>
void reverse(char *s){
	int len=0;   //求尾指针的变量
	char *p = s;   //p为数组的头指针
	while(*p != 0){
		len++;
		p++;
	}
	int i=0;
	char c;  //用来交换的中间变量
	while(i<=len/2-1){
		c = *(s+i);
		*(s+i) = *(s+len-i-1);
		*(s+len-i-1) = c;
		i++;
	}
}

int main(){
	char s[100];
	printf("请输入字符串:");
	fgets(s,sizeof(s),stdin);    //使用 stdin 表示从标准输入（键盘）读取。 
	int len = strlen(s);          
	
	//由于fgets函数默认输出的最后一个字符是\n
	if(s[len-1]=='\n'){           //"\n"是错误的
		s[len-1] ='\0';      //将换行符换成结束符
		len--;
	}
	printf("字符串为:%s，长度：%d\n",s,len);
	reverse(s);  //反转函数
	printf("反转字符串为：%s",s);
	return 0;
}

第二节 查找和排序

15.攻擂法(找到一组数字中的最大值和最小值)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include<stdio.h>

int findMax(int arr[],int n){
	int max = arr[0];
	for(int i=0;i<n;i++){    //注意数组越界
		if(arr[i]>max){
			max = arr[i];	
		}
	}
	return max;
}
	
int findMin(int arr[],int n){
	int min = arr[0];
	for(int i=0;i<n;i++){
		if(arr[i]<min){
			min = arr[i];	
		}
	}
	return min;
}	
		
int main(){
	int arr[] = {10,20,1,90,60,50,44};
	int n = sizeof(arr) /sizeof(arr[0]);   //动态计算数组 arr 中元素的个数，sizeof(arr)=7元素*4字节，sizeof(arr[0])=4

	//调用函数的最大值和最小值
	int max = findMax(arr,n);
	int min = findMin(arr,n);


	printf("数组中的在最大值：%d\n",max);
	printf("数组中的的最小值：%d\n",min);
	return 0;
}

16.冒泡排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#include<stdio.h>
#include<stdlib.h>

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

void bubbleSort(int arr[],int n){
	int i,j,temp;
	for(i=0;i<n-1;i++){    //tang数
		for(j=0;j<n-i-1;j++){   //这里记不住直接写n-1也可以
			if(arr[j]>arr[j+1]){
				temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
			}
		}
	}
}

int main(){
	int n;
	printf("请输入要排序的元素个数：");
	scanf("%d",&n);


	//动态分配存储空间
	int *arr = (int*)malloc(n * sizeof(int));    //引入stdlib
	if(arr == NULL){
		printf("内存分配失败！\n");
		return 1;
	}

	printf("请输入%d个整数：",n);
	for(int i=0;i<n;i++){
		scanf("%d",&arr[i]);
	}
	printArray(arr,n);
	bubbleSort(arr,n);
	printArray(arr,n);
	return 0;
}

17.选择排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include<stdio.h>
#include<stdlib.h>
void printArray(int arr[],int n){
	for(int i=0;i<n;i++){
		printf("%d ",arr[i]);
	}
	printf("\n");
}

//每次选择有一个最小值和第i个位置上的值交换位置，接下来从剩下的n-i+1个数字中找最最小值，最后一个可以不用管
void selectionSort(int arr[],int n){
	int i,j,min_idx,temp;
	for(i=0;i<n-1;i++){
		min_idx=i;
		for(j=i+1;j<n;j++){
			if(arr[j]<arr[min_idx])
				min_idx = j;  //第j个指针的值才是最小的
		}
		temp=arr[min_idx];
		arr[min_idx]=arr[i];
		arr[i]=temp;

	}
}

int main(){
	int n;
	printf("请输入要排序的元素个数：");
	scanf("%d",&n);

	//动态分配存储空间、
	int *arr = (int *)malloc(sizeof(int) * n);
	if(arr == NULL){
		printf("内存分配失败！");
		return 1;
	}
	
	printf("请输入%d个整数：\n",n);
	for(int i=0;i<n;i++){
		scanf("%d",&arr[i]);
	}

	printArray(arr,n);	
	selectionSort(arr,n);
	printArray(arr,n);	
	return 0;
}

18.插入排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include<stdio.h>
#include<stdlib.h>

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


void insertionSort(int arr[],int n){
	int i,j,temp;
	for(i=1;i<n;i++){
		temp = arr[i]; //将第i个值存在temp中
		j=i-1;
		//将比temp大的元素往后移
		while(j>=0 && arr[j]>temp){
			arr[j+1]=arr[j];
			j--;
		}
		arr[j+1]=temp;
	}
}

int main(){
	int n;
	printf("请输出需要排序的数字个数：");
	scanf("%d",&n);
	
	//分配内存
	printf("请输入%d位数：\n",n);
	int *arr = (int*)malloc(sizeof(int)*n);
	for(int i=0;i<n;i++){
		scanf("%d",&arr[i]);
	}
	if(arr==NULL){
		printf("分配内存失败！");
	}
	//输出
	printArray(arr,n);
	//排序
	insertionSort(arr,n);
	//输出
	printArray(arr,n);
	return 0;
}

19.顺序查找(跟攻擂法逸一样，知识返回下标)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//顺序查找
int func_seque(int arr[],int n,int key){
	for(int i=0;i<n;i++){
		if(key==arr[i]){
			return i;
		}
	}
	return -1;
}
#include<stdio.h>
int main(){
	int arr[]={10,20,30,40,50};//假设查找30
	int n = sizeof(arr)/sizeof(arr[0]);//求长度
	int key = 30;
	int result = func_seque(arr,n,key);
	if(result != -1){
		printf("所查找元素%d的下标点为：%d\n",key,result);
	}else{
		printf("所查找的元素不在数组中!\n");
	}
	return 0;
}

20.二分查找–需要先排序,排好序后，需要知道首地址和尾地址 相加/2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include<stdio.h>
int binary_search(int arr[],int n,int key){
	int left=0,right=n-1;
	while(left<=right){
		int mid = left + (right-left)/2;

		if(arr[mid == key]){
			return mid;
		}else if(arr[mid]<key){
			left = mid+1;
		}else{
			right = mid-1;
		}
	}
	return -1;
}
int main(){
	int arr[]={10,20,30,40,50};
	int n = sizeof(arr)/sizeof(arr[0]);
	int key=30;
	int result= binary_search(arr,n,key);
	if(result !=-1){
		printf("所查找元素%d的下标为：%d\n",key,result);
	}else{
		printf("所查找的元素不存在！");
	}
	return 0;
}

21.实现一个算法来识别一个字符串 str2是否是另一个字符串 str1 的排列。排列的解释如下：如果将 str1的字符拆分开，
重新排列后再拼接起来，能够得到 str2，那么就说字符串 str2 是字符串 str1 的排列。（不忽略大小写）

方法一：穷举法 直接st1和st2穷举比较
方法二：先排序，再比较，可以借助字符串函数strcmp比较

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
//方法一：

#include<stdio.h>
#include<string>
void bubbleSort(char arr[],int n){
	int i,j,temp;
	for(i=0;i<n-1;i++){
		for(j=0;j<n-i-1;j++){
			if(arr[j]>arr[j+1]){
				temp = arr[j];
				arr[j]=arr[j+1];
				arr[j+1]=temp;
			}
		}
	}
}
int main(){
	printf("请输入字符串:");
	char a[105],b[105];
	scanf("%s %s",a,b);
	int n = strlen(a),m=strlen(b);
	if(m=n){
		bubbleSort(a,n);
		bubbleSort(b,n);
	}
	if(strcmp(a,b)==0){  //strcmp主要是用来比较两个字符串相等，相等为0；str1<str2为负；str1>str2为正。也可以用for循环
		printf("Yes\n");
	}else{
		printf("No\n");
	}
	return 0;
}

22.压缩字符串：输入一行字符串，长度不超过 500. 压缩的格式是将连续相同字符替换为字符 + 数字形式，
例如 “AAABCCDDDD” 变为 “A3BC2D4”。需要判断压缩能不能节省空间，仅在压缩后字符串比原字符串长度更短时进行压缩。eg:AABB A2B2长度一样没必要压缩

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#include<stdio.h>
#include<string>
int main(){
	//从标准输入读取一行字符串，并将其存储到字符数组 a 中。
	//1. 准备食材（输入字符串）
	char a[500];
	fgets(a,sizeof(a),stdin); 
	//2. 清理不需要的食材（处理换行符）
	int len=strlen(a);
	if(a[len-1]=='\n'){
		a[len-1]='\0';
		len--;
	}
	//3. 准备压缩容器（初始化压缩结果）
	char compressed[1000]="";  //存放压缩后的食材。
	int comPreLen=0;           //当前容器中食材的数量（初始为 0）。
	int count=1;              //是用来记录连续相同食材的数量的计数器（初始为 1）
	
	//4. 开始压缩食材（遍历字符串）
	for(int i=0;i<len;i++){
		if(i==len-1 || a[i] != a[i+1]){
			if(count>1){ //如果连续食材的数量大于1，你需要将食材名称和数量一起放入容器
				compressed[comPreLen++] = a[i];       //将字符 a[i] 存储到 compressed 数组中，并更新压缩结果的长度。
				char countstr[10];                    //定义一个字符数组，用于存储重复次数的字符串形式。
				sprintf(countstr,"%d",count);         //将整数 count 转换为字符串，并存储到 countstr 中。
				for(int j=0;countstr[j] != '\0';j++){
					compressed[comPreLen++] = countstr[j];//当前里面一个A,我们把字符串3加入到了里面，就是A3
				}
			}else{
				compressed[comPreLen++] = a[i];         
			}
			count = 1;
		}else{
			count++;
		}
	}
	//5. 检查压缩效果
	if(comPreLen >= len){
		printf("NO\n");
	}else{
		printf("压缩有作用！");

 //在 C 语言中，字符串是以空字符（\0）结尾的。在压缩结果的末尾添加一个空字符，表示字符串的结束。
//如果没有这个语句，程序可能会在输出压缩结果时出现错误，因为它无法确定字符串的结束位置。
		compressed[comPreLen]='\0';
		printf("%s\n",compressed);
	}
	return 0;
}

23.实现一个算法来识别一个字符串的字符是否是唯一的（忽略字母大小写）。若唯一，则输出 YES ，否则输出 NO。
例如：abd25+ 输出 yes aabcd 输出 NO

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#include<stdio.h>
#include<string>
int main(){
	//准备食材
	printf("请输入字符串：");
	char a[100];
	fgets(a,sizeof(a),stdin);
	//清理食材
	int len = strlen(a);
	if(a[len-1] =='\n'){
		a[len-1] = '\0';
	}

	int i,j;
	for(i=0;i<len;i++){
		for(j=i+1;j<len;j++){
			if(a[i] == a[j]){
				printf("NO\n");
				return 0;
			}
		}
	}
	printf("Yes\n");
	return 0;
}

24.给定 n 个正整数 a1,a2,……,an，你可以将它们任意排序。现要将这 n 个数字连接成一排，即令相邻数字收尾相接，组成一个数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
// 自定义比较函数，用于判断两个数字怎样排列能组成更大的数
int compare(int a, int b) {
	char str1[20], str2[20];
	// 将两个数字按不同顺序拼接成字符串
	sprintf(str1, "%d%d", a, b);
	sprintf(str2, "%d%d", b, a);
	// 比较两个拼接后的字符串大小，返回结果
	return strcmp(str2, str1);
}
int main() {
	int n;
	scanf("%d", &n);
	int a[21];
		// 输入n个正整数
	int i;
	for (i = 0; i < n; i++) {
		scanf("%d", &a[i]);
	}
	// 冒泡排序，根据compare函数的规则对数组进行排序
	for (i = 0; i < n - 1; i++) {
		for (int j = 0; j < n - 1 - i; j++) {
			if (compare(a[j], a[j + 1]) > 0) {
				int temp = a[j];
				a[j] = a[j + 1];
				a[j + 1] = temp;
			}
		}
	}
	char num[100001] = "";
	// 将排序后的数字依次拼接到num字符串中
	for (i = 0; i < n; i++) {
		char arr[20];
		sprintf(arr, "%d", a[i]);
		strcat(num, arr);
	}
	printf("%s\n", num);
	return 0;
}

第三节 结构体

结构体的内容 一般考试都会给出
#include<stdio.h>
typedef struct human{
char a[100];
int number;
}human;

human arr[];
//例如 arr[0].number arr[0].a[]

25.给定N个职员的信息，包括姓名、基本工资、浮动工资和支出，要求编写程序顺序输出每位职员的姓名
和实发工资（实发工资=基本工资+浮动工资-支出）
输入格式：
输入在一行中给出正整数N。随后N行，每行给出一位职员的信息，格式为“姓名 基本工资 浮动工资 支
出”，中间以空格分隔。其中“姓名”为长度小于10的不包含空白字符的非空字符串，其他输入、输出保证
在单精度范围内。
输出格式：
按照输入顺序，每行输出一位职员的姓名和实发工资，间隔一个空格，工资保留2位小数。
输入样例：
3
zhao 240 400 75
qian 360 120 50
zhou 560 150 80
输出样例：
zhao 565.00
qian 430.00
zhou 630.00 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include<stdio.h>
#include<stdlib.h>
typedef struct human{
	char name[100];
	double base_Gongzi;
	double float_gongzi;
	double zhichu;
	double shifa_gongzi;
}human;


int main(){
	int n,i;
	printf("请输入职员人数N：");
	scanf("%d",&n);
	human *arr =(human*)malloc(n*sizeof(human));
	printf("请输入职员的姓名 基本工资 浮动工资 支出：\n");
	for(i=0;i<n;i++){
		//char 类型通常用于表示单个字符，使用%c作为格式化输入输出的占位符。然而当处理字符串（即字符数组）时，需要使用%s。
		//double类型用lf,float类型用f,int类型用d      
		scanf("%s %lf %lf %lf",&arr[i].name,&arr[i].base_Gongzi,&arr[i].float_gongzi,&arr[i].zhichu);
		arr[i].shifa_gongzi = arr[i].base_Gongzi+arr[i].float_gongzi-arr[i].zhichu;
	}
	for(i=0;i<n;i++){
		printf("%s %.2f\n",arr[i].name,arr[i].shifa_gongzi);
	}
	return 0;
}

26.每个 PAT 考生在参加考试时都会被分配两个座位号，一个是机试座位，一个是考试座位。正常情况
下，考生在入场时先得到机试座位号码，入座进入机试状态后，系统会显示该考生的考试座位号码，考
试时考生需要换到考试座位就座。但有些考生迟到了，试机已经结束，他们只能拿着领到的机试座位号
码求助于你，从后台查出他们的考试座位号码。
输入格式：
输入第一行给出一个正整数 N（≤1000），随后 N 行，每行给出一个考生的信息：准考证号 机试座位号
考试座位号。其中准考证号由 16 位数字组成，座位从 1 到 N 编号。输入保证每个人的准考证号都不
同，并且任何时候都不会把两个人分配到同一个座位上。考生信息之后，给出一个正整数 M（≤N），随
后一行中给出 M 个待查询的试机座位号码，以空格分隔。
输出格式：
对应每个需要查询的试机座位号码，在一行中输出对应考生的准考证号和考试座位号码，中间用 1 个空
格分隔。

输入样例：
4
3310120150912233 2 4
3310120150912119 4 1
3310120150912126 1 3
3310120150912002 3 2
2
3 4
输出样例：
3310120150912002 2
3310120150912119 1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include<stdio.h>
#include<stdlib.h>
typedef struct student{
	char number[1000];
	int shi;
	int kao;
}student;   //student存放的时学生的整体信息

int main(){
	int n;
	printf("请输入考试学生数目：");
	scanf("%d",&n);
	student *arr = (student*)malloc(n*sizeof(student));
	int i;
	for(i=0;i<n;i++){
		scanf("%s %d %d",&arr[i].number,&arr[i].shi,&arr[i].kao);
	}
	int research;
	printf("请输入查询的人数:");
	scanf("%d",&research);
	int *arr1 = (int*)malloc(research*sizeof(int));//保存的是查询的

	//将数据写进去
	for(i=0;i<research;i++){
		scanf("%d",&arr1[i]);
	}
	for(i=0;i<research;i++){
		for(int j=0;j<n;j++){
			if(arr[j].shi == arr1[i]){
				printf("%s %d\n",arr[j].number,arr[j].kao);
			}
		}
	}
	return 0;
}

27.字符串查找
输入样例：
123456123abc123hbc
123
输出：
3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int main(){
	char src_str[100];
	char find_str[100];
	int len1=0,len2=0;
	int count=0;
	printf("请输入字串：");
	fgets(src_str,sizeof(src_str),stdin);//末尾时换行符
	fgets(find_str,sizeof(find_str),stdin);//末尾时换行符
	len1 = strlen(src_str);
	len2 = strlen(find_str);
	//删除换行符
	src_str[len1-1] = '\0';
	len1 -=1;
	find_str[len2-1] = '\0';
	len2 -= 1;
	//找
	for(int i=0;i<len1-len2+1;i++){
		for(int j=0;j<len2;j++){
			if(src_str[i+j] != find_str[j])
				break;
		/*  src_str[i + j] 的含义
			src_str 是一个字符数组，存储源字符串。

			i 是外层循环的变量，表示当前匹配的起始位置。

			j 是内层循环的变量，表示子串 find_str 的当前字符位置。

			i + j 表示在源字符串 src_str 中，从起始位置 i 开始的第 j 个字符的位置。   */
		}
		if(j==len2){
			count++;
		}
	}
	printf("%d\n",count);
	return 0;
}

28.字符串删除
输入样例：
1234567890
456
输出：
1237890

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main(){
	char str1[100];
	char str2[100];
	int len1=0,len2=0;
	printf("请输入字符串1：");
	fgets(str1,sizeof(str1),stdin);
	fgets(str2,sizeof(str2),stdin);
	len1 = strlen(str1);
	str1[len1-1] = '\0';
	len1-=1;
	len2 = strlen(str2);
	str2[len2-1]='\0';
	len2-=1;
	//找  
	//1234567890
	//456
	int i,j;
	int count=0;
	for(i=0;i<len1-len2+1;i++){
		for(j=0;j<len2;j++){
			if(str1[i+j]!=str2[j])
				break;
		}
		if(j==len2){
			//删除
			for(j=i;j<len1-len2;j++){
				str1[j]= str1[j+len2];
			}
			len1=len1-len2;
			i-=1;  //因为外层循环结束后，需要i++
		}
	}
	//设置结束；
	str1[len1] = '\0';
	printf("%s\n",str1);
	return 0;
}

29.二进制转换为十进制
例如，二进制数 1011 转换为十进制的过程如下：

1×2^3 + 0×2^2 + 1×2^1 + 1×2^0 = 8+0+2+1=11
因此，1011 的十进制值是 11。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>

int main(){
	int n;     //用户输入的二进制数（以整数形式存储）
	int i=0;   //用于记录当前位的权重
	int num;   //用于存储 n 的当前最低位。
	printf("请输入二进制的位数n:");
	scanf("%d",&n);
	int decimal=0;      //存储最终的十进制结果。
	while(n!=0){
		num = n%10;  // 获取 n 的最低位
		n/=10;      // 去掉 n 的最低位     n = 1011，则 n /= 10 后，n = 101。
		decimal =decimal + num * pow(2,i);   //2^i
		i++;
	}
	printf("十进制为：%d\n",decimal);
	return 0;
}

30.十进制转换为二进制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
例如，十进制数 11 转换为二进制的过程如下：
11÷2=5  余数 1
5÷2=2   余数 1
2÷2=1   余数 0
1÷2=0   余数 1
将余数倒序排列，得到二进制数 1011。

  注意：每次余数rema * 位权i = 二进制数的十进制表示  eg:5-->101  

      n   rema    binum(最终的二进制数的十进制表示)       i
初始： 5    0        0                                 1
step1:2    1      0+1*1=1(binum+rema*i)               10  
step2:1    0      1+0*10=1                            100
step3:1/2  1      1+1*100=101                         1000
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#include<stdio.h>
#include<string.h>
//n=10
int func(int n){
	int binum=0;   // 用于存储最终的二进制数的十进制表示,二进制binum=1010的十进制表示。
	int rema;      //rema: 余数=======相当于二进制
	int i=1,step=1;  // i: 位权, step: 步骤计数器
	while(n!=0){
		rema = n%2;//0 1 0 1得到余数
		printf("step%d: %d/2 = %d(商),余数=%d,\n",step++,n,n/2,rema);
		n/=2;  //5  2  1  0
		binum =binum + rema *i;  //0 10 10 1010 将余数（二进制）乘以位权并累加到 binum
		i*=10;   //10 100 1000 10000 更新位权（从低位到高位）
	}
	return binum;
}
int main(){
	int n;
	printf("请输入十进制的数：");
	scanf("%d",&n);
	printf("%d的二进制为：%d\n",n,func(n));

	return 0;
}

31.将奇数数组与偶数数组合并为一个数组 随后按照从大到小排列

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int main(){
	int i;
	int arr1[]={1,3,5,7,9};
	int arr2[]={2,4,6,8};
	int arr3[9];
	int arr1_len = 5,arr2_len = 4;
	//先将两个数组的全部数据存入到数组3
	for(i=0;i<5;i++){
		arr3[i] = arr1[i];
	}
	int j=0;
	for(i;i<9;i++){
		arr3[i] = arr2[j++];
	}
	//打印输出一下
	for(i=0;i<9;i++){
		printf("%d  ",arr3[i]);
	}
	//对arr3冒泡排序
	for(i=0;i<9;i++){
		for(j=0;j<9-i-1;j++){
			if(arr3[j]>arr3[j+1]){
				int temp = arr3[j];
				arr3[j] = arr3[j+1];
				arr3[j+1] = temp;
			}
		}
	}
	//输出排序后的结果
	printf("\n");
	for(i=0;i<9;i++){
		printf("%d  ",arr3[i]);
	}

	return 0;
}

32.给定一个字符串 S，请你求出 S 的最长回文子串。
输入：
aa1ABA1b
输出：
5

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
//判断是否是回文字符串
int func2(char s[],int left,int right){
	while(left<right){
		if(s[left] != s[right]){
			return 0;
		}
		left++;
		right--;
	}
	return 1;
}
//求最大数量
int func1(char s[],int len){
	int maxlen = 1;
	for(int i=0;i<len;i++){
		for(int j=i;j<len;j++){
			if(func2(s,i,j)){//如果是回文数
				int len = j-i+1;
				if(len > maxlen){
					maxlen = len;
				}
			}
		}
	}
	return maxlen;
}
int main(){
	//输入字符
	char s[100];
	printf("请输入字符串：\n");
	fgets(s,sizeof(s),stdin);
	int len = strlen(s);
	s[len-1]='\0';
	len-=1;
	int result = func1(s,len);
	printf("%d\n",result);
	return 0;
}

33.两个长度不同的字串按照其每个字符的大小 从小到大拼接起来

1

34.字符串匹配

1

35.字符串中大小写转换 （2024真题）
遍历数组，大写字母和小写字母中间差32个asc码

再尝试一下八进制转换

1

第四节 链表

1.头插法

1

2.尾插法

1

3.中间插入

1

4.删除链表中所有匹配的值

1

5.两个有序链表合并(升序排列)

1

6.链表反转

1

7.判断链表是否包含环(快慢指针)

1

8.反转链表的指定部分(我们可以先找到需要反转的起始节点的前一个节点和结束节点的后一个节点，然后对需要反转的部分进行反转操作，最后将反转后的部分重新连接回原链表)8.反转链表的指定部分(我们可以先找到需要反转的起始节点的前一个节点和结束节点的后一个节点，然后对需要反转的部分进行反转操作，最后将反转后的部分重新连接回原链表)

1

9.链表的奇偶重排(奇数在前 偶数在后)

1

10.输入k个有序链表合并成一个链表

1

第五节 综合

1741523484774

1

2.现在有 n 个人，第 i 个人的名字是 Si，现在想选择三个人，以满足以下条件：每个被选中的人的名字都以 M、A、R、C 或 H 开头。在不考虑被选人名字顺序的情况下，问：最多可以有多少这样的方式去选择三个人。

1
2
3
4
5
6
7
8
9
输入：
6
Mango
Apple
Rabbit
Cat
Hamster
Ant

1

3.一个整数如果按从低位到高位的顺序，奇数位 (个位、百位、万位 ⋯⋯ ) 上的数字是奇数，偶数位 (十

位、千位、十万位 ⋯⋯ ) 上的数字是偶数，我们就称之为 “好数”。

问：给定一个正整数 N，请计算从 1 到 N 一共有多少个好数。

1

4.给定一个字符串，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。

1
2
3
4
5
6
7
输入：

leetcode

输出：

0
1

5.给定一个字符串 s ，请你找出其中不含有重复字符的最长子的长度。

1

6.构建有n个值的链表，输入一个整数k或者正数第k个和倒数第个元素 返回两个元素的合。

1

7.建立有p个节点的链表，然后输出两个正整数m和n判断 从倒第m个节点到倒数第n的节点所构成的链表是否是回文链表。

1

8.求一个3*3矩阵对角线元素之和

1

1741523785687

1
2
3
4
5
6
7
8
9
10
11
输入：
2 3
1 2 3
4 5 6
3 2
7 8
9 10
11 12
输出：
58 64
139 154
1

赏

谢谢你请我吃糖果

支付宝
微信
置顶

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家