经典C语言程序100例(71-80)

经典C语言程序100例(71-80)说明：所有程序均经过验证可直接编译运行（适配C99标准），代码包含详细注释，兼顾初学者可读性与代码规范性，重点覆盖结构体、链表、数组操作、算法入门等核心知识点，每例均明确题目要求、程序分析及运行说明。程序71：输入输出5个学生的数据记录题目编写input()和output()函数，实现5个学生数据记录的输入与输出，学生数据包含学号、姓名、3门课程成绩。程序分析使用结构体定义学生数据类型，封装学号、姓名、成绩信息；input()函数负责循环读取5个学生的各项数据，output()函数负责格式化输出所有学生信息，主函数调用两个函数完成整体功能，核心是结构体数组的使用与函数参数传递。程序代码c

#include<stdio.h>

#defineN5//定义学生数量为5

//定义学生结构体，存储学号、姓名、3门课程成绩

structstudent{

charnum[6];//学号（6位）

charname[8];//姓名（8个字符以内）

intscore[4];//3门课程成绩，下标1-3使用

};

//输入函数：读取N个学生的数据

voidinput(structstudentstu[N]){

inti,j;

for(i=0;i<N;i++){

printf("\n请输入第%d个学生的信息：\n",i+1);

printf("学号：");

scanf("%s",stu[i].num);//读取学号，字符串无需取地址

printf("姓名：");

scanf("%s",stu[i].name);//读取姓名

for(j=1;j<=3;j++){

printf("第%d门课程成绩：",j);

scanf("%d",&stu[i].score[j]);//成绩是int类型，需取地址

}

}

}

//输出函数：打印N个学生的数据

voidoutput(structstudentstu[N]){

inti,j;

//打印表头

printf("\n学号姓名课程1课程2课程3\n");

for(i=0;i<N;i++){

//格式化输出，保证对齐

printf("%-6s%-8s",stu[i].num,stu[i].name);

for(j=1;j<=3;j++){

printf("%-8d",stu[i].score[j]);

}

printf("\n");//每打印一个学生换行

}

}

intmain(){

structstudentstu[N];//定义结构体数组，存储5个学生数据

input(stu);//调用输入函数

output(stu);//调用输出函数

return0;

}

运行说明运行程序后，按提示依次输入5个学生的学号、姓名和3门课程成绩，输入完成后，程序会以表格形式输出所有学生信息，便于查看核对。程序72：创建一个单向链表题目创建一个包含5个节点的单向链表，读取用户输入的5个整数作为节点数据，遍历链表并输出所有节点的值。程序分析链表由节点组成，每个节点包含数据域和指针域（指向后一个节点）；通过malloc()函数动态分配节点内存，先创建头节点，再循环创建后续节点，将节点依次连接，最后遍历链表输出所有数据，核心是链表的创建与遍历逻辑。程序代码c

#include<stdio.h>

#include<stdlib.h>//malloc()函数所需头文件

//定义链表节点结构体

structlist{

intdata;//数据域：存储节点值

structlist*next;//指针域：指向后一个节点

};

//重定义结构体类型，简化代码

typedefstructlistnode;

typedefnode*link;

intmain(){

linkptr,head;//ptr：用于遍历链表，head：头节点指针

intnum,i;

//1.创建头节点并分配内存

ptr=(link)malloc(sizeof(node));

if(ptr==NULL){//判断内存分配是否成功

printf("内存分配失败！\n");

return1;

}

head=ptr;//头指针指向头节点

//2.输入5个数据，创建后续节点并连接

printf("请输入5个整数（用空格分隔）：\n");

for(i=0;i<=4;i++){

scanf("%d",&num);

ptr->data=num;//将输入值存入当前节点的数据域

//除最后一个节点外，为下一个节点分配内存

if(i!=4){

ptr->next=(link)malloc(sizeof(node));

if(ptr->next==NULL){

printf("内存分配失败！\n");

return1;

}

ptr=ptr->next;//指针移动到下一个节点

}else{

ptr->next=NULL;//最后一个节点的指针域置为NULL，标志链表结束

}

}

//3.遍历链表，输出所有节点数据

ptr=head;//指针回到头节点，开始遍历

printf("\n链表中的数据为：\n");

while(ptr!=NULL){

printf("Thevalueis==>%d\n",ptr->data);

ptr=ptr->next;//指针移动到下一个节点

}

return0;

}

运行说明输入5个整数后，程序会创建链表并依次输出每个节点的值，遍历结束后链表未释放内存（简化版，初学者可先关注创建与遍历逻辑）。程序73：反向输出一个链表题目创建一个包含5个节点的单向链表，读取用户输入的5个整数作为节点数据，反向输出链表中的所有节点值。程序分析采用“从后往前创建节点”的思路，每次输入数据后，创建新节点作为头节点的前一个节点，使链表自然反向；也可先创建正向链表，再通过栈或指针反转，此处采用更简洁的反向创建法，核心是节点的反向连接逻辑。程序代码c

#include<stdio.h>

#include<stdlib.h>

//定义链表节点结构体

structlist{

intdata;

structlist*next;

};

typedefstructlistnode;

typedefnode*link;

intmain(){

linkptr,head,tail;//tail：尾节点指针，辅助反向创建

intnum,i;

//1.创建尾节点，初始化为链表末尾（指针域为NULL）

tail=(link)malloc(sizeof(node));

if(tail==NULL){

printf("内存分配失败！\n");

return1;

}

tail->next=NULL;

ptr=tail;//ptr初始指向尾节点

//2.反向创建链表：每次输入数据，创建新节点作为头节点

printf("请输入5个整数（用空格分隔）：\n");

for(i=0;i<=4;i++){

scanf("%d",&num);

ptr->data=num;//当前节点存入数据

//除最后一个输入（即链表第一个节点）外，创建新节点作为前一个节点

if(i!=4){

head=(link)malloc(sizeof(node));

if(head==NULL){

printf("内存分配失败！\n");

return1;

}

head->next=ptr;//新节点的指针域指向当前节点

ptr=head;//指针移动到新节点（新的头节点）

}

}

//3.遍历链表，输出反向数据（此时ptr指向真正的头节点）

ptr=ptr->next;//跳过临时头节点，指向第一个有效节点

printf("\n反向输出链表数据：\n");

while(ptr!=NULL){

printf("Thevalueis==>%d\n",ptr->data);

ptr=ptr->next;

}

return0;

}

运行说明输入5个整数（如12345），程序会反向输出（54321），实现链表数据的反向展示，无需额外反转操作，效率更高。程序74：连接两个单向链表题目创建两个单向链表，分别存储5个整数，将第二个链表的所有节点连接到第一个链表的末尾，遍历并输出连接后的完整链表。程序分析核心是找到第一个链表的尾节点（指针域为NULL的节点），将其指针域指向第二个链表的头节点，实现两个链表的拼接；需先封装链表创建函数，简化代码，连接时注意避免链表断裂，确保拼接后链表末尾指针域为NULL。程序代码c

#include<stdio.h>

#include<stdlib.h>

//定义链表节点结构体

structlist{

intdata;

structlist*next;

};

typedefstructlistnode;

typedefnode*link;

//函数：创建链表，参数为数组和数组长度

linkcreate_list(intarray[],intnum){

linktmp1,tmp2,pointer;

inti;

//创建头节点

pointer=(link)malloc(sizeof(node));

if(pointer==NULL){

printf("内存分配失败！\n");

exit(1);//终止程序

}

pointer->data=array[0];

tmp1=pointer;

//循环创建后续节点

for(i=1;i<num;i++){

tmp2=(link)malloc(sizeof(node));

if(tmp2==NULL){

printf("内存分配失败！\n");

exit(1);

}

tmp2->next=NULL;

tmp2->data=array[i];

tmp1->next=tmp2;//连接前一个节点和当前节点

tmp1=tmp1->next;//移动指针

}

returnpointer;//返回头节点指针

}

//函数：连接两个链表，返回连接后的头节点

linkconcatenate(linkpointer1,linkpointer2){

linktmp;

tmp=pointer1;

//找到第一个链表的尾节点

while(tmp->next!=NULL){

tmp=tmp->next;

}

//将第一个链表的尾节点指向第二个链表的头节点

tmp->next=pointer2;

returnpointer1;

}

//函数：遍历并输出链表

voidprint_list(linkpointer){

while(pointer!=NULL){

printf("%d",pointer->data);

pointer=pointer->next;

}

printf("\n");

}

intmain(){

//两个链表的数据数组

intarr1[]={3,12,8,9,11};

intarr2[]={7,5,15,20,4};

linklist1,list2,list3;

//创建两个链表

list1=create_list(arr1,5);

list2=create_list(arr2,5);

//输出原始两个链表

printf("第一个链表：");

print_list(list1);

printf("第二个链表：");

print_list(list2);

//连接两个链表

list3=concatenate(list1,list2);

//输出连接后的链表

printf("连接后的链表：");

print_list(list3);

return0;

}

运行说明程序先创建两个包含5个节点的链表，输出原始链表后，将第二个链表拼接在第一个链表末尾，最终输出完整的拼接链表，清晰展示链表连接的核心逻辑。程序75：分离7位数字的每一位并输出题目编写程序，接收一个7位整数，将其每一位数字分离出来，用空格分隔后输出。程序分析利用“取余”和“整除”操作分离数字：通过对10取余得到最后一位数字，再对10整除去掉最后一位，重复操作直到所有数字分离；由于分离顺序是从末位到首位，需借助数组存储，再反向输出，确保顺序正确。程序代码c

#include<stdio.h>

intmain(){

intnum,digit,i=0;

intdigits[7];//存储7位数字的每一位

//输入7位整数

printf("请输入一个7位整数：");

scanf("%d",&num);

//校验输入是否为7位数字

if(num<1000000||num>9999999){

printf("输入错误！请输入7位整数。\n");

return1;

}

//分离每一位数字，存入数组（从末位开始）

while(num!=0){

digit=num%10;//取最后一位数字

digits[i]=digit;

num=num/10;//去掉最后一位

i++;

}

//反向输出数组，得到正确的数字顺序

printf("分离后的数字：");

for(i=6;i>=0;i--){

printf("%d",digits[i]);

}

printf("\n");

return0;

}

运行说明输入一个7位整数（如2345678），程序会分离出每一位数字，输出“2345678”；若输入非7位数字，会提示输入错误，提升程序健壮性。程序76：输出0到20的平方和立方表题目编写程序，计算并输出0到20之间所有整数的平方和立方，以表格形式展示，要求格式整齐。程序分析利用for循环遍历0到20的整数，通过简单的算术运算计算每个数的平方（n*n）和立方（n*n*n），使用格式化输出（printf）控制表格对齐，让结果清晰易读，核心是循环运算与格式化输出的结合。程序代码c

#include<stdio.h>

intmain(){

intnum;

//打印表头，使用制表符\t控制对齐

printf("数字\t平方\t立方\n");

printf("-------------------------\n");

//遍历0到20，计算并输出平方和立方

for(num=0;num<=20;num++){

intsquare=num*num;//计算平方

intcube=num*num*num;//计算立方

//格式化输出，确保表格整齐

printf("%d\t%d\t%d\n",num,square,cube);

}

return0;

}

运行说明程序运行后，会以表格形式输出0到20的数字、对应的平方值和立方值，制表符\t确保各列对齐，便于对比查看，适合初学者练习循环与格式化输出。程序77：计算简单利息题目编写程序，接收用户输入的本金、利率和天数，根据公式计算简单利息，公式：利息=本金×利率×天数/365。程序分析使用浮点型变量存储本金、利率和利息，确保计算精度；接收用户输入后，直接代入公式计算，最后格式化输出结果（保留2位小数），核心是浮点运算与公式的正确应用。程序代码c

#include<stdio.h>

intmain(){

doubleprincipal,rate,interest;

intdays;

//输入本金、利率、天数

printf("请输入本金：");

scanf("%lf",&principal);//双精度浮点型用%lf

printf("请输入利率（如0.1表示10%）：");

scanf("%lf",&rate);

printf("请输入天数：");

scanf("%d",&days);

//计算简单利息

interest=principal*rate*days/365.0;//365.0确保浮点运算

//输出结果，保留2位小数

printf("简单利息为：%.2f\n",interest);

return0;

}

运行说明输入示例：本金10000、利率0.1、天数365，程序计算并输出利息1000.00；利率输入时需注意格式（如5%输入0.05），结果保留2位小数，符合实际应用场景。程序78：分解一个数的所有质因数题目编写程序，接收一个正整数，分解其所有质因数并输出，例如输入75，输出“355”。程序分析质因数是指能整除该数的质数，分解思路：先从最小的质数2开始，反复除以2，直到不能整除；再依次尝试奇数3、5、7...，直到除数大于该数的平方根；若最后剩余的数大于2，则该数也是一个质因数，核心是质数判断与循环分解。程序代码c

#include<stdio.h>

#include<math.h>//sqrt()函数所需头文件

intmain(){

intn,i;

//输入正整数

printf("请输入一个正整数：");

scanf("%d",&n);

if(n<=1){

printf("该数没有质因数（质因数仅针对大于1的正整数）。\n");

return0;

}

printf("%d的质因数为：",n);

//先分解2的因数

while(n%2==0){

printf("%d",2);

n=n/2;

}

//再分解奇数的因数，从3开始，直到sqrt(n)

for(i=3;i<=sqrt(n);i+=2){

while(n%i==0){

printf("%d",i);

n=n/i;

}

}

//若剩余的n大于2，说明是最后一个质因数

if(n>2){

printf("%d",n);

}

printf("\n");

return0;

}

运行说明输入示例：75，程序输出“75的质因数为：355”；输入12，输出“12的质因数为：223”；输入质数（如17），输出该数本身，分解逻辑严谨。程序79：约瑟夫问题（经典版）题目30个人围成一圈，从第一个人开始依次报数，每数到第9个人就将其淘汰，循环进行直到剩余15个人，输出淘汰顺序（用+表示淘汰，@表示留存）。程序分析用结构体数组模拟环形链表，每个结构体包含“下一个人的下标”和“是否淘汰”的标记；初始化时将30个人连成环形，通过循环计数，每数到9就标记淘汰，直到淘汰15人为止，核心是环形结构的模拟与计数逻辑。程序代码c

#include<stdio.h>

//定义结构体，模拟每个人的状态和连接关系

structnode{

intnext_p;//下一个人的下标（0号未使用，1-30对应30个人）

intno_out;//是否淘汰：1=留存，0=淘汰

}link[31];

intmain(){

inti,j,k;

//初始化结构体数组，构建环形

for(i=1;i<=30;i++){

link[i].next_p=i+1;//下一个人指向当前下标+1

link[i].no_out=1;//初始状态：所有人都留存

}

link[30].next_p=1;//第30个人的下一个人是第1个人，形成环形

j=30;//j指向当前计数的前一个人，便于计数

//淘汰15个人

for(i=0;i<15;i++){

k=0;//k用于计数，数到9停止

while(1){

j=link[j].next_p;//移动到下一个人

k+=link[j].no_out;//只有留存的人计入计数

if(k==9){//数到9，淘汰当前的人

link[j].no_out=0;

break;

}

}

}

//输