devbox
不正经
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

程序设计第八周_编写函数void sort(int*n1,int*n2,int*n3),swap(int*p1,*p

作者：不正经 | 2024-02-26 03:48:19

赞

踩

编写函数void sort(int*n1,int*n2,int*n3),swap(int*p1,*p2),使用main函数调

编写一个函数void fun(int *p, int n)，其功能为对整数数组p[5]中的数字进行排序。排序结果在主函数中输出。 输入： 34 78 23 12 69 输出如下： 78,69,34,23,12

注意：输入数字之间用一个空格分隔

  1. #include<stdio.h>
  2. void fun(int *p, int n);
  3. int main()
  4. {
  5. 	int arr[5] = {0};
  6. 	int i;
  7. 	for(i = 0; i < 5; i++)
  8. 	{
  9. 		scanf("%d",&arr[i]);
  10. 	}
  11. 	int* p = arr;
  12. 	fun(p, 5);
  13. 	for(i = 0; i < 5; i++)
  14. 	{
  15. 		if(i == 0)
  16. 		{
  17. 			printf("%d",arr[i]);
  18. 		}
  19. 		else
  20. 		{
  21. 			printf(",%d",arr[i]);
  22. 		}
  23. 	}
  24. 	return 0;	
  25. }
  26. void fun(int *p, int n)
  27. {
  28. 	int i,j;
  29. 	// 这里使用冒泡排序了
  30. 	for(i = 0; i < n;i++)
  31. 		for(j = 0; j < ( n - i - 1); j++)
  32. 		{
  33. 			if(*(p + j) < *(p + j + 1))
  34. 			{
  35. 				// 小的往后移动
  36. 				int temp = *(p + j);
  37. 				*(p + j) = *(p + + j + 1);
  38. 				*(p + j + 1) = temp;		
  39. 			}	
  40. 		}	
  41. }

编写函数，使用指针传递实现三个整数的从大到小排序。
编写主函数，输入三个整数，调用函数排序，输出三个从大到小排序的整数。
输入：三个整数，用空格隔开
输出，三个整数，从大到小，用一个空格隔开。
【输入输出样例】
输入：
1 2 3
输出:
3 2 1
注意，本题的关键是要用函数实现三个数的排序，用指针，不用数组。

  1. #include<stdio.h>
  2. void sort(int* n1, int* n2, int* n3);
  3. int main()
  4. {
  5. 	int n1, n2, n3;
  6. 	int *p1 = &n1;
  7. 	int *p2 = &n2;
  8. 	int *p3 = &n3;
  9. 	scanf("%d%d%d",p1,p2,p3);
  10. 	sort(p1,p2,p3);
  11. 	printf("%d %d %d",n1,n2,n3);
  12. 	return 0;
  13. }
  14. void sort(int* n1, int* n2, int* n3)
  15. {
  16. 	int temp;
  17. 	// 找出第一个最大的 
  18. 	if(*n1 < *n2)
  19. 	{
  20. 		temp = *n1;
  21. 		*n1 = *n2;
  22. 		*n2 = temp;
  23. 	}
  24. 	// 经过这样后，n2存储的值有可能比n1大 
  25. 	if(*n2 < *n3)
  26. 	{
  27. 		temp = *n2;
  28. 		*n2 = *n3;
  29. 		*n3 = temp;
  30. 	}
  31. 	// 
  32. 	if(*n1 < *n2)
  33. 	{
  34. 		temp = *n1;
  35. 		*n1 = *n2;
  36. 		*n2 = temp;
  37. 	}
  38. }

若有n个数，循环右移一位指每个数移到相邻的右边一个位置，最右边的数移到最左边。如由数1,2,3,4,5；循环右移一位的结果为5,1,2,3,4。
编写函数，实现数组元素的循环右移k位。如有数组元素1,2,3,4,5右移3位的 结果为3,4,5,1,2。

编写主函数输入若干元素和右移位数，调用函数右移，在主函数中输出结果。元素个数不超过100.

输入：两行，第1行为若干用空格分隔的整数，以9999表示结束；第2行一个整数，表示右移的位数。
输出:一行，移位的结果，用一个空格隔开，末尾无空格。
【输入输出样例】
输入：
1 2 3 4 5 9999
3
输出：
3 4 5 1 2

  1. #include<stdio.h>
  2. void move(int* arr, int n,int len); 
  3. int main()
  4. {
  5. 	int num[100];
  6. 	int n = 0; // 输入的个数
  7. 	int temp;
  8. 	while(1)
  9. 	{
  10. 		scanf("%d",&temp);
  11. 		if(temp == 9999)
  12. 		{
  13. 			break;
  14. 		}
  15. 		num[n] = temp;
  16. 		n++;
  17. 	}
  18. 	// 右移动的位数 
  19. 	int count;
  20. 	scanf("%d",&count);
  21. 	move(num,count,n);
  22. 	int i;
  23. 	for(i = 0; i < n; i++)
  24. 	{
  25. 		if(i == 0)
  26. 		{
  27. 			printf("%d",num[i]);
  28. 		}
  29. 		else
  30. 		{
  31. 			printf(" %d",num[i]);
  32. 		}
  33. 		
  34. 	}
  35. 	return 0;
  36. }
  37. // n 移动位数 len ：数组长度 
  38. void move(int* arr, int n, int len)
  39. {
  40. 	int k;
  41. 	for(k = 0; k < n; k++)
  42. 	{
  43. 		// 移动的逻辑
  44. 		int i;
  45. 		// 定义一个变量来容纳最后的一个元素
  46. 		int temp = arr[len - 1]; 
  47. 		for(i = len - 1; i > 0; i--)
  48. 		{
  49. 			//swap(arr + i ,arr + i - 1);
  50. 			*(arr + i) = *(arr + i - 1);
  51. 		}
  52. 		// 把最后一个元素放到第一个去
  53. 		*arr = temp;
  54. 	}	
  55. }
  56.

写一个函数int slen(char *s)，返回值为字符串s的长度。要求在主函数中输入一个长度不大于20的字符串，调用函数slen，输出字符串对应的长度。
输入：
hello world
输出：
11（空格算作有效字符）

  1. #include<stdio.h>
  2. int slen(char *s);
  3. int main()
  4. {
  5. 	char s[20];
  6. 	gets(s);
  7. 	int len = slen(s);
  8. 	printf("%d",len);
  9. 	return 0;
  10. }
  11. int slen(char* s)
  12. {
  13. 	int count = 0;
  14. 	while(*s != '\0')
  15. 	{
  16. 		count++;
  17. 		s++;
  18. 	}
  19. 	return count;
  20. }

写一个函数int strcmp（char *p1, char *p2）用来实现两个字符串的比较。在主函数中输入两个字符串，输出对应的结果。
输入：
hello
world
则输出：-1
输入：
world
hello
则输出1
输入：
hello
hello
则输出：0

  1. #include<stdio.h>
  2. int strcmp(char *p1, char *p2);
  3. int main()
  4. {
  5. 	char s1[100];
  6. 	char s2[100];
  7. 	gets(s1);
  8. 	gets(s2);
  9. 	int res = strcmp(s1,s2);
  10. 	printf("%d",res);
  11. 	return 0;	
  12. } 
  13. int strcmp(char *p1, char *p2)
  14. {
  15. 	while((*p1 != '\0') && (*p2 != '\0'))
  16. 	{
  17. 		if(*p1 > *p2)
  18. 		{
  19. 			return 1;
  20. 		}
  21. 		if(*p1 < *p2)
  22. 		{
  23. 			return -1;	
  24. 		}
  25. 		p1++;
  26. 		p2++;		
  27. 	}
  28. 	// 到结尾了还没有匹配,但是还是有长度不一致的情况 
  29. 	if(*p1 == '\0' && *p2 == '\0')
  30. 	{
  31. 		return 0;
  32. 	}
  33. 	else if(*p1 == '\0')
  34. 	{
  35. 		return -1;
  36. 	}
  37. 	else
  38. 	{
  39. 		return 1;
  40. 	} 
  41. }

编写函数，将字符串s1中从第n个字符开始的最多k个字符复制到字符串s2中。最多的意思是如果s1从n开始的字符不够k个，则复制到末尾为止。如s1="study",n=4,k=5,则只复制“dy”两个字符。函数返回s2的首地址。函数原型为：
char * copykn(char *s1,char *s2,int n,int k)
编写主函数，输入字符，n和k，调用函数复制，输出结果字符串。主函数为：
int main()
{
char s1[100],s2[100];
int n,k;
gets(s1);
scanf("%d %d",&n,&k);
puts(copykn(s1,s2,n,k));
return 0;
}
【输入输出样例】
输入：
communication
2 3
输出:
omm

  1. #include<stdio.h>
  2. char * copykn(char *s1,char *s2,int n,int k);
  3.  
  4. int main()
  5. {
  6. 	char s1[100] = "";
  7. 	char s2[100] = "";
  8.     // 这里需要赋初值，为什么我不清楚
  9. 	int n,k;
  10. 	gets(s1);
  11. 	scanf("%d %d",&n,&k);
  12. 	puts(copykn(s1,s2,n,k));
  13. 	return 0;
  14. }
  15. char * copykn(char *s1,char *s2,int n,int k)
  16. {
  17. 	//多的意思是如果s1从n开始的字符不够k个，则复制到末尾为止
  18. 	s1 = s1 + (n - 1);
  19. 	int i;
  20. 	char * res = s2; // 这里要小心，直接使用s2 的话，返回的就不是s2的首字母地址了 
  21. 	for(i = 0; i < k; i++)
  22. 	{
  23. 		*res = *s1;
  24. 		res++;
  25. 		s1++;
  26. 		if(*s1 == '\0')
  27. 		{
  28. 			break;
  29. 		}
  30. 	}
  31. 	return s2;
  32. }

有一段文字（文字长度小于200），其中有若干整数。编写函数，找出其中的整数，存入一个数组中。函数原型为：
int findint(char *s,int *a);
其中s表示带数字的字符串，a表示存整数的数组，返回值为字符串中的整数个数。字符串中只有大于等于0的整数。

编写主函数，输入字符串，调用函数识别整数，逆序输出它们。例如，输入字符串“The Wandering Earth exhibition at the China Science and Technology Museum in Beijing, April 4, 2019.”识别数字，输出“2019,4”。

输入：带空格字符串
输出：若干整数，用逗号隔开。
【输入输出样例】
输入：
he Wandering Earth exhibition at the China Science and Technology Museum in Beijing, April 4, 2019.
输出：
2019,4

题目延伸：（1）如果字符串中有负整数，如何修改程序。（2）如果字符串中是实数，如何编写程序

  1. #include<stdio.h>
  2. int findint(char *s,int *a);
  3. int main()
  4. {
  5. 	char s[200];
  6. 	int n[10] = {0};
  7. 	gets(s);
  8. 	int count = findint(s,n);
  9. 	int i;
  10. 	for(i = count -1 ; i >= 0; i--)
  11. 	{
  12. 		if(i == count - 1)
  13. 			printf("%d",n[i]);
  14. 		else
  15. 		{
  16. 			printf(",%d",n[i]);
  17. 		}
  18. 	}
  19. 	return 0;
  20. }
  21. int findint(char *s,int *a)
  22. {
  23. 	int cunt = 0; // 用来记录用来里面有多少个整数
  24. 	char* str; // 用来装一个数字 
  25. 	int flag = 0; // 用来标记首字母已经被锁定 
  26. 	int *temp = a;
  27. 	int numCount = 0; // 数字的字数 
  28. 	while(*s != '\0')
  29. 	{
  30. 		if('0' <= *s && *s <= '9')
  31. 		{
  32. 			str = s;
  33. 			int index = 0;
  34. 			// 统计数字出现的长度 
  35. 			while( *s != '\0' && ( *(s + 1) >= '0' && *(s + 1) <= '9'))
  36. 			{
  37. 				index++;
  38. 				s++;	
  39. 			}
  40. 			int res = 0;
  41. 			int i;
  42. 			
  43. 			for(i = 0; i <= index; i++)
  44. 			{
  45. 				res = (*(str + i) - '0') + res * 10;  	
  46. 			}
  47. 			//printf("%d",res);
  48. 			*temp = res;
  49. 			temp++;
  50. 			numCount++; 
  51. 		}
  52. 		s++;
  53. 	}
  54. 	 return numCount;
  55. }

字符串排序，就象单词的字典排序。'a'<'b'等等。
编写函数，实现字符串的排序(从小到大)，不区分大小写。函数原型为：
void sortstring(char **r,int n);
其中r表示字符串首地址数组的首地址，n表示字符串个数。字符串的首地址放在字符指针数组中，r是这个指针数组的首地址。

编写主函数，输入n和n个单词，调用函数拍序，在主函数中输出排序的单词，每个一行。每个单词的长度不超过20个字符。

【输入输出样例】
输入：
5
study
student
sting
STRING
STRAY

输出：
sting
STRAY
STRING
student
study

  1. #include<stdio.h>
  2. #include<string.h>
  3. #include<stdlib.h>
  4. void sortstring(char **r,int n);
  5. int main()
  6. {
  7. 	int n;
  8. 	scanf("%d",&n);
  9. 	char** r;
  10. 	r = (char**) malloc(n * sizeof(char *));
  11. 	int i;
  12. 	for(i = 0; i < n; i++)
  13. 	{
  14. 		r[i] = (char *) malloc(21 * sizeof(char));
  15. 		scanf("%s",r[i]);
  16. 	}
  17. 	sortstring(r,n);
  18. 	for(i = 0; i < n; i++)
  19. 	{
  20. 		printf("%s\n",r[i]);
  21. 	}
  22. 	for(i = 0; i < n; i++)
  23. 	{
  24. 		free(r[i]);
  25. 	}
  26. 	free(r);
  27. 	return 0;
  28. }
  29. // 这里就要调用前面作业中写的一个比较两个字符串的函数了 
  30. // 或者也可以调用库函数，偷个懒，调用库函数 
  31. void sortstring(char **r,int n)
  32. {
  33. 	int i;
  34. 	int j;
  35. 	char* temp;
  36. 	for(i = 0; i < n - 1; i++)
  37. 	{
  38. 		for(j = 0; j < n - i - 1; j++)
  39. 		{
  40. 			if(strcasecmp(r[j],r[j+1]) > 0)
  41. 			{
  42. 				temp = r[j];
  43. 				r[j] = r[j + 1];
  44. 				r[j + 1] = temp;	
  45. 			}		
  46. 		}	
  47. 	}	
  48. }

编写程序，输入正整数n和n个学生的学号和三门课程成绩，计算每个人的平均分，按平均分从小到大排序，输出排序结果。学号的长度不超过10位；三门课程成绩为整数；平均成绩为实数，输出平均成绩保留两位小数；学生人数不超过50人。
提示：请用多个函数实现。
【输入输出样例】
输入：
5
001 80 80 80
002 60 70 80
003 80 90 93
004 50 60 70
005 60 70 83
输出：
004 50 60 70 60.00
002 60 70 80 70.00
005 60 70 83 71.00
001 80 80 80 80.00
003 80 90 93 87.67

  1. #include<stdio.h>
  2. #include<string.h>
  3. #include<stdlib.h>
  4. typedef struct{
  5. 	char id[11];
  6. 	int score[3]; // 三门分数 
  7. 	double vgrade; // 平均成绩	
  8. }Student;
  9.  
  10. // 计算所有学生的平均成绩
  11. void caclAvg(Student *stu,int n)
  12. {
  13. 	int i, j;
  14. 	for(i = 0; i < n; i++)
  15. 	{
  16. 		double sum = 0;
  17. 		for(j = 0; j < 3; j++)
  18. 		{
  19. 			sum += stu[i].score[j];
  20. 		}
  21. 		stu[i].vgrade = sum / 3.0;
  22. 	}
  23. } 
  24.  
  25. void sortByAvg(Student *stu, int n)
  26. {
  27. 	int i, j;
  28. 	for(i = 0; i < n; i++)
  29. 		for(j = 0; j < n - i -1 ; j++)
  30. 		{
  31. 			if(stu[j].vgrade > stu[j + 1].vgrade)
  32. 			{
  33. 				Student temp = stu[j];
  34. 				stu[j] = stu[j + 1];
  35. 				stu[j + 1] = temp;
  36. 			}
  37. 		}
  38. }
  39. int main()
  40. {
  41. 	int n;
  42. 	scanf("%d",&n);
  43. 	Student *stu = (Student*) malloc(n * sizeof(Student));
  44. 	int i;
  45. 	for(i = 0; i < n; i++)
  46. 	{
  47. 		scanf("%s%d%d%d",stu[i].id,&stu[i].score[0],&stu[i].score[1],&stu[i].score[2]);	
  48. 	}
  49. 	caclAvg(stu,n);
  50. 	sortByAvg(stu,n);
  51. 	for(i = 0; i < n; i++)
  52. 	{
  53. 		printf("%s %d %d %d %.2f\n", stu[i].id, stu[i].score[0], stu[i].score[1], stu[i].score[2], stu[i].vgrade);	
  54. 	}
  55. 	free(stu);	
  56. 	return 0;
  57. }
  58. //

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/不正经/article/detail/143785
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号