上机实验题目解题思路.docx
《上机实验题目解题思路.docx》由会员分享，可在线阅读，更多相关《上机实验题目解题思路.docx（18页珍藏版）》请在冰豆网上搜索。
上机实验题目解题思路
上机实验题目解题思路
目录
指针之二3
2455：
步骤：
3
2456：
步骤：
3
2457：
步骤：
4
3577：
步骤：
4
3578：
步骤：
4
3579：
步骤：
5
3581：
步骤：
5
3583：
步骤：
6
3584：
步骤：
6
3584：
步骤：
7
3585：
步骤：
7
3586：
步骤：
8
指针之一8
2453：
步骤：
8
2454：
步骤：
9
3575：
步骤：
方法同24549
3576：
步骤：
9
3580：
步骤：
10
3582：
步骤：
10
函数11
2452：
步骤：
11
2482：
步骤：
11
3574：
步骤：
12
3571：
步骤：
12
函数12
3565：
步骤：
12
3566：
步骤：
13
3567：
步骤：
13
3568：
步骤：
13
3569：
步骤：
14
3570：
步骤：
14
3571：
步骤：
14
3573：
步骤：
14
数组14
3552：
步骤：
14
3553：
步骤：
15
3555：
步骤：
15
3556：
步骤：
15
3561：
步骤：
15
3893：
步骤：
15
3895：
步骤：
16
3900：
步骤：
16
3905：
步骤：
16
指针之二
2455：
步骤：
1）定义两数交换的函数voidswap（int*p1,int*p2），交换两指针所指向的值。
.
2）main函数：
20个元素的浮点数组表示n个数，用选择排序或冒泡排序对n个数进行从小到大的排序，对排序过程中的交换两数用函数调用来实现，如交换a[i]和a[index]为swap（&a[i],&a[index]）;;
2456：
步骤：
法一：
1）定义移数函数mov（int*a,intn），把数组最后面一个数移到最前面，其他数往后移一位，具体过程为：
a）先保存最后一个元素
b）从第一个元素开始到倒数第二个元素都往后移一位
c）最后一个元素放到最前面
2）定义main函数，多组输入测试数据，循环调用移数函数mov（）。
intmain（）
{inta[100],m,n,i;
while（scanf（"%d%d",&n,&m）!
=EOF）//多组输入n、m值
{
for（I=0;Iscanf（“%d”,&a[i]）;
for（i=0;imov（a,n）;
for循环输出数组的每一个元素
}
Return0;
}
法二：
1）定义递归移数函数mov（int*a,intn,intm），把数组最后面一个数移到最前面，其他数往后移一位，当m>1时，调用函数mov（a,n,m-1）具体过程为：
d）先保存最后一个元素
e）从第一个元素开始到倒数第二个元素都往后移一位
f）最后一个元素放到最前面
g）如果m>1，move（a,n,m-1）;
2）定义main函数
intmain（）
{inta[100],m,n,i;
while（scanf（"%d%d",&n,&m）!
=EOF）//多组输入n、m值
{
for循环输入数组的每一个元素
mov（a,n,m）;
for循环输出数组的每一个元素
}
Return0;
}
2457：
步骤：
1）定义逆序函数voidsort（int*p1,intn），逆序排列p1地址开始的n个数。
循环变量i从0开始到n/2，*（p+i）与*（p+n-1-i）交换。
若是定义函数为voidsort（intx[],intn）,则改为*（p+i）为x[i]，其实作为形参int*p与intp[]是完全等价的，后面*（p+2）与p[2]是等价的。
2）main函数：
多组输入测试。
intmain（）
{intnum[20],n,i;
while（scanf（"%d",&n）!
=EOF）//多组输入n值
{
for循环输入数组的每一个元素
sort（num,n）;//逆序排列数组num，或sort（&num[0],n）或int*p,p=num,sort（p,n）;
for循环输出数组的每一个元素
}
Return0;
}
3577：
步骤：
与2456完全相同。
3578：
步骤：
1）main函数：
定义三个一维字符数组s1[80]/s2[80]/s3[80]，定义一个用于交换的临时字符数组t[80]。
如同三个整数的排序，先比较符数组s1、s2，若s1大于s2则交换两字符串；再比较s1、s3，若s1大于s3则交换两字符串；这样s1一定是最小的。
再比较s2、s3，若s2大于s3则交换两字符串。
2）比较字符数组s1、s2为：
strcmp（s1,s2）
3）字符串S1和s2交换为：
{strcpy（t,s1）;strcpy（s1,s2）;strcpy（s2,t）;}若写s1=s2，为错误。
4）由于有三次比较，就会有三次交换，三次交换为重复代码，考虑用交换函数实现。
交换函数定义为：
voidswap（char*str1,char*str2）//表示函数功能要交换str1、str2对应两个字符值
{chart[80];步骤3的三个语句}
3579：
步骤：
1）自定义求字符串长度函数intlength（char*s），功能为返回字符串s的长度。
intlength（char*s）
{inti;
…………….
returni;
}
2）main函数：
多组输入测试。
intmain（）
{
charstr[80];
while（gets（str）!
=NULL）
{
printf（"%d\n",length（str））;
}
return0;
}
3581：
步骤：
1）自定义排序函数voidsort（int*p,intn），功能是对以p的值为起始地址的n个数排序。
voidsort（int*p,intn）//冒泡法排序代码，也可写成选择法排序的
{inti,j,t;
For（I=0;iFor（j=0;jIf（p[j]>p[j+1]）//a[j]可改为*（p+j）,p[j+1]可改为*（p+j+1）
{t=p[j];p[j]=p[j+1];p[j+1]=t;}
}
2）main函数：
多组输入测试。
intmain（）
{Inta[100];
IntI,n;
while（scanf（"%d",&n）!
=EOF）
{输入数组每一个元素；
调用排序函数；
输出数组每一个元素;
换行printf（"\n"）;
}
return0;
}
3583：
步骤：
1）自定义排序函数voidsortA（int*p,intn），功能是对以p的值为起始地址的n个数从小到排序；方法参考题目3581
2）自定义排序函数voidsortD（int*p,intn），功能是对以p的值为起始地址的n个数从大到排序，方法参考题目3581。
3）main函数：
多组输入测试。
intmain（）
{Inta[10],i;
Charc;
while（scanf（"%c",&c）!
=EOF）
{输入10个整数；
Getchar（）;//得到10个整数输入时的最后一个回车符，让下一次的%c能得到字符’A’或’D’
If（c==‘A’）
调用排序函数sortA（a,10）；
Elseif（c==‘D’）
调用排序函数sortD（a,10）;
输出数组每一个元素;
换行printf（"\n"）;
}
return0;
}
3584：
步骤：
1）自定义查找函数intsearch（intlist[],intn,intx），功能是在以list值为起始地址的n个数中找x，若找到返回下标，否则返回-1.
2）main函数：
多组输入测试。
intmain（）
{inta[10],x,i,result;
while（scanf（"%d",&a[0]）!
=EOF）
{for（i=1;i<10;i++）
scanf（"%d",&a[i]）;
scanf（"%d",&x）;
result=search（a,10,x）;
if（result==-1）
printf（"Notfound\n"）;
else
printf（"%d\n",result）;
}
return0;
}
3584：
步骤：
1）自定义查找函数intsearch（intlist[],intn,intx），功能是在以list值为起始地址的n个数中找x，若找到返回下标，否则返回-1.
2）main函数：
多组输入测试。
intmain（）
{inta[10],x,i,result;
while（scanf（"%d",&a[0]）!
=EOF）
{for（i=1;i<10;i++）
scanf（"%d",&a[i]）;
scanf（"%d",&x）;
result=search（a,10,x）;
if（result==-1）
printf（"Notfound\n"）;
else
printf（"%d\n",result）;
}
return0;
}
3585：
步骤：
1）自定义函数voidmcopy（char*src,char*dst,intm），功能是从src为起始地址的第m个字符开始的全部字符复制到以dst为起始地址的字符数组中。
voidmcopy（char*src,char*dst,intm）
{inti,j=0;
for（i=m;src[i]!
='\0';i++,j++）
………..;
dst[j]='\0';
}
2）main函数：
多组输入测试。
intmain（）
{intm;
charsrc[80],dst[80];
while（scanf（"%d",&m）!
=EOF）
{
…………………
}
return0;
}
3586：
步骤：
1）自定义函数intstrcomp（char*s1,char*s2），功能是当s1>s2时，返回1，当s1==s2时，返回0，当s1不能调用函数strcmp（），字符串的比较是从两个字符串的首字符开始，依次比较相对应的字符（比较字符的ASCII码），直到出现不同的字符或遇到’\0’为止。
如果所有字符相同，表示相同；以第一个不相同的字符进行比较，哪个大则其对应的字符串就为较大的字符串。
如“abc”与”abcd”，第一个不同的是’\0’与’d’，而’d’>’\0’，所以“abcd”大于”abc”。
intstrcomp（char*s1,char*s2）
{intresult,……
Returnresult;
}
2）main函数：
多组输入测试。
intmain（）
{
chars1[80],s2[80];
while（gets（s1）!
=NULL）
{
gets（s2）;
printf（"%d\n",strcomp（s1,s2））;
}
return0;
}
指针之一
2453：
步骤：
1）定义两数交换的函数voidswap（int*p1,int*p2），交换两指针所指向的值。
.
2）main函数：
多组输入a、b，调用交换函数交换两变量值。
代码框架：
voidswap（int*p1,int*p2）
{
……
}
intmain（）
{inta,b;
Int*pointer_1,*pointer_2;
while（scanf（"%d%d",&a,&b）!
=EOF）//输入a、b值
{
Pointer_1=….;
Pointer_2=…..;
If（aSwap（…..）;
printf（“%d%d\n”,a,b）;
}
return0;
}
2454：
步骤：
h）定义同2453相同的函数voidswap（int*p1,int*p2），交换两指针所指向的值。
i）定义main函数，多组输入三个数，从大到小输出。
intmain（）
{inta,b，c;
while（scanf（"%d%d",&a,&b）!
=EOF）//输入a、b值
{If（aSwap（&a,&b）;
If（aSwap（&a,&c）;
If（bSwap（&b,&c）;
printf（“%d%d%d\n”,a,b,c）;
}
return0;}
3575：
步骤：
方法同2454
3576：
步骤：
1）定义类同2453函数voidswap（float*p1,float*p2），交换两指针所指向的值。
2）定义main函数，多组输入五个数，从小到大输出。
intmain（）
{inta[5],i,temp;
while（scanf（"%f",&a[0]）!
=EOF）//输入a、b值
{
for（i=1;i<5;i++）
scanf（“%f”,&a[i]）;
选择排序完成5个数的排序，其中交换通过
Swap（&a[],&a[]）完成;
循环输出a的所有元素;
}
return0;
}
3580：
步骤：
1）自定义函数input（inta[],intn）,output（inta[],intn）；
Voidinput（inta[],intn）//函数无返回值，等效于void（int*a,intn）
{inti;
For（i=0;iScanf（“%d”,&a[i]）;
}
2）在main函数中，调用它，完成对数组n个元素的输入输出。
Intmain（）
{intarray[100],n;
While（scanf（“%d”,&n）!
=EOF）
{
Input（array,n）;
Output（array,n）;
}
Return0;
}
3582：
步骤：
1）定义一个计算两个数和、差的函数sumDiff（intop1,intop2,int*pSum,int*pDiff）,功能是求两个数op1、op2的和、差，其中*psum和*pdiff是计算得出的和与差，代替return返回值，故函数不需要返回任何值了。
VoidsumDiff（intop1,intop2,int*pSum,int*pDiff）
{//op1、op2是要计算的两数
*pSum=op1+op2;//pSum是main（）函数中变量的地址，故修改的是main（）函数中变量的值
……
}
2）在main函数中，调用它，计算输入的任意两个数的和与差。
Intmain（）
{inta,b,s,d;
While（scanf（“%d%d”,&a,&b）!
=EOF）
{
sumDiff（a,b,&s,&d）;
printf（“sum=%d,diff=%d\n”,s,d）;
}
Return0;
}
函数
2452：
步骤：
3）定义判断素数函数intprime（intx）：
当x是素数时，函数返回1，否则返回0.
4）main函数：
多组输入n、m，对n-m间的每一个数i，调用函数prime（x）判断是否是素数，若是就输出。
代码框架：
intprime（intx）//（循环从2到sqrt（x），不能从2到x-1）
{
……
}
intmain（）
{intm,n,i;
while（scanf（"%d%d",&n,&m）!
=EOF）//输入n、m值
{
for（i=n;i<=m;i++）
{
If（）
Printf（“%d”,i）;.....//输出素数
}
printf（“\n”）;
}
return0;
}
2482：
步骤：
3）定义递归函数intage（intn,intm,intk），功能是求第n个人的岁数，并返回此岁数。
函数：
intage（intn,intm,intk）
{intresult;
if（n==1）
result=k;
else
result=age（n-1,m,k）+m;
returnresult;
}
4）定义main函数，多组输入，输出第n个人的岁数。
3574：
步骤：
1）定义函数intreverse（intn），功能返回n的逆序数。
函数：
intreverse（intn）
{intresult=0;
do{……
………………
}while（….!
=0）;
returnresult;
}
2）定义main函数，多组输入n，输出结果。
3571：
步骤：
1）定义递归函数intfib（intn）,，功能是求返回第n项Fibonacci数。
函数：
intfib（intn）
{inti,f1,f2,item,result;
if（n==1||n==2）
result=1;
else
result=fib（n-1）+fib（n-2）
returnresult;
}
2）定义main函数,多组输入，输出结果。
intmain（）
{int….
while（scanf（……）!
=EOF）
{
for（i=m;i<=n;i++）
printf（“%5d“,fib（i））
printf（“\n”）;
}
函数
3565：
步骤：
1）定义符号函数sign（intn）
2）main函数：
输入x，调用函数sign（x）。
代码框架：
intsign（intn）
{intm;
........
returnm;
}
intmain（）
{intx,y;
while（scanf（"%d",&x）!
=EOF）//输入x值
{
y=sign（x）;
.....//输出y的值
}
return0;
}
3566：
步骤：
1）定义函数max（intx,inty），功能是求两个数x、y中最大数的，并返回最大数。
函数：
intmax（intx,inty）
{intz;
if（x>y）z=x;
elsez=y;
returnz;
}
2）main函数：
定义三个变量a、b、c和m、多组测试输入三个整数；两次调用函数，就可得到最大数了。
3567：
步骤：
1）定义判断素数的函数intprime（intx），若是素数返回1，否则返回0。
2）主函数：
从100-200每个数都通过调用函数prime（i）来判断是否素数。
intmain（）
{inti;
For（I=100;I<200;i++）
If（prime（i）==1）
Printf（“%5d”,i）;
}（以上代码未处理换行）
3568：
步骤：
1）定义求n!
函数intfact（intn），函数返回n!
值。
（既可用整数表阶乘也可用浮点表阶乘）
2）主函数：
从1-10每个数都通过调用函数fact（i）来求i!
，并累加求和。
由于阶乘和较大，故用浮点表示和。
intmain（）
{inti;floatsum;
For（I=1;I<=10;i++）
Sum+=fact（i）;
Printf（“%f\n”,sum）;
}
3569：
步骤：
1）定义函数intfn（inta,intn），返回a…a（n个a）。
2）主函数核心语句：
循环i=1到n,s+=fn（a,i）。
3570：
步骤：
1）定义函数intcountdigit（intnumber,intdigit），返回number中数字digit的个数
关键算法：
取出number的每一位，若等于digit，则计数count加1，最后返回count。
2）主函数核心语句：
输入x,个数n=countdigit（x,2）。
3571：
步骤：
1）定义函数intfactorsum（intnumber），返回number的因子和。
关键算法：
i从1到number-1，若i是number的因子，则累加和sum；最后返回sum。
2）主函数main（），核心语句：
i从m到n，若I==fact（i），则输出i。
3573：
步骤：
1）定义函数intis（intnumber），若数字立方和等于本身，返回1，否则返回0。
关键算法：
累加number的每一位数字，若和等于number，则返回1，否则返0。
2）主函数main（），核心语句：
i从m到n，若I==is（i），则输出i。
数组
3552：
步骤：
1）定义数组a[10][10],s[10]及相关变量
2）多组测试：
输入m,n；二重for循环输入数组a的每一个元素（scanf（“%d”,&a[i][j]），注意%d后不加空格）。
3）对于第一行a[0]的每个元素a[0][j]（j=0-n-1）都和第m-1行对应元素交换。
4）对每一行（i=0---m-1），计算元素和并存入数组s[i]中
5）输出数组a的每一行（i=0----m-1）元素及s[i]，并换行。
3553：
步骤：
1）定义数组a[10][10]及相关变量
2）多组测试：
输入n；二重for循环输入数组a的每一个元素（scanf（“%d”,&a[i][j]），注意%d后不加空格）。
3）主对角线元素：
a[i][i]，副对角线a[i][n-1-i]。
3555：
步骤：
1）定义数组a[6][6]、标记是否上三角变量flag、及相关变量
2）多组测试：
输入n；flag=1;二重for循环输入数组a的每一个元素
3）对于主对角线以下每个元素进行判断，如果不为零的，则flag=0同时跳出循环。
4）
升级会员 