目录
- 41.累加链表结点数据域中的数据作为函数值返回
- 42.根据整型形参m，计算如下公式的值
- 43.删除数列中值为x的元素
- 44.从N个字符串中找出最长的那个串，并将其地址作为函数值返回
- 45.将两个长度相等的纯数字字符串当作两个加数，求其代表的数值之和
- 46.统计形参str中所出现的大写字母的范围跨度
- 47.根据整型形参m，计算如下公式的值
- 48.求矩阵（二维数组)a[N][N]中每行的最小值，结果存放到数组b中
- 49.从一个3行4列的矩阵中找出最大数及最大数所在位置的下标，函数返回值为最大数，形参pRow和pCo1返回最大数所在位置的下标
- 50.列出带头结点单链表中所有没有删除标记的数据
41.累加链表结点数据域中的数据作为函数值返回
给定程序modi1.c的主函数中，将a、b、c三个结点链成一个单向链表，并给各结点的数据域赋值，函数fun()的作用是:累加链表结点数据域中的数据作为函数值返回。
请改正函数fun中指定部位的错误，使它能得出正确的结果。
注意:不要改动main函数，不得增行或删行，也不得更改程序的结构。
modi1.c：
#include <stdio.h>
typedef struct list
{ int data;
struct list *next;
} LIST;
int fun(LIST *h)
{ LIST *p;
/**********found**********/
int t;//t是求总和累加的，那t就要赋初值
p=h;//让p指向链表的开头
/**********found**********/
while( *p )//应该是指针p为空指针时跳出循环
{
/**********found**********/
t=t+p.data;//p是结构体指针，应该用->
p=(*p).next;//指针p后移指向下一个节点
}
return t;
}
main()
{ LIST a, b, c, *h;
a.data=34; b.data=51; c.data=87; c.next='\0';//节点c为最后一个节点，以空结尾
h=&a; a.next=&b; b.next=&c;//比较少见的节点链成链表方式,毕竟现在都在用结构体指针
printf("总和 = %d\n",fun( h ));
getchar();
}
街头思路：
组建链表的方式比较少见，但也并不难理解，实际上是一样的，只是把->变成了.
答案：
#include <stdio.h>
typedef struct list
{ int data;
struct list *next;
} LIST;
int fun(LIST *h)
{ LIST *p;
/**********found**********/
int t=0;
p=h;
/**********found**********/
while( p )
{
/**********found**********/
t=t+p->data;
p=(*p).next;
}
return t;
}
main()
{ LIST a, b, c, *h;
a.data=34; b.data=51; c.data=87; c.next='\0';
h=&a; a.next=&b; b.next=&c;
printf("总和 = %d\n",fun( h ));
getchar();
}
测试：
42.根据整型形参m，计算如下公式的值
给定程序MODI1.C中fun函数的功能是:根据整型形参m，计算如下公式的值。
例如，若主函数中输入5，则应输出-0.283333。
请改正函数fun中的错误或在横线处填上适当的内容并把横线删除，使它能计算出正确的结果。
注意:不要改动main函数，不得增行或删行，也不得更改程序的结构!
MODI1.C:
#include <stdio.h>
double fun( int m )
{
double t = 1.0;
int i;
for( i = 2; i <= m; i++ )
/**********found**********/
t = 1.0-1 /i;//这里对比下题目公式，这里应该是t=t-1.0/i,1.0是因为保证这个分式结果会保留小数
/**********found**********/
_______;//这里应该返回公式的结果，也就是返回t
}
main()
{
int m ;
printf( "\nPlease enter a number:\n" );
scanf( "%d", &m);
printf( "\n\nThe result is %lf\n", fun( m ) );
getchar();
}
解题思路：
给个空填，还以为我做的是程序填空，这种什么什么公式的都不难，找出规律就好
答案：
#include <stdio.h>
double fun( int m )
{
double t = 1.0;
int i;
for( i = 2; i <= m; i++ )
/**********found**********/
t = t-1.0 /i;
/**********found**********/
return t;
}
main()
{
int m ;
printf( "\nPlease enter a number:\n" );
scanf( "%d", &m);
printf( "\n\nThe result is %lf\n", fun( m ) );
getchar();
}
测试：
43.删除数列中值为x的元素
假定整数数列中的数不重复，并存放在数组中。给定程序modi1.c中函数fun的功能是:删除数列中值为x的元素。n中存放的是数列中元素的个数。
请改正程序中的错误，使它能得出正确结果。
注意:不要改动main函数，不得增行或删行，也不得更改程序的结构!
modi1.c:
#include <stdio.h>
#define N 20
int fun(int *a,int n,int x)
{ int p=0,i;
a[n]=x;//数组已经有元素的下标为0到n-1，在下标存入x是为了让下面的while循环不会死循环
while( x!=a[p] )//数组元素不等于x时进入循环，等于时跳出
p=p+1;
/**********found**********/
if(P==n) return -1;//下标p写成大写了，这句的意思是当p等于n时，也就是意味着数组元素遍历完了，数组里没有等于x的元素
else
{ for(i=p;i<n-1;i++)//这里就进入数组元素里有等于x的分支了
/**********found**********/
a[i+1]=a[i];//这句话成了向后覆盖了，元素整体后移了，我们应该要覆盖的是a[p]才对，应该元素前移
return n-1;//把等于x的元素覆盖了后，数组中元素个数就少了一个
}
}
main()
{ int w[N]={-3,0,1,5,7,99,10,15,30,90},x,n,i;
n=10;
printf("The original data :\n");
for(i=0;i<n;i++) printf("%5d",w[i]);
printf("\nInput x (to delete): "); scanf("%d",&x);//输入要删去的值为x的元素
printf("Delete : %d\n",x);
n=fun(w,n,x);
if ( n==-1 ) printf("***Not be found!***\n\n");//返回-1，则数组中没有元素值为x
else
{ printf("The data after deleted:\n");
for(i=0;i<n;i++) printf("%5d",w[i]);printf("\n\n");//若有，则输出一遍数组
}
getchar();
}
解题思路：
在数组末尾加上个x,很有意思的思路(⊙o⊙)
答案：
#include <stdio.h>
#define N 20
int fun(int *a,int n,int x)
{ int p=0,i;
a[n]=x;
while( x!=a[p] )
p=p+1;
/**********found**********/
if(p==n) return -1;
else
{ for(i=p;i<n-1;i++)
/**********found**********/
a[i]=a[i+1];
return n-1;
}
}
main()
{ int w[N]={-3,0,1,5,7,99,10,15,30,90},x,n,i;
n=10;
printf("The original data :\n");
for(i=0;i<n;i++) printf("%5d",w[i]);
printf("\nInput x (to delete): "); scanf("%d",&x);
printf("Delete : %d\n",x);
n=fun(w,n,x);
if ( n==-1 ) printf("***Not be found!***\n\n");
else
{ printf("The data after deleted:\n");
for(i=0;i<n;i++) printf("%5d",w[i]);printf("\n\n");
}
getchar();
}
测试：
存在值为x的元素:
不存在值为x的元素：
44.从N个字符串中找出最长的那个串，并将其地址作为函数值返回
给定程序modi1.c中，函数fun的功能是:从N个字符串中找出最长的那个串，并将其地址作为函数值返回。各字符串在主函数中输入，并放入一个字符串数组中。
请改正程序中的错误，使它能得出正确结果。
注意:不要改动main函数，不得增行或删行，也不得更改程序的结构!
modi1.c:
#include <stdio.h>
#include <string.h>
#define N 5
#define M 81
/**********found**********/
fun(char (*sq)[M])//在main函数可以看到返回的是char类型的指针，所以fun也该是char *
{ int i; char *sp;
sp=sq[0];
for(i=0;i<N;i++)
if(strlen( sp)<strlen(sq[i]))//筛出最长字符串
sp=sq[i] ;//地址赋给指针sp
/**********found**********/
return sq;//应该返回指向最长字符串的指针sp
}
main()
{ char str[N][M], *longest; int i;
printf("Enter %d lines :\n",N);
for(i=0; i<N; i++) gets(str[i]);
printf("\nThe N string :\n",N);
for(i=0; i<N; i++) puts(str[i]);
longest=fun(str);//longest是char型指针
printf("\nThe longest string :\n"); puts(longest);
getchar();
}
解题思路：
看来我的基础还是不够扎实，看到puts里直接放指针，还疑惑了下
答案：
#include <stdio.h>
#include <string.h>
#define N 5
#define M 81
/**********found**********/
char *fun(char (*sq)[M])
{ int i; char *sp;
sp=sq[0];
for(i=0;i<N;i++)
if(strlen( sp)<strlen(sq[i]))
sp=sq[i] ;
/**********found**********/
return sp;
}
main()
{ char str[N][M], *longest; int i;
printf("Enter %d lines :\n",N);
for(i=0; i<N; i++) gets(str[i]);
printf("\nThe N string :\n",N);
for(i=0; i<N; i++) puts(str[i]);
longest=fun(str);
printf("\nThe longest string :\n"); puts(longest);
getchar();
}
测试：
45.将两个长度相等的纯数字字符串当作两个加数，求其代表的数值之和
给定程序MODI1. C中函数char *fun(char *s1, char *s2，char *r) 的功能是:将两个长
度相等的纯数字字符串当作两个加数，求其代表的数值之和并以字符串的形式存入r所指内存且返回。
如: s1是”723”，s2是”567", 则返回的字符串为”1290”。要考虑进位。
请改正程序中的错误，使它能得出正确的结果。
注意:不要改动main函数，不得增行或删行，也不得更改程序的结构!
MODI1. C:
#include <stdio.h>
#include <string.h>
char *fun(char * s1,char *s2,char *r)
{
int len,cy=0,md;
char *p,*q,*t;
len=strlen(s1);
p=s1+len-1;
q=s2+len-1;
t=r+len;
/**********************found***********************/
*t='\0';//这句用注释不好说，看解题思路吧
while(p>=s1)
{
/**********************found***********************/
md=*p+*q-'0'+cy;//两个数字字符不像整数相加，要想转化为整数，要减两个字符'0'
if(md>=10) cy=1;
else cy=0;
*t=md%10+'0';
p--;//三个指针前移
q--;
t--;
}
/**********************found***********************/
if(cy=1) //单等是赋值，双等才是相等
*t='1';//若最后最高位相加有进位则存入
else
{
while(*r++=*++t);//如果没有则字符串里元素全部前移
}
return r;
}
void main()
{
char s1[100],s2[100],s3[101];
strcpy(s1,"65743");
strcpy(s2,"85339");
fun(s1,s2,s3);
printf("%s+%s=%s\n",s1,s2,s3);
}
解题思路：
理一下代码的思路，最终两个数字字符串相加的结果是存入r中的，初始化三个指针，p指向字符串s1最后一个字符，q指向字符串s2最后一个字符，t则指向字符串r下标为len的位置，为了确保最高位的进位有空间存放，r+len可能就是最后一个字符，字符串要以'\0'结尾，那么就要在r+len+1的位置赋'\0'
代码中的*t='\0'要改成*(t+1)='\0',确保字符串以’\0’结尾，再用while循环遍历,题目说两个数字字符串长度相等，所以这里循环表达式是p>=s1或者q>=s2都可以，md是两个字符串中字符转为整数相加的结果，两个数字字符相加不像整数相加，要减两个字符’0’才会转化为两个整数相加的结果，如果md大于10，则进位cy赋1，md是整数，用取余的方式去掉可能有的进位，再加上字符’0’转化为字符，赋给指针t存入字符串r，然后一个判断最高位相加是否有进位
答案：
#include <stdio.h>
#include <string.h>
char *fun(char * s1,char *s2,char *r)
{
int len,cy=0,md;
char *p,*q,*t;
len=strlen(s1);
p=s1+len-1;
q=s2+len-1;
t=r+len;
/**********************found***********************/
*(t+1)='\0';
while(p>=s1)
{
/**********************found***********************/
md=*p+*q-'0'-'0'+cy;
if(md>=10) cy=1;
else cy=0;
*t=md%10+'0';
p--;
q--;
t--;
}
/**********************found***********************/
if(cy==1)
*t='1';
else
{
while(*r++=*++t);
}
return r;
}
void main()
{
char s1[100],s2[100],s3[101];
strcpy(s1,"65743");
strcpy(s2,"85339");
fun(s1,s2,s3);
printf("%s+%s=%s\n",s1,s2,s3);
}
测试：
46.统计形参str中所出现的大写字母的范围跨度
给定程序MODI1. C中，函数fun的功能是:统计形参str中所出现的大写字母的范围跨度,
即按字典序最前面的大写字母与最后面的大写字母ASCII值之差，并传递回主函数输出。若没有大写字母，则函数输出0。
例如: 若str的内容为”Baybye!Doom"，其中大写字母为B和D，D与B之 差为2，函数返回2,程序输出2。
若str的内容为"M68C9Xaa”，其中字典序最前面的大写字母为C，最后面的大写字母为X，X与C之差为21，函数返回21，程序输出21。
请改正函数fun中指定部位的错误，使它能得出正确的结果。
注意:不要改动main函数，不得增行或删行，也不得更改程序的结构!
MODI1. C：
#include <stdio.h>
#include <string.h>
int fun(char* str) {
int k, c0, c1;
c0 = c1 = -1;
for (k=0; k<strlen(str); k++) //找出字符串中第一个大写字母,就停止循环
if ( (str[k] >= 'A') && (str[k] <= 'Z') )
{ c0 = c1 = k;//下标赋给c0,c1
break;
}
if (c0 == -1)//进入此分支说明该字符串没有大写字母
return 0;
/**********************found***********************/
for (k=0; k<strlen(str)-1; k++) //这里循环条件有误，少了一项，应该是<=
{
/**********************found***********************/
if ( (str[k] >= 'A') || (str[k] <= 'Z') ) //这里是要筛出大写字母，应该是且&&才对
{
if (str[k] < str[c0])//c0下标指向字符串中字典序最小的大写字母
c0 = k;
if (str[k] > str[c1])//c1指向字符串字典序最大的大写字母
c1 = k;
}
}
/**********************found***********************/
return c1 - c0;//应该返回字符串中字典序最大的大写字母与字典序最小的大写字母之差，这里返回的下标之差了
}
int main()
{
char str[100];
int l;
printf("input string:");
scanf("%s", str);
l = fun(str);
printf("span:%d\n", l);
return 0;
}
解题思路：
筛出大写字母可以用一个函数：isupper()
头文件为#include<ctype.h>
int isupper(char c);
如果 c 是一个大写字母，则该函数返回非零值（true），否则返回 0（false）。
答案：
#include <stdio.h>
#include <string.h>
int fun(char* str) {
int k, c0, c1;
c0 = c1 = -1;
for (k=0; k<strlen(str); k++)
if ( (str[k] >= 'A') && (str[k] <= 'Z') )
{ c0 = c1 = k;
break;
}
if (c0 == -1)
return 0;
/**********************found***********************/
for (k=0; k<=strlen(str)-1; k++)
{
/**********************found***********************/
if ( (str[k] >= 'A') && (str[k] <= 'Z') )
{
if (str[k] < str[c0])
c0 = k;
if (str[k] > str[c1])
c1 = k;
}
}
/**********************found***********************/
return str[c1]-str[c0];
}
int main()
{
char str[100];
int l;
printf("input string:");
scanf("%s", str);
l = fun(str);
printf("span:%d\n", l);
return 0;
}
测试：
47.根据整型形参m，计算如下公式的值
给定程序MODI1.C中函数fun的功能是:根据整型形参m，计算如下公式的值。
例如，若m=2000，则应输出:0.000160。
请改正程序中的语法错误，使它能计算出正确的结果。
注意:不要改动main函数，不得增行或删行，也不得更改程序的结构!
MODI1.C:
#include <stdio.h>
/************found************/
fun ( int m )//看最后返回的y是double类型的
{
double y = 0, d ;
int i ;
/************found************/
for( i = 100, i <= m, i += 100 )//for循环()内的表达式应该用分号;分隔
{
d = (double)i * (double)i ;
y += 1.0 / d ;
}
return( y ) ;
}
main( )
{
int n = 2000 ;
printf( "\nThe result is %lf\n", fun ( n ) ) ;
getchar();
}
解题思路：
这题既然扯到了for的结构，那就说下关于for循环的一些名词吧
for(初始化表达式;循环条件；更新表达式)
{
}
for循环的执行过程：
1.执行初始化表达式，用于初始化循环变量
2.判断循环条件，如果条件为真，则执行循环体，否则跳出循环
3.执行循环体中的代码
4.执行更新表达式，更新循环变量的值
5.回到步骤2，继续判断循环条件，重复执行循环体和更新表达式的过程
for适用已知循环次数的情况
答案：
#include <stdio.h>
/************found************/
double fun ( int m )
{
double y = 0, d ;
int i ;
/************found************/
for( i = 100;i <= m;i += 100 )
{
d = (double)i * (double)i ;
y += 1.0 / d ;
}
return( y ) ;
}
main( )
{
int n = 2000 ;
printf( "\nThe result is %lf\n", fun ( n ) ) ;
getchar();
}
测试：
48.求矩阵（二维数组)a[N][N]中每行的最小值，结果存放到数组b中
给定程序MODI1.C中，函数fun的功能是求矩阵（二维数组)a[N][N]中每行的最小值，结果存放到数组b中。
例如：若
则结果应为1，5，9，13，
请改正函数fun中指定部位的错误，使它能得出正确的结果。
注意:不要改动main函数，不得增行或删行，也不得更改程序的结构。
MODI1.C：
#include <stdio.h>
#define N 4
void fun(int a[][N], int b[])
{ int i, j;
for (i=0; i<N; i++)
{
/**********found**********/
b[i] = a[0][0];//题目要求是找出每一行的最小数，应该是把每行的第一个元素赋给b[i]
/**********found**********/
for (j=1; j<N-1; j++)//循环条件错了，漏了一项
/**********found**********/
if ( b[i] < a[i][j] )//题目要求的是找出最小数，而这里变成找最大数
b[i] = a[i][j];
}
}
main()
{ int a[N][N]={{1,4,3,2},{8,6,5,7},{11,10,12,9},{13,16,14,15}},b[N]; int i;
fun(a,b);
for (i=0; i<N; i++) printf("%d,", b[i]);
printf("\n");
getchar();
}
解题思路：
没什么难度(￣︶￣*))
答案：
#include <stdio.h>
#define N 4
void fun(int a[][N], int b[])
{ int i, j;
for (i=0; i<N; i++)
{
/**********found**********/
b[i] = a[i][0];
/**********found**********/
for (j=1; j<=N-1; j++)
/**********found**********/
if ( b[i] > a[i][j] )
b[i] = a[i][j];
}
}
main()
{ int a[N][N]={{1,4,3,2},{8,6,5,7},{11,10,12,9},{13,16,14,15}},b[N]; int i;
fun(a,b);
for (i=0; i<N; i++) printf("%d,", b[i]);
printf("\n");
getchar();
}
测试：
49.从一个3行4列的矩阵中找出最大数及最大数所在位置的下标，函数返回值为最大数，形参pRow和pCo1返回最大数所在位置的下标
给定程序MODI1. C中，函数fun的功能是:从一个3行4列的矩阵中找出最大数及最大数所
在位置的下标，函数返回值为最大数，形参pRow和pCo1返回最大数所在位置的下标。
请改正程序中的错误，使它能得出正确的结果。
注意:不要改动main函数，不得增行或删行，也不得更改程序的结构!
MODI1. C：
#include <stdio.h>
int func(int (*p)[4], int m, int n, int *pRow, int *pCol)
{
int i, j, max;
/**********found**********/
max = *p;//这是二维数组，单一个解引符*p指代的是一行而不是一个元素，
*pRow = 0;//指代行
*pCol = 0;//指代列
for (i=0;i<m;i++)
{
for (j=0;j<n;j++)
{
if ( *(*(p+i)+j) > max)
{
max = *(*(p+i) + j);
*pRow = i;
/**********found**********/
*pCol = i + j;//指代列下标，应该是j
}
}
}
/**********found**********/
return *max;//max是int类型的，不是指针
}
int main()
{
int aa[3][4] = {{1,3,5,7},{21,19,27,22},{11,17,18,20}};
int maxVal, row, col;
maxVal = func(aa, 3, 4, &row, &col);
printf("%d %d %d\n", maxVal, row, col);
return 0;
}
解题思路：
说下代码出现的二维数组指针，
- 在第一处错误里，指针可以写成
max=(*p)[0];//这个想必很好理解吧，*p指代行，后面的列已给出
max=*p[0];//上面那个去掉括号也是一样的
max=p[0][0];//这个就不必多说了吧
max=*(*(p+0)+0);//最里面的括号是指代行，外层括号的加0就是对列的调整，解引后也就指向了单个元素
max=**p;//上面那句看懂了，这句就不难理解了，就是+0这个省略掉了
答案：
#include <stdio.h>
int func(int (*p)[4], int m, int n, int *pRow, int *pCol)
{
int i, j, max;
/**********found**********/
max = **p;
*pRow = 0;
*pCol = 0;
for (i=0;i<m;i++)
{
for (j=0;j<n;j++)
{
if ( *(*(p+i)+j) > max)
{
max = *(*(p+i) + j);
*pRow = i;
/**********found**********/
*pCol = j;
}
}
}
/**********found**********/
return max;
}
int main()
{
int aa[3][4] = {{1,3,5,7},{21,19,27,22},{11,17,18,20}};
int maxVal, row, col;
maxVal = func(aa, 3, 4, &row, &col);
printf("%d %d %d\n", maxVal, row, col);
return 0;
}
测试：
50.列出带头结点单链表中所有没有删除标记的数据
给定程序MODI1. C中，函数void list (MYDATA *h)的功能是:列出带头结点单链表中所有
没有删除标记的数据。调用这个函数时，传给形参h的是指向单链表头结点的指针。
例如：当10个结点的数据为1,2,3,4,5,6, 7,8,9, 10时，输出将是:3 4 6 7 8 9 10。
其中，各个数据所对应的删除标记是由随机数产生的。
请改正函数list中指定部位的错误，使它能得出正确的结果。
注意:不要改动main函数和creat函数，不得增行或删行，也不得更改程序的结构。
MODl1.C:
#include<stdio.h>
#include<stdlib.h>
typedef struct dat
{
char deleted; //是否删除：0-未删除，1-删除
int data;
struct dat* next;
} MYDATA;
void list(MYDATA *h)
{
/******found******/
MYDATA p;//由下文可见p应为结构体指针
p=h->next;
while(p!=NULL)
{
/******found******/
if(p->data==0)//题目中说了是要输出没有删除标记的数据，data是数据，deleted才是删除标记，deleted为0时，未删除，输出
{
printf("%d ",p->data);
}
/******found******/
p=next;//指针p后移，应该是p=p->next
}
}
void creat(MYDATA *h,int *d,int n)//n是节点数
{
MYDATA *p, *q;
int i=0,del;
q=h;
while(n>0)
{
p=( MYDATA *)malloc(sizeof(MYDATA));
del=rand()%2;//取随机数范围为0到1
p->data=d[i];
p->deleted=del;//删除标记
p->next=q->next;//这里有个有意思的点，q的初始化是头节点，头节点的指针域为空，在之后这个q节点的指针域始终是空，也就不用最后最后赋个空了
q->next=p;//把p节点放在q节点后
q=p;
n--;i++;
}
}
void main()
{
MYDATA *head;
int n=10,dd[]={1,2,3,4,5,6,7,8,9,10};
head=(MYDATA *)malloc(sizeof(MYDATA));//开辟空间
head->next=NULL;
creat(head,dd,n);
list(head);
}
解题思路：
这题的int类型赋给char类型看得我不太适应，
随机数函数出现了，那就再回忆下这个rand()函数的定义：
rand()%(n-m+1)+m //产生一个[m,n]范围的随机数
答案：
#include<stdio.h>
#include<stdlib.h>
typedef struct dat
{
char deleted; //是否删除：0-未删除，1-删除
int data;
struct dat* next;
} MYDATA;
void list(MYDATA *h)
{
/******found******/
MYDATA *p;
p=h->next;
while(p!=NULL)
{
/******found******/
if(p->deleted==0)
{
printf("%d ",p->data);
}
/******found******/
p=p->next;
}
}
void creat(MYDATA *h,int *d,int n)
{
MYDATA *p, *q;
int i=0,del;
q=h;
while(n>0)
{
p=( MYDATA *)malloc(sizeof(MYDATA));
del=rand()%2;
p->data=d[i];
p->deleted=del;
p->next=q->next;
q->next=p;
q=p;
n--;i++;
}
}
void main()
{
MYDATA *head;
int n=10,dd[]={1,2,3,4,5,6,7,8,9,10};
head=(MYDATA *)malloc(sizeof(MYDATA));
head->next=NULL;
creat(head,dd,n);
list(head);
}
测试：
