C语言入门必刷100题合集之每日一题（20-40）
二十一：C语言实现打印菱形。
解题思路：这道题目的逻辑的很简单，本质来说还是循环的嵌套，然后就是一些简单的数学逻辑，有了上个题目心形表白的学习，看这道题应该很容易看懂。菱形一共分为两部分，菱形的上下部分。
C语言实现前四行的打印：
for(i=0;i<4;i++)
{
for(j=0;j<=2-i;j++)
{
printf(" ");
}
for(k=0;k<=2*i;k++)/
{
printf("*");
}
printf("\n");
}单独打印结果：
#include//头文件
int main()//主函数
{
int i,j,k;//定义整型变量
for(i=0;i<4;i++)//循环四次，打出前四行
{
for(j=0;j<=2-i;j++)//设定每行*号前面的空格，每行都是2-i个
{
printf(" ");//打印空格
}
for(k=0;k<=2*i;k++)//循环打出2*i-i个*号
{
printf("*");//打印*号
}
printf("\n");//打完一行后换行
}
for(i=0;i<=2;i++)//循环三次，打出后三行
{
for(j=0;j<=i;j++)//假设每行*号前面的空格，每行都是i个
{
printf(" ");//打印空格
}
for(k=0;k<=4-2*i;k++)//循环打出4-2*i个*号
{
printf("*");//打印*号
}
printf("\n");//打完一行后换行
}
return 0;//函数返回值为0
} 编译运行结果如下：
二十二：C语言实现对数组元素依次赋值0，1，2，3，4，5，6，7，8，9，然后按照逆序输出。
解题思路：显然首先要定义一个长度为10的数组，由于赋给的值是整数，因此，数组可以定义为整型，要赋值的是0~9，有一定规律，可以用循环来赋值。
源代码演示：
#include//头文件
int main()//主函数
{
int a[10];//定义整型数组，数组的大小为10
int i;//定义整型变量
printf("原来的顺序：");
for(i=0;i<10;i++)//赋值使a[0]~a[9]的值为0~9
{
a[i]=i;// 把i的值赋给数组a[i]
printf("%d ",a[i]);//输出a[i],每个数之间加个空格隔开
}
printf("\n");//换行
printf("逆序排列后：");
for(i=9;i>=0;i--)//倒序输出
{
printf("%d ",a[i]);
}
printf("\n");//换行
return 0;//函数返回值为0
} 编译运行结果如下：
原来的顺序：0 1 2 3 4 5 6 7 8 9
逆序排列后：9 8 7 6 5 4 3 2 1 0
--------------------------------
Process exited after 2.526 seconds with return value 0
请按任意键继续. . .注意：数组元素的下标是从0开始看，如果用int a[10]，定义数组，则最大下标值为9，不存在数组元素a[10]。
二十三：C语言实现从小到大对10个数进行排序，要求使用冒泡排序实现。
解题思路：排序的规律有两种：一种是“升序”，从小到大；另一种是“降序”，从大到小。
源代码演示：
#include//头文件
int main()//主函数
{
int i,j,t;//定义整型变量
int array[10];//定义数组大小
printf("请输入十个数:");//提示语句
for(i=0;i<10;i++)//手动往数组里输入10个数
{
scanf("%d,",&array[i]);//注意&符号
}
for(j=0;j<9;j++)//外层循环限制
{
for(i=0;i<9-j;i++)//内存循环
if(array[i]>array[i+1])//如果前一个数比后一个数大
{
t=array[i]; //把小的数赋值给前面，大的数赋值给后面
array[i]=array[i+1];
array[i+1]=t;
}
}
printf("按照从小到大的顺序排序:");//提示语句
for(i=0;i<10;i++)//循环输出10个数
{
printf("%d ",array[i]);
}
printf("\n");//换行
return 0;//函数返回值为0
} 编译运行结果如下：
请输入十个数:9 8 4 1 6 2 7 4 10 9
按照从小到大的顺序排序:1 2 4 4 6 7 8 9 9 10
--------------------------------
Process exited after 20.46 seconds with return value 0
请按任意键继续. . .以上就是很著名的“冒泡排序”，也称为“起泡排序”，通过此例对以后学习快速排序、堆排序等会有所启示。从大到小该如何排序呢？
二十四：C语言实现将一个二维数组行和列的元素互换，存到另一个二维数组中。
例如：
a数组的序列：
1 2 3
4 5 6
b数组的序列:
1 4
2 5
3 6解题思路：可以定义两个数组：数组a为2行3列，存放指定的6个数。数组b为3行2列，开始时未赋值，只要将a数组中的元素a[i][j]存放到b数组中的b[j][i]元素中即可。
源代码演示：
#include//头文件
int main()//主函数
{
int i,j;//定义整型变量
int a[2][3]={{1,2,3},{4,5,6}};//定义二维数组，且赋初值
int b[3][2];//定义二维数组
printf("横向数组的序列：\n");//提示语句
for(i=0;i<2;i++)//外层for循环，限制行，共2行
{
for(j=0;j<3;j++)//内层for循环，限制列，共3列
{
printf("%6d",a[i][j]);//输出数组元素值，宽度为6
b[j][i]=a[i][j];//赋值
}
printf("\n");//换行
}
printf("纵向数组的序列:\n");//提示语句
for(i=0;i<3;i++)//外层for循环，限制行，3行
{
for(j=0;j<2;j++)//内层for循环，限制列，共2列
{
printf("%6d",b[i][j]);//输出数组元素值，宽度为6
}
printf("\n");//换行
}
return 0;//函数返回值为0
}
编译运行结果如下：
横向数组的序列：
1 2 3
4 5 6
纵向数组的序列:
1 4
2 5
3 6
--------------------------------
Process exited after 0.04857 seconds with return value 0
请按任意键继续. . .二十五：C语言实现求3*4的矩阵中制最大的那个元素的值，以及其所在的行号列号。
解题思路：输出二维数组的各元素，方便核对输出的结果是否争取：
for(i=0;i<3;i++)//外层循环限制行，3行
{
for(j=0;j<4;j++)//外层循环限制列，4列
{
printf("%3d ",array[i][j]);//输出数组
}
printf("\n");//换行
}需要注意这两行代码，在row和column后都加了1，因为数组下标是从0开始的：
printf("行号是：%d\n",row+1);//行号
printf("列号是：%d\n",column+1);//列号源代码演示：
#include//头文件
int main()//主函数
{
int i,j;//定义整型变量
int row,column,max;//定义行号、列号、最大值变量
int array[3][4]={{1,2,3,4},{90,8,7,6},{-10,10,-5,2}};//定义二维数组且赋值
for(i=0;i<3;i++)//外层循环限制行，3行
{
for(j=0;j<4;j++)//外层循环限制列，4列
{
printf("%3d ",array[i][j]);//输出数组，宽度为3
}
printf("\n");//换行
}
printf("------------------\n");//分割开
max=array[0][0];//先把数组的第一个数赋值给max
for(i=0;i<3;i++)//外层循环限制行，3行
{
for(j=0;j<4;j++)//外层循环限制列，4列
if(array[i][j]>max)//将数组中的每个数与第一个进行比较
{
max=array[i][j];//把大的赋值给max
row=i;//把大的数的行号赋值给row
column=j;//把大的数的列号赋值给column
}
}
printf("max=%d\n",max);//输出最大的数
printf("行号是：%d\n",row+1);//行号
printf("列号是：%d\n",column+1);//列号
return 0;//函数返回值为0
} 编译运行结果如下：
1 2 3 4
90 8 7 6
-10 10 -5 2
------------------
max=90
行号是：2
列号是：1
--------------------------------
Process exited after 0.0816 seconds with return value 0
请按任意键继续. . .二十六：C语言实现输出杨辉三角。
解题思路：对于这道题，拆分为3部分进行讲解
第一部分，对有特点的数（每行开头和结束的数都是1）进行赋值：
for(i=0;i<10;i++)//for循环
{
array[i][i]=1;//给二维数组的每一行的最后一个赋值为1
array[i][0]=1;//第二维数组的每一行的开头赋值为1
}第二部分，给中间的数进行赋值：
for(i=2;i<10;i++)//外层循环限制行
{
for(j=1;j<=i-1;j++)//内层循环限制列
{
array[i][j]=array[i-1][j]+array[i-1][j-1];//给中间的数赋值
}
}第三部分，就是把上面赋值后的二维数组，遍历输出即可；
for(i=0;i<10;i++)//外层循环限制行
{
for(j=0;j<=i;j++)//内层循环限制列
{
printf("%6d",array[i][j]);//输出二维数组，宽度为6
}
printf("\n");//换行
}源代码演示：
#include//头文件
int main()//主函数入口
{
int i,j;//定义整型变量
int array[10][10];//定义二维数组
for(i=0;i<10;i++)//for循环
{
array[i][i]=1;//给二维数组的每一行的最后一个赋值为1
array[i][0]=1;//第二维数组的每一行的开头赋值为1
}
for(i=2;i<10;i++)//外层循环限制行
{
for(j=1;j<=i-1;j++)//内层循环限制列
{
array[i][j]=array[i-1][j]+array[i-1][j-1];//给中间的数赋值
}
}
for(i=0;i<10;i++)//外层循环限制行
{
for(j=0;j<=i;j++)//内层循环限制列
{
printf("%6d",array[i][j]);//输出二维数组，宽度为6
}
printf("\n");//换行
}
return 0;//函数返回值为0
} 编译运行结果如下：
二十七：C语言实现输出以下结果，要求用函数调用实现。
***************
I love you!
**************解题思路：在输出的文字上下分别有一行“*”号，显然不必重复写这段代码，用一个函数来实现输出一行“*”的功能
int special_Symbols()//自定义函数，功能是输出一行*符号
{
printf("*****************\n");
}第二个函数实现输出中间的I love you即可。
int text()//自定义函数，功能是输出I love you!\n
{
printf("I love you!\n");
}源代码演示：
#include//头文件
int main()//主函数
{
int special_Symbols();//声明自定义的special_Symbols方法
int text();//声明自定义的text方法
special_Symbols();//调用special_Symbols方法
text();//调用text方法
special_Symbols();//调用special_Symbols方法
return 0;//函数返回值为0
}
int special_Symbols()//自定义函数，功能是输出一行*符号
{
printf("*****************\n");
}
int text()//自定义函数，功能是输出I love you!\n
{
printf("I love you!\n");
} 编译运行结果如下：
*****************
I love you!
*****************
--------------------------------
Process exited after 1.794 seconds with return value 0
请按任意键继续. . .在自定义函数special_Symbols和text时指定函数的类型为void，意为函数无类型，即无函数值，也就是说，执行这两个函数后不会把任何值带回main函数。
二十八：输入两个整数，要求输出其中值较大者。要求用函数来找到大数。
解题思路：这个问题的逻辑很简单，主要就是把比较大小的逻辑抽取出来即可，比较大小具体可以参考之前的文章
int max_Fun(int x,int y)//自定义比大小函数
{
int temp;//定义中间变量
temp=x>y?x:y;//把大的数赋值给temp
return temp;//把temp的结果返回到函数调用处
}源代码演示：
#include//头文件
int main()//主函数
{
int max_Fun(int x,int y);//函数声明
int a,b,max;//定义整型变量
printf("请输入两个数：");//提示语句
scanf("%d,%d",&a,&b);//键盘输入两个数，注意用逗号隔开
max=max_Fun(a,b);//调用max_Fun
printf("大的数是：%d",max);//输出结果
return 0;//主函数返回值为0
}
int max_Fun(int x,int y)//自定义比大小函数
{
int temp;//定义中间变量
temp=x>y?x:y;//把大的数赋值给temp
return temp;//把temp的结果返回到函数调用处
} 编译运行结果如下：
请输入两个数：4,9
大的数是：9
--------------------------------
Process exited after 4.251 seconds with return value 0
请按任意键继续. . .注意：键盘输入两个数时，中间的逗号应该时英文状态下的，因为代码中的逗号是英文的，scanf函数键盘输入的要和代码保存一致，如果是中文的会输出以下结果。
请输入两个数：4，9
大的数是：4
--------------------------------
Process exited after 2.026 seconds with return value 0
请按任意键继续. . .二十九：有5个美女坐在一起，问第5个美女多少岁，她说比第4个美女大2岁；问第4个美女多少岁，她说比第3个美女大2岁；问第3个美女多少岁，她说比第2个美女大2岁；问第2个美女多少岁，她说比第一个大2岁。最后问第1个美女，她说10岁。请问第2、3、4、5个美女多少岁？要求用C语言编程实现。
解题思路：需要求第几个美女的年龄，age函数就一共被调用几次，最后一次是main函数调用的，其余的是在age函数中调用的。
求年龄函数：
int age(int temp)//自定义递归函数，参数temp类型是整型
{
int peple_Age;//定义变量
if(temp==1)//如果temp=1
{
peple_Age=10;//年龄是10岁
}
else
{
peple_Age=age(temp-1)+2;//年龄等于比前一个大2岁
}
return peple_Age;//将年龄返回到age函数调用处
}源代码演示：
#include//头文件
int main()//主函数
{
int age(int temp);//函数声明
int number;//定义变量
int people_Age;//定义变量
printf("输入想知道的第几个孩子："); //提示语句
scanf("%d",&number);//键盘输入想知道第几个函数
people_Age=age(number);//调用age函数
printf("第%d个学生的年龄是%d岁\n",number,people_Age);//输出年龄
return 0;//主函数返回值为0
}
int age(int temp)//自定义递归函数，参数temp类型是整型
{
int peple_Age;//定义变量
if(temp==1)//如果temp=1
{
peple_Age=10;//年龄是10岁
}
else
{
peple_Age=age(temp-1)+2;//年龄等于比前一个大2岁
}
return peple_Age;//将年龄返回到age函数调用处
} 编译运行结果如下：
输入想知道的第几个孩子：5
第5个学生的年龄是18岁
--------------------------------
Process exited after 1.828 seconds with return value 0
请按任意键继续. . .递归调用的重要性，在实际开发中用的并不多，根据小林大学期间参加ACM和蓝桥杯的经验来看竞赛中出现的更多。
例30：C语言求n！，要求用递归实现。
解题思路：本题和例29思想差不多，都是用递归来实现
求阶乘函数：
int factorial(int number)//自定义阶乘函数
{
int temp;//定义整型变量
if(number<0)//如果这个数小于0
{
printf("错误数据请，输入大于0的数！");//不符合条件，无法求
}
else if(number==0||number==1)//0或者1本身的阶乘是1
{
temp=1;
}
else
{
temp=factorial(number-1)*number;//否则求这个数与前一个数相乘的结果
}
return temp;//将temp返回到函数调用处
}源代码演示：
#include//头文件
int main()//主函数
{
int factorial(int number);//自定义阶乘函数声明
int number,temp;//定义变量
printf("输入要求阶乘的数：");//提示语句
scanf("%d",&number);//键盘输入相求的数
temp=factorial(number);//调用阶乘函数
printf("%d!=%d",number,temp) ;//输出结果
return 0;//主函数返回值为0
}
int factorial(int number)//自定义阶乘函数
{
int temp;//定义整型变量
if(number<0)//如果这个数小于0
{
printf("错误数据请，输入大于0的数！");//不符合条件，无法求
}
else if(number==0||number==1)//0或者1本身的阶乘是1
{
temp=1;
}
else
{
temp=factorial(number-1)*number;//否则求这个数与前一个数相乘的结果
}
return temp;//将temp返回到函数调用处
} 编译运行结果如下：
输入要求阶乘的数：5
5!=120
--------------------------------
Process exited after 1.553 seconds with return value 0
请按任意键继续. . .
上述代码我定义的是int类型，因为这个数不可能无限大，如果特别大，会超过int的范围，如下：
输入要求阶乘的数：100
100!=0
--------------------------------
Process exited after 1.575 seconds with return value 0
请按任意键继续. . .获取100题整理文档及更多学习资料、项目实战源码的小伙伴欢迎加入粉丝编程学习交流群哦！群里有一些资料可以帮助大家更好的学习，在学习C语言的过程中遇到任何的问题，都可以发出来一起讨论，大家都是学习C/C++的，或是转行，或是大学生，还有工作中想提升自己能力的前端党，如果你是正在学习C/C++的小伙伴可以加入学习。
点击链接加入群聊【C语言/C++交流二群】
三十一：C语言用指针方法对10个整数按由大到小顺序排序。
解题思路：在主函数中定义数组，用来存放10个整数，定义int *型指针变量p指向a[0]，定义函数sort将数组中的元素按由大到小排序。
排序函数：
void sort(int x[],int n)//自定义排序函数
{
int i,j,k,t;//定义整型变量
for(i=0;i<9;i++)//外层for循环
{
k=i;//把i的值赋给k
for(j=1+i;j<10;j++)//内层for循环
{
if(x[j]>x[k])//如果前一个数大
{
k=j;
}
}
t=x[k]; //赋值
x[k]=x[i];
x[i]=t;
}
}源代码演示：
#include//头文件
int main()//主函数
{
void sort(int x[],int n);//函数声明
int i,*p,a[10];//定义整型变量、指针变量、数组
p=a;//读者需要注意这里a赋值
printf("请输入十个数：");//提示语句
for(i=0;i<10;i++)//输入10个数
{
scanf("%d,",p++);//注意每个数之间用英文逗号隔开
}
p=a;//读者需要注意这里a赋值
sort(a,10);//调用sort排序
printf("由大到小排序后的：");//提示语句
for(p=a,i=0;i<10;i++)//输出排序后的数
{
printf("%d ",*p);
p++;
}
printf("\n");//换行
return 0;//主函数返回值为0
}
void sort(int x[],int n)//自定义排序函数
{
int i,j,k,t;//定义整型变量
for(i=0;i<9;i++)//外层for循环
{
k=i;//把i的值赋给k
for(j=1+i;j<10;j++)//内层for循环
{
if(x[j]>x[k])//如果前一个数大
{
k=j;
}
}
t=x[k]; //赋值
x[k]=x[i];
x[i]=t;
}
}
编译运行结果如下：
请输入十个数：0,4,6,1,8,12,78,34,67,4
由大到小排序后的：78 67 34 12 8 6 4 4 1 0
--------------------------------
Process exited after 22.77 seconds with return value 0
请按任意键继续. . .
在上一节说过，给指针变量赋的是地址，如下：
int i,*p,a[10];
p=a;但上述代码中却是这样赋值：
int i,*p,a[10];
p=&a;
是因为定义的a就是数组，在C语言中，数组名可以表示地址，因此不用再加取地址符&，读者需要了解。
三十二：有一个班，3个学生，各学习4门课，C语言编程实现计算总平均分数以及第n个学生的成绩，要求使用指针。
解题思路：今天这道例题分为3部分，下述求的是第3个学生，读者请思考怎么改为求第n个学生。
第一步：求平均分函数：
void average(float *p,int n)//自定义求平均成绩函数
{
float *p_end;//定义浮点类型指针变量
float sum=0,aver;//定义浮点型变量
p_end=p+n-1;//把地址赋给指针变量
for(;p<=p_end;p++)//for循环，注意第一处分号
{
sum=sum+(*p);//总和
}
aver=sum/n;//平均分
printf("平均数是:%f",aver);//输出平均分
printf("\n");//换行
}第二步：求第n个学生成绩函数
void search_Grade(float (*p)[4],int n)//自定义求第n个学生成绩函数
{
int i;//定义变量
printf("第%d个学生的成绩是:",n+1);//输出，注意此处我写的是n+1，数组下标是从0开始的
for(i=0;i<4;i++)//for循环
{
printf("%5.2f ",*(*(p+n)+i));
}
}源代码演示：
#include//头文件
int main()//主函数
{
void average(float *p,int n);//函数声明
void search_Grade(float (*p)[4],int n);//函数声明
float score[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};//定义浮点型数组
average(*score,12);//平均成绩
search_Grade(score,2);//第3个学生的成绩，这里写2是因为按照数组从0开始
return 0;//主函数返回值为0
}
void average(float *p,int n)//自定义求平均成绩函数
{
float *p_end;//定义浮点类型指针变量
float sum=0,aver;//定义浮点型变量
p_end=p+n-1;//把地址赋给指针变量
for(;p<=p_end;p++)//for循环，注意第一处分号
{
sum=sum+(*p);//总和
}
aver=sum/n;//平均分
printf("平均数是:%f",aver);//输出平均分
printf("\n");//换行
}
void search_Grade(float (*p)[4],int n)//自定义求第n个学生成绩函数
{
int i;//定义变量
printf("第%d个学生的成绩是:",n+1);//输出，注意此处我写的是n+1，数组下标是从0开始的
for(i=0;i<4;i++)//for循环
{
printf("%5.2f ",*(*(p+n)+i));
}
} 编译运行结果如下：
平均数是:6.500000
第3个学生的成绩是: 9.00 10.00 11.00 12.00
--------------------------------
Process exited after 0.07228 seconds with return value 0
请按任意键继续. . .三十三：有一个3*4的二维数组，要求用C语言实现指向元素的指针变量输出二维数组个元素的值。
解题思路：二维数组的元素时整型的，它相当于整型变量，可以用int*型指针变量指向它。二维数组的元素在内存中是按行顺序存放的，即存放完序号为0的行中的全部元素后，接着存放序号为1的行中的全部元素，依此类推。
本例是顺序输出数组中各元素之值，比较简单。如果要输出某个指定的数值元素，则应事先计算该元素在数组中的相对位置。
源代码演示：
#include//头文件
int main()//主函数
{
int array[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};//定义二维数组，且赋初值
int *p,m;//定义指针变量和普通变量
for(m=0,p=array[0];p 编译运行结果如下：
三十四：C语言实现将字符串a复制为b，然后输出b，要求使用指针。
解题思路：定义两个字符数组a和b，对a数组初始化。将a数组中的每一个字符逐个复制到b数组中，程序中a和b都定义为字符数组，通过地址访问其数组元素。
源代码演示：
#include//头文件
int main()//主函数
{
char a[]="I love you";//定义字符数组且赋初值
char b[20];//定义字符数组
int i;//定义整型变量
for(i=0;*(a+i)!='\0';i++)//for循环，!='\0'是指最后一个字符不是\0
{
*(b+i)=*(a+i);//赋值
}
*(b+i)='\0';//赋值
printf("字符串a是:%s\n",a);//输出原来的
printf("单个输出字符b："); //提升语句
for(i=0;b[i]!='\0';i++)//for循环
{
printf("%c",b[i]);//输出字符数组
}
printf("\n");//换行
return 0;//主函数返回值为0
} 编译运行结果如下：
字符串a是:I love you
单个输出字符b：I love you
--------------------------------
Process exited after 1.745 seconds with return value 0
请按任意键继续. . .
三十五：C语言编程实现改变指针变量的值。
解题思路： 指针p的值是可以变化的，printf函数输出字符串时，从指针变量p当时所指向的元素开始，逐个输出各个字符，直到遇‘\0’为止。而数组名虽然代表地址，但是它是常量，它的值是不能改变的。
源代码演示：
#include//头文件
int main()//主函数
{
char *p="I love C program language";//定义指针变量且赋值
p=p+7;//指针变量p指向字符串的第8位
printf("%s",p);//输出
return 0;//主函数返回值为0
} 编译运行结果如下：
C program language
--------------------------------
Process exited after 2.299 seconds with return value 0
请按任意键继续. . .
应该特别注意的是：
char *p="I love C program language";数组名虽然代表地址，但是它是常量，值不能改变。
p=p+7;虽然是+7，但是在C语言中，下标是从0开始的。
三十六：C语言实现输入两个整数，然后让用户选择1或者2，选择1是调用max，输出两者中的大数，选择2是调用min，输出两者中的小数。
解题思路：定义一个函数max和函数min，实现求两个整数中的大的和小的。
源代码演示：
#include//头文件
int main()//主函数
{
int max_Number(int ,int );//函数声明
int min_Number(int x,int y);//函数声明
int (*p)(int,int);//定义有参数的函数指针
int a,b,c,d;//定义整型变量
printf("请输入两个数:");//提示语句
scanf("%d,%d",&a,&b);//键盘输入两个数，注意之间用英文逗号隔开
printf("请选择1或者2：");//提示语句
scanf("%d",&c);//键盘输入
if(c==1)//如果是1
{
p=max_Number;//调用求大的函数
}
else if(c==2)//如果是2
{
p=min_Number;//调用求小的函数
}
d=(*p)(a,b);//给d赋值
if(c==1)//如果是1
{
printf("max=%d",d);//输出大的
}
else
{
printf("min=%d",d);//否则输出小的
}
return 0; //主函数返回值为0
}
int max_Number(int x,int y)//自定义求两个数中的较大数
{
return(x>y?x:y); //此处使用了三目运算符
}
int min_Number(int x,int y)//自定义求两个数中的较小数
{
return (x>y?y:x);//此处使用了三目运算符
} 编译运行结果如下：
请输入两个数:6,9
请选择1或者2：1
max=9
--------------------------------
Process exited after 7.124 seconds with return value 0
请按任意键继续. . .三十七：C语言实现把一个学生的信息（包括学号、姓名、姓名、地址）放在一个结构体变量中。然后输出这个学生的信息。
解题思路：先在程序中自己建立一个结构体类型，包括有关学生信息的各成员。然后用他来定义结构体变量，同时赋初值。
在定义结构体变量时可以对它的成员初始化。初始化列表是用花括号括起来的一些常量，这些常量依次赋给结构体变量中的各成员。
源代码演示：
#include//头文件
int main()//主函数
{
struct student_Information //定义学生结构体
{
int num; //学号
char name[20];//名字
char sex[20];//性别
char address[20]; //地址
}
student_Information={8888,"刺客567","男生","广州市"};//赋值
printf("学号是：%d\n",student_Information.num);//输出学号
printf("姓名是：%s\n",student_Information.name);//输出名字
printf("性别是：%s\n",student_Information.sex);//输出性别
printf("住址是：%s\n",student_Information.address);//输出住址
return 0;//主函数返回值为0
} 编译运行结果如下：
学号是：8888
姓名是：刺客567
性别是：男生
住址是：广州市
--------------------------------
Process exited after 2.791 seconds with return value 0
请按任意键继续. . .存储的数组是字符串，不是单个的字符，如果用%c格式控制符，则输出结果会如下：
学号是：8888
姓名是：?
性别是：?
住址是：?
--------------------------------
Process exited after 1.785 seconds with return value 0
请按任意键继续. . .
三十八：有三个候选人，每个选民只能投给一个人，要求用C语言编一个统计选票的程序，先后输入备选人的的名字，最后输出各人的得票结果。
解题思路：需要设计一个结构数组，数组中包含3个元素，每个元素中的信息应包括候选人的姓名和得票数。
源代码演示：
#include//头文件
#include//引入strcmp
struct people//定义结构体变量
{
char name[20];//定义字符数组
int number;//定义整型变量
} leader[3]={"li",0,"zhang",0,"sun",0}; /*数组的定义和引用不一样，把姓赋给数组name 把0赋给 shu*/
int main()//主函数
{
int i,j;//定义整型变量
char leader_name[20];//定义字符数组
for(i=1;i<10;i++)//for循环，循环9次
{
printf("请输入人名\n");//提示语句
scanf("%s",leader_name);//键盘输入名字
for(j=0;j<3;j++)
if(strcmp(leader_name,leader[j].name)==0)//比较两个字符串，如果名字相等
{
leader[j].number++;//票数加1
}
}
printf("结果是：\n");//提示语句
for(i=0;i<3;i++)//for循环
{
printf("%s票数：%d\n",leader[i].name,leader[i].number);//输出名字和票数
}
return 0;//主函数返回值为0
} 编译运行结果如下：
请输入人名
li
请输入人名
zhang
请输入人名
sun
请输入人名
sun
请输入人名
li
请输入人名
li
请输入人名
li
请输入人名
sun
请输入人名
sun
结果是：
li票数：4
zhang票数：1
sun票数：4
--------------------------------
Process exited after 23.01 seconds with return value 0
请按任意键继续. . .三十九：有n个学生的信息（包括学号、姓名、成绩），C语言编程实现按照成绩的高低顺序输出学生的信息。
解题思路：用结构体数组存放n个学生信息，采用选择法对各元素进行排序，在定义结构体数组时进行初始化，为清晰起见，将每个学生的信息用一对花括号包起来。
源代码演示：
#include//头文件
struct student //学生结构体
{
int num; //学号
char name[20]; //姓名
float score; //成绩
} ;
int main()//主函数
{
//定义结构体变量且赋值
struct student stu[5]={{10010,"Tom",78},{10011,"Jon",98.5},{10012,"Lisi",100},{10013,"zhangsan",99},{10014,"wangwu",10}};
struct student t;
int i,j,k;//定义整型变量
printf("成绩由大到小排序：\n");//提示语句
for(i=0;i<4;i++)//外层for循环
{
k=i;//把i的值赋给k
for(j=i+1;j<5;j++)//内层for循环
{
if(stu[j].score>stu[k].score)//挑出分数高的
{
k=j;//把相应的j赋值给k
}
}
t=stu[k]; //把成绩高的放到前面
stu[k]=stu[i];
stu[i]=t;
}
for(i=0;i<5;i++)//循环输出5个人的成绩
{
printf("%d,%10s,%6.2f分\n",stu[i].num,stu[i].name,stu[i].score);//输出结果
}
return 0;//主函数返回值为0
} 编译运行结果如下：
成绩由大到小排序：
10012, Lisi,100.00分
10013, zhangsan, 99.00分
10011, Jon, 98.50分
10010, Tom, 78.00分
10014, wangwu, 10.00分
--------------------------------
Process exited after 0.05481 seconds with return value 0
请按任意键继续. . .例40：C语言实现通过指向结构体变量的指针变量变量输出结构体变量中的信息。
解题思路：在主函数中声明了struct student类型，然后定义了一个struct student类型的变量s_1，又定义了一个指针变量p，它指向一个struct student类型的对象，将结构体变量s_1的起始地址赋给指针变量p，也就是使p指向s_1，然后对s_1的各个成员赋值。
源代码演示：
#include//头文件
#include//为了引用strcpy函数
int main(){//主函数
struct student{ //学生结构体
int num;
char name[20];
char sex;
float score;
};
struct student s_1;//定义结构体变量
struct student *p;//定义结构体指针变量
p=&s_1;//将s_1得地址赋给指针变量
s_1.num=10010;//赋值
strcpy(s_1.name,"yan");//复制
s_1.sex='M';//赋值
s_1.score=100;//赋值
printf("学号是：%d\n名字是%s\n性别是：%c\n成绩是：%f\n",
s_1.num,s_1.name,s_1.sex,s_1.score); //输出结果
printf("--------------------\n"); //隔开
printf("学号是：%d\n名字是%s\n性别是：%c\n成绩是：%f\n",
(*p).num,(*p).name,(*p).sex,(*p).score); //输出结果
return 0;//主函数返回值为0
} 编译运行结果如下：
学号是：10010
名字是yan
性别是：M
成绩是：100.000000
--------------------
学号是：10010
名字是yan
性别是：M
成绩是：100.000000
--------------------------------
Process exited after 1.116 seconds with return value 0
请按任意键继续. . .思考两个问题，怎么对结构体变量成员赋值？怎么通过指向结构体变量的指针访问结构体变量中成员？
获取100题整理文档及更多学习资料、项目实战源码的小伙伴欢迎加入粉丝编程学习交流群哦！群里有一些资料可以帮助大家更好的学习，在学习C语言的过程中遇到任何的问题，都可以发出来一起讨论，大家都是学习C/C++的，或是转行，或是大学生，还有工作中想提升自己能力的前端党，如果你是正在学习C/C++的小伙伴可以加入学习。
点击链接加入群聊【C语言/C++交流二群】