一、教学对象计算机科学与技术系新生 ( 第二学期）二、教学目标...

C 语言程序设计

一、教学对象计算机科学与技术系新生 (第二学期）二、教学目标程序设计的重要性程序设计的基本概念与基本方法编程解题的思路与典型方法数学模型简介算法及算法步骤程序结构与相应语句编码与上机调试

绪论绪论


三、教学重点三、教学重点 1. 1. 程序设计的基本概念，基本方法；程序设计的基本概念，基本方法； 2.2. 在在 CC 语言的环境下，学会如何针对问题进行分析，语言的环境下，学会如何针对问题进行分析，得出数学模型，理出算法并编程实现；得出数学模型，理出算法并编程实现； 3.3. 有条有理有根有据的编程实践；有条有理有根有据的编程实践； 4.4. 养成良好的编程风格与习惯；养成良好的编程风格与习惯； 5.5. 重在思维方法的学习，鼓励创新。重在思维方法的学习，鼓励创新。

绪论绪论


四、指导思想1. 立足改革，以培养高素质有创造精神的人才为这门课的教学目标。2. 以学生为中心，采用与现实生活贴切和具有趣味性的实例进行讲解，有利于调动学生学习的积极性，引导学生主动学习。 3. 强化实践，这门课主张程序设计是高强度的脑力劳动，不是听会的、也不是看会的，而是练会的。引导学生在解题编程的实践中探索其中带规律性的认识。将感性认识升华到理性高度。

绪论绪论


五、学习方法 1. 动手动脑，理论指导下的实践有条有理的实践。 2. 在编写大量程序之后，才能感到运用自如。

绪论绪论


六、教学内容安排 1. 简单 C程序设计； 2. 分支结构程序设计； 3. 循环结构程序设计； 4. 数组； 5. 函数； 6. 递归及其实现方法 7. 指针； 8. 结构体与链表。

绪论绪论


1.1 认识 C语言程序 1. 程序实例#include <stdio.h> // 预编译命令 ,将标准输入输出函数 // 作为头文件包扩到用户源文件中 #include <math.h> // 预编译命令 ,将系统提供的数学函数 // 作为头文件包扩到用户源文件中 main( ) // 主函数，名为 main ， { // 函数体 .开始 float a,b,c; // 声明部分 .定义变量类型 b=30.0; // 执行部分 .赋值语句 a=sin(b*3.14159/180); // 执行部分 .赋值语句 printf(“%f\n”,a); // 执行部分 .输出语句 } // 函数体 .结束

第一讲简单的 C程序设计


1.2 实例总结 1.C 程序结构预编译命令主函数 main( ) { 函数体开始声明部分执行部分 } 函数体结束



2. 变量的类型整型： int 长整型： long 浮点型： float 双精度型： double 字符型： char 用户自定义类型



3. 声明的作用为变量分配内存单元，变量名作为内存单元的符号地址，这件事是在程序编译链接时完成的。 4. 变量其值可以改变的量，是内存单元的符号地址。通过符号 b可以找到相应的存储单元地址，假设为 1000 。语句 b=30.0 ；是将值 30.0存放在地址为 1000 的存储单元。



5. 对变量的赋值赋值符号“ =” < 变量 >＝ < 表达式 > b = 30.0; // 读作将表达式的值 30.0 赋给变量 b

a=sin(b*3.14159/180); // 读作将表达式（正弦函数）的值赋给变量 a



6. 变量赋值特点（ 1）先定义，后使用 int d,e,f; 定义三个变量为整数类型如未定义，则在编译时被查出，认为非法（ 2）变量未被赋值前，值为未知（ 3）对变量赋值过程是“覆盖”过程，用新值去替换旧（ 4）读出变量的值，该变量保持不变（ 5）参与表达式运算的所有变量都保持原来的值不变



变量赋值过程 d e f未赋值前执行 d=7执行 e=d 执行 f=d+e执行 d=d+1 000

-123497 234316 0

7 234316 0

7 7 0

7 7 14

8 7 14



7. 输出语句 printf 函数（格式输出函数）一般形式为 printf(参数 1，参数 2，参数 3，……，参数 n）其中参数 1——格式控制参数 2，参数 3，……，参数 n——输出表列举例： float a; int b; a = 85.56; b = 100; printf("%f %d", a, b);



格式控制是用双引号括起来的字符串，称“转换控制字符串”%f —— 第一个输出表列的格式说明，以小数形式输出单、双精度实数，隐含输出 6位小数 %d —— 第二个输出表列的格式说明，以带有符号的十进制形式输出整数（正数不输出符号）显然， %f 是控制实数 a 的； %d 是控制整数 b 的



为了醒目，格式控制项中除格式说明之外可以有• 普通字符例 : printf(“a=%f b=%d", a, b); 输出结果为： a=85.560000 b=100• 换行符号例 : printf(“a=%f\nb=%d”,a,b);输出结果为： a=85.560000 b=100• 域宽和精度例： printf（” %5.3f”， a）；



8. 数学函数 sin(x) x为弧度， double x， double sin(x) cos(x) cos(x)exp(x) ex

log(x) logexlog10(x) log10xfabs(x) xfmod(x,y) 整除 x/y 的余数floor(x) 求不大于 x 的最大整数pow(x, y) xy

sqrt(x) x1/2



9. 算术运算符＋加－减 * 乘 / 除 % 模（取余数）



1.3 作业第一讲简单的 C程序设计


我们在日常生活中经常需要处理具有两个分支的问题，例如，如果明天下雨，则在教室内组织活动，否则去野游。在 C语言中，这类问题需要使用 if语句解决，而判断操作通常使用关系运算符。关系运算符和关系表达式 > 大于 < 小于 >= 大于等于 <= 小于等于 == 等于 != 不等于

第二讲分支结构


2.1 掌握 if 语句的使用方法【实例】编写程序，判断输入的整数是否为 6，若是，显示“ Right！”和“ Great!”，否则显示“ Wrong ！”和“ Sorry ！”。 1 ．编程思路：要显示“ Right！”和“ Great！”，应执行两条语句“ printf(”Right！ \n“);”和“ printf(”Great！ \n“);”，要显示“ Wrong ！”和“ Sorry ！”，执行两条语句“ printf(”Wrong ！ \n“);”和“ printf(”Sorry ！ \n“);”。本题需要根据所输入的值（假设赋给 a）是否为 6来选择执行相应的两条语句。在 C语言中判断 a 中的值是否为 6，使用“ if(a==6)”形式。



本实例的流程图如图所示开始输入 a 值

a==6

显示 “ Right ！”显示 “ Great ！”

显示“ Wrong ！”显示 “ Sorry ！”

结束

假真



本实例的 N-S 流程图如图所示输入 a的值

a==6显示“ Right ！” 显示“ Great ！”

显示“ Wrong ！” 显示“ Sorry ！ ”



2．程序代码：#include <stdio.h>main(){ int a=0; printf("Input a:"); scanf("%d",&a); printf("a=%d\n",a); if(a==6) /* if 语句开始 */ {printf("Right ！ \n"); printf("Great ！ \n"); }

else {printf("Wrong ！ \n"); printf("Sorry ！ \n");} /* if 语句结束 */}



3．运行结果：第 1次运行结果： Input a:6<回车 > a=6 Right！ Great！第 2次运行结果： Input a:5<回车 > a=5 Wrong ！ Sorry ！



4．归纳分析：（ 1）程序中的“ a==6”是关系表达式。用关系运算符把两个 C 语言表达式连接起来的表达式称为关系表达式。关系运算的判断结果只有“真”或“假”两种可能，关系成立时为“真”，不成立时为“假”。关系表达式的值只能是 1 或 0 ，当关系运算的判断结果为“真”时，关系表达式的值为 1 ，否则，关系表达式的值为 0 。例如，当 a 的值为 6时，关系表达式“ a==6” 的值为 1，当 a 的值为 5时，关系表达式“ a==6”的值为 0。



（ 2）程序中的“ if(a==6)”是 if 语句的开始部分。本例题需要根据“ a==6”是否为“真”来选择执行不同的两个输出语句。处理两个分支的问题时常使用 if 语句。 if 语句根据其后面括号中表达式的结果，选择执行某个分支程序段。 if 语句的一般形式如下： if( 表达式 ) { 语句组 1 } else { 语句组 2 } “if”和“ else”是关键字。当表达式结果为“真”（即不等于 0）时，执行语句组 1，表达式结果为“假”（即等于 0）时，执行语句组 2。在语句组 1和语句组 2中只能选择执行一组，而后执行整个 if 语句后面的语句。



（ 3） C 语言中允许程序中的 if 语句不带 else 部分。省略 else 的 if 语句一般形式如下： if( 表达式 ) { 语句组 } 此 if 语句的执行过程：当表达式结果为“真”时，执行语句组，表达式结果为“假”时，不处理。



2.2学会使用逻辑运算符处理问题时经常需要同时判断多个条件。例如，在某学生数学和英语成绩中判断是否至少有一门课程是不及格。这时使用逻辑运算符。逻辑运算符共有三种： && 逻辑与 || 逻辑或 ! 逻辑非这 3个运算符按高到低的优先级顺序是“ !”、“ &&”、“ ||” 一般而言，单目运算符优先级较高，赋值运算符优先级低。算术运算符优先级较高，关系和逻辑运算符优先级较低。



【实例】编写程序，判断某人的体重是否在 50公斤至 55公斤之间，若在此范围之内，显示“ Ok”，否则显示“ No”。1．编程思路：先将体重存放在变量 w中，要使 w的值在 50至 55 范围内，应同时满足“ w>=50”和“ w<=55”。在 C语言中用“ w>=50 && w<=55”表示 w的值是否同时满足“ w>=50”和“ w<=55”。输入体重 w的值

w >=50 && w<=55

显示“ Ok” 显示“ No”



2．程序代码： #include <stdio.h>main(){ float w=0.0; printf("Input w:"); scanf("%f",&w); printf("w=%.1f\n",w); if(w>=50&&w<=55) printf("Ok\n"); else printf("No\n");}



3. 运行结果：第 1次运行结果：Input w:53.5<回车 >w=53.5Ok第 2次运行结果：Input w:60.7<回车 >w=60.7No



4．归纳分析：程序中的“ w>=50 && w<=55”是逻辑表达式。用逻辑运算符把两个 C 语言表达式连接起来的表达式称为逻辑表达式。逻辑运算的判断结果也只有“真”或“假”两种可能，逻辑运算的规则如下：逻辑与： 1&&1=1, 其它为 0逻辑或： 0||0=0 ，其它为 1逻辑非：！ 0为 1，！ 1为 0，！ 2为 0，！ a为 0（当 a不为 0时）逻辑表达式的值也只能是 1 或 0 ，当逻辑运算的判断结果为“真”时，逻辑表达式的值为 1 ，否则，逻辑表达式的值为 0。



2.3 学会使用嵌套的 if语句有些问题必须在满足某种条件后，再继续分支处理。例如，某单位男职工 60岁退休，女职工 55岁退休，为了判断某职工是否应退休，首先要判断该职工是男职工还是女职工，然后再根据职工性别判断年龄是否到规定年龄。这时需要使用嵌套的 if语句。



【实例】编写程序，判断若输入的体重大于 0且小于 200 ，再判断该体重是否在 50公斤至 55公斤之间，若在此范围之内，显示“ Ok”，否则显示“ No”；若所输入的体重不大于 0 或不小于 200 ，则显示“ Data over!”。

1．编程思路：在上实例中，输入 w 的值后立刻用 if 语句实现选择执行“ printf(“Ok\n");” 或“ printf("No\n");” 的功能，但由于本题目是在 w 的值大于 0且小于 200 的情况下，才能执行此 if 语句，所以在此 if 语句外面还需要套另一个 if语句。



本实例的程序流程图：

课堂作业：请根据此图画出其 N-S 流程图。

开始输入 w 值

w>0 且w<200

显示“ Ok”显示 “ Data over！”

结束

假真

w≥50 且w≤55

真假显示“ No”



2．程序代码：main(){ float w=0.0; printf("Input w:"); scanf("%f",&w); printf("w=%.1f\n",w); if(w>0 && w<200) /* 外嵌 if语句开始 */if(w>=50 w<=55) /* 内嵌 if语句开始 */printf(“Ok\n");elseprintf("No\n");/* 内嵌 if语句结束 */ elseprintf("Data over!\n");/* 外嵌 if语句结束 */}



3．运行结果：第 1次运行结果：Input w:53.5<回车 >w=53.5Ok第 2次运行结果：Input w:60.7<回车 >w=60.7No第 3次运行结果：Input w:201.7<回车 >w=201.7Data over!



4．归纳分析：（ 1）本程序在一个 if语句中包含了另一个 if语句。在 if 语句的语句组 1 或语句组 2 中又包含另一个分支结构的 if语句称为嵌套的 if语句。（ 2）本程序中出现了两次 else 。 C 语法规定，在 if语句中，若多次出现 else ，则每一个 else总是与前面最近的 if配对，所以本例题中第一个 else 与内嵌的 if配对，第二个 else 与最上面的 if配对。程序中由于采用了缩进格式， if与 else 的配对关系一目了然。



2.4 学会使用 if-else if形式的嵌套 if语句【实例】编写程序，求下面分段函数的值，要求 x的值从键盘输入。

x+2 (0≤x<5)y=

0 (x<0)

x2-3 (5≤x<10)

10 (x≥10)



1．编程思路：开始输入 x 值

x<0

结束

假真真假

显示 x 和 y 的值

x<5

真假x<10y=x+2

y=10y=x2-3

y=0



2．程序代码：#include <stdio.h>main(){ float x=0,y=0;printf("Input x:"); scanf("%f",&x); if(x<0) y=0; else if(x<5) y=x+2; else if(x<10) y=x*x-3; else y=10; printf("x=%f,y=%f\n",x,y);}



2.5 switch 语句在日常生活中经常遇到菜单选择操作，例如，用 ATM自动取款机取钱时，从菜单中可以选择语种、取款额；用自动服务系统给手机充值时，可以选择查余额还是充值，对本机充值还是对其他号码充值等。这些问题一般使用switch语句解决。

总之，这些问题都是多分支情况。



【实例】编写程序，在如下菜单中选择一个运算类型，并进行相应的运算。如选择了加法，则进行求和运算。Please choose + : addition- : subtraction* : multiplication/ : division



1．程序代码：#include <stdio.h>main(){float a=5.0,b=2.0,c=0.0;char sym='\0';printf("Please choose\n");printf("+ : addition\n");printf("- : subtraction\n");printf("* : multiplication\n");printf("/ : division\n");sym=getchar();printf("%f%c%f=",a,sym,b); /* 显示算式 */



switch(sym) /* 计算算式 */ {case '+': c=a+b; break; case '-': c=a-b; break; case '*': c=a*b; break; case '/': c=a/b; break; } printf("%f\n",c); /* 显示结果 */}



2．运行结果：Please choose+ : addition- : subtraction* : multiplication/ : division/<回车 > 5.000000/2.000000=2.500000



3．归纳分析：switch 语句的一般形式为：switch( 表达式 ){ case 表达式 1: 语句组 1 break; case 表达式 2: 语句组 2 break;… … case 表达式 n: 语句组 n break; default: 语句组 n+1 break;}其中 switch 、 case 、 default 和 break是关键字，所有表达式均为整型或字符型。在表达式 1 、表达式 2 、…、表达式 n 中只能出现常量和运算符，而且每个表达式的值不能相等。



2.6 条件运算符及其表达式 C 语言中条件运算符由“ ?”和“ :” 组成，例如“ a>b ? a : b”。条件表达式的一般形式为：表达式 1 ？表达式 2 ：表达式 3当表达式 1 的值为非 0时，以表达式 2 的值作为条件表达式的值，否则，以表达式 3 的值作为条件表达式的值。例如，当 a>b 成立时，条件表达式“ a>b ? a : b” 的值为 a 中的值，否则为 b中的值。使用条件表达式也可以实现分支结构。



课堂讨论：谁做的好事？忻州师院有四位同学中的一位做了好事，不留名，表扬信来了之后，校长问这四位是谁做的好事。 A说：不是我。 B说：是 C 。 C说：是 D 。 D说： C胡说。已知三个人说的是真话，一个人说的是假话。现在要根据这些信息，找出做了好事的人。画出 N-S流程图并写出程序。



11 、编程思路：、编程思路：如何找到该人，一定是“先假设该人是做好事者，然后如何找到该人，一定是“先假设该人是做好事者，然后到每句话中去测试看有几句是真话”。“有三句是真话就确到每句话中去测试看有几句是真话”。“有三句是真话就确定是该人，否则换下一人再试”。定是该人，否则换下一人再试”。比如，先假定是比如，先假定是 AA 同学，让同学，让 thisman='A';thisman='A'; 代入到四句话中代入到四句话中 AA 说：说： thisman!=‘A’;thisman!=‘A’; ‘A’!=‘A’‘A’!=‘A’假，值为假，值为 00 。。 BB 说：说： thisman==‘C’;thisman==‘C’; ‘A’==‘C’‘A’==‘C’假，值为假，值为 00 。。 CC说：说： thisman==‘D’;thisman==‘D’; ‘A’==‘D’‘A’==‘D’假，值为假，值为 00 。。 DD 说：说： thisman!=‘D’;thisman!=‘D’; ‘A’!=‘D’‘A’!=‘D’真，值为真，值为 11 。。显然，不是 'A' 做的好事（四个关系表达式值的和为 1）



再试再试 BB 同学，让同学，让 thisman=‘B’;thisman=‘B’; 代入到四句话中代入到四句话中AA 说：说： thisman!=‘A’;thisman!=‘A’; ‘B’!=‘A’‘B’!=‘A’ 真，值为真，值为11 。。 BB 说：说： thisman==‘C’;thisman==‘C’; ‘B’==‘C’‘B’==‘C’ 假，值为假，值为00 。。CC说：说： thisman==‘D’;thisman==‘D’; ‘B’==‘D’‘B’==‘D’ 假，值为假，值为00 。。DD 说：说： thisman!=‘D’;thisman!=‘D’; ‘B’!=‘D’‘B’!=‘D’ 真，值为真，值为11 。。显然，不是 'B' 所为（四个关系表达式值的和为 2）



再试再试 CC同学，让同学，让 thisman=‘C’;thisman=‘C’; 代入到四句话中代入到四句话中AA 说：说： thisman!=‘A’;thisman!=‘A’; ‘C’!=‘A’‘C’!=‘A’ 真，值为真，值为 11 。。 BB 说：说： thisman==‘C’;thisman==‘C’; ‘C’==‘C’‘C’==‘C’ 真，值为真，值为 11 。。 CC说：说： thisman==‘D’;thisman==‘D’; ‘C’==‘D’‘C’==‘D’ 假，值为假，值为 00 。。 DD 说：说： thisman!=‘D’; ‘C’!=‘D’thisman!=‘D’; ‘C’!=‘D’ 真，值为真，值为 11 。。显然，就是‘ C’做了好事（四个关系表达式值之和为 3）这时，我可以理出头绪，要用所谓枚举法，一个人一个人地去试，四句话中有三句为真，该人即所求。



循环结构是程序中一种很重要的结构。其特点是，在给定条件成立时，反复执行某程序段，直到条件不成立为止。给定的条件称为循环条件，反复执行的程序段称为循环体。Ｃ语言提供了三种循环语句，可以组成各种不同形式的循环结构 ,它们是 : ｗｈｉｌｅ语句ｄｏ－ｗｈｉｌｅ语句ｆｏｒ语句

第三讲循环结构


3.1 简单循环【实例】古典问题：有一对兔子，从出生后第 3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？1. 程序分析：兔子的规律为数列 1,1,2,3,5,8,13,21....该数列的规律为 a1=1 a2=1 an=an-1+an-2 这里求前 20项



i<=20

a1=1;a2=1; i=3

an=a1+a2

输出 an

i=i+1;a1=a2;a2=an;

Y

end

begin

N



该题目的 N-S 流程图a1=1;a2=1;an=0;

i<=20an=a1+a2输出 ani=i+1a1=a2

a2=an



2. 程序源代码：方法一： for循环语句#include "stdio.h"main( ){ long a1,a2,an; int i; a1=a2=1; for(i=3;i<=20;i++) { an=a1+a2; printf(“a%d=%ld”,i,an); a1=a2; a2=an; } }

可否调换？



方法二： while循环语句#include "stdio.h"main( ){ long a1,a2,an; int i; a1=a2=1;i=3 ； while（ i<=20） { an=a1+a2; printf(“a%d=%ld”,i,an); a1=a2; a2=an; i++; } }



方法三： do-while循环语句#include "stdio.h"main( ){ long a1,a2,an; int i; a1=a2=1;i=3 ； do { an=a1+a2; printf(“a%d=%ld”,i,an); a1=a2; a2=an; i++; }while（ i<=20); }



3. 归纳分析（ 1） for 语句格式： for ( 表达式 1 ; 表达式 2 ; 表达式 3 ) { 语句 } 即： for ( 循环变量赋初值 , 循环结束条件 , 循环变量增值 ) { 语句 }



For 语句执行过程表达式 1

表达式 2

表达式 3

语句 Y

N



表达式可以省略，但分号不能省略a) 省略表达式 1 i=1 for ( ； i<=50 ； i++ ) sum=sum+2*ib) 省略表达式 2——产生死循环 for ( i=1 ；； i++ ) sum=sum+2*ic) 省略表达式 3 for ( i=1 ； i<=50 ； ) { sum=sum+2*i; i++;}d) 省略表达式 1 , 省略表达式 3 i=1 for ( ； i<=50 ； ) { sum=sum+2*i; i++; }



表达式 1 ，表达式 3可以是： a) 简单的表达式 b)逗号表达式表达式 2 一般是关系表达式或逻辑表达式例： for ( sum=0 , i=1 ; i<=50 ; i++,i++ ) sum=sum+2*i;或： for ( sum=0 , i=1 ; i<=50 ; i=i+2 ) sum=sum+2*i



(2) while 语句的一般形式为： while( 表达式 ) { 语句； } 其中表达式是循环条件，语句为循环体。while 语句的语义是：计算表达式的值，当值为真 (非 0)时，执行循环体语句。



使用 while 语句应注意以下几点：1.while 语句中的表达式一般是关系表达或逻辑表达式，只要表达式的值为真 (非 0)即可继续循环。2.循环体如包括有一个以上的语句，则必须用 {}括起来，组成复合语句。3.应注意循环条件的选择以避免死循环 ,一般需要在循环体中动态改变循环条件的值。



(3) do-while 语句的一般形式为： do语句； while( 表达式 ) ；其中语句是循环体，表达式是循环条件。do-while 语句的语义是：先执行循环体语句一次，再判别表达式的值，若为真 (非0)则继续循环，否则终止循环。do-while 语句和 while 语句的区别在于 do-while 是先执行后判断，因此 do-while至少要执行一次循环体。而 while是先判断后执行，如果条件不满足，则一次循环体语句也不执行。



(4)循环体语句可使用 break 和 continue语句break ：可以用来从循环体内跳出循环体（提前结束循环）continue：用于跳过循环体中下面尚未执行的语句，接着重新执行循环的判断例 :输出 100以内能被 7整除的数。 int n;for(n=7;n<=100;n++){if (n%7!=0)continue;printf("%d ",n);}



练习：1. 有一分数序列： 2/1 ， 3/2 ， 5/3 ， 8/5 ， 13/8 ， 21/13...求出这个数列的前 20项之和。2.求 1+2!+3!+...+20!的和。3.用牛顿切线法求 x-sin(x)=0 在区间（ 0 ， π）之间的解。4.任意输入两个数，求这两个数的最大公约数。5.从键盘输入一个数判断其是否为素数。



作业：1. 求 s=a+aa+aaa+aaaa+aa...a 的值，其中 a是一个数字。例如 2+22+222+2222+22222(此时共有 5个数相加 ) ，几个数相加由键盘输入控制。2. 一球从 100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在第 10次落地时，共经过多少米？第 10次反弹多高？3. 求 1+2!+3!+...+20!的和4. 猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个。第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第 10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少？



3.2 循环的嵌套使用【实例】搬砖问题。 36块砖， 36人搬，男搬 4 ，女搬 3 ，两个小孩抬一砖，要求一次全搬完，问男、女、小孩各若干？1. 分析 : 列方程 ,得出问题条件 : w+m+c=36 4*m+3*w+c/2=36 可以用枚举的方法，让变量 w在 0~9 、 m在 0~12 、 c在 0~36 的偶数中取值，形成满足上述条件的 w 、 m、 c的组合



N-S 流程图m<9

w<12c=36-m-w 且 c%2==0

4*m+3*w+c/2==36

输出 m 、 w 、 cTrue False

w=0

w=w+1;m=m+1;

m=0



2. 程序main（）{int m,w,c; for(m=0;m<9;m++) for(w=0;w<12;w++) {c=36-w-m; if(c%2!=0)continue; if(4*m+3*w+c/2==36) printf(“m=%d,w=%d,c=%d”,m,w,c); } }



练习：1. 输出 9*9口诀。2.判断 101-200 之间有多少个素数，并输出所有素数。3.打印出所有的“水仙花数”，所谓“水仙花数”是指一个三位数，其各位数字立方和等于该数本身。例如： 153 是一个“水仙花数”，因为153=1 的三次方＋ 5 的三次方＋ 3 的三次方。



作业：1. 将一个正整数分解质因数。例如：输入 90,打印出 90=2*3*3*5 。程序分析：对 n进行分解质因数，应先找到一个最小的质数 k，然后按下述步骤完成： (1) 如果这个质数恰等于 n，则说明分解质因数的过程已经结束，打印出即可。(2)如果 n<>k，但 n 能被 k整除，则应打印出 k的值，并用 n除以 k的商 , 作为新的正整数你 n,　重复执行第一步。(3)如果 n 不能被 k整除，则用 k+1 作为 k的值 ,重复执行第一步。2.一个数如果恰好等于它的因子之和，这个数就称为“完数”。例如 6=1＋ 2＋ 3. 编程找出 1000 以内的所有完数。



课堂讨论：五位跳水高手将参加十米高台跳水决赛，有好事者让五个人据实力预测比赛结果。 A 选手说： B第二，我第三；B 选手说：我第二， E第四；C选手说：我第一， D第二；D 选手说： C最后，我第三；E选手说：我第四， A第一；决赛成绩公布之后，每位选手的预测都只说对了一半，即一对一错，请编程解出比赛的实际名次。



思路：思路： 1 首先是将五个人的预测写成逻辑表达式：让关系运算符“ ==”的含义是“是”。让数字 1 、 2、 3、 4、 5分别表示名次第一、第二，…，第五。让整型变量 A、 B、 C、 D、 E分别表示每个选手所得名次。 A 选手说： B==2 ， A==3 ；B 选手说： B==2 ， E==4 ；C选手说： C==1 ， D==2 ；D 选手说： C==5 ， D==3 ；E选手说： E==4 ， A==1 ；



2 考虑到每个人说的话是一对一错，即一真一假，比如 A 说的，若 B==2 为真，则 A==3 为假，为真取值为 1，为假取值为 0，则两个关系表达式之和必为 1。即 (B==2)+(A==3)应该是 1 我们可以归纳出要同时满足五个人所说的话都符合一半对一半错的条件是ta=((B==2)+(A==3))==1; 符合 A 选手的话，则 ta 为 1tb=((B==2)+(E==4))==1; 符合 B 选手的话，则 tb 为 1tc=((C==1)+(D==2))==1; 符合 C选手的话，则 tc 为 1td=((C==5)+(D==3))==1; 符合 D 选手的话，则 td 为 1te=((E==4)+(A==1))==1; 符合 E选手的话，则 te 为 1



3.仍然可以用枚举的方法，让变量 A、 B、 C、 D、 E在 1~5中取值，形成满足上述条件且 A、 B、 C、 D、 E取值均不同的 A~E的组合，即是所求。可以考虑 A、 B、 C、 D、 E取值均不同的条件为 A *B*C*D*E=120


C 语言程序设计第三讲循环结构For(A=1;A<=5;A++)

For(B=1;B<=5;B++)For(C=1;C<=5;C++)

For(D=1;D<=5;D++)E=15-(A+B+C+D)

A*B*C*D*E=120求 ta 、 tb 、 tc 、td 、 tet=ta+tb+tc+td+te

t==5输出 ABCDE

True

True

False

False


作业 : 某地刑侦大队对涉及六个嫌疑人的一桩疑案进行分析： 1） A、 B至少有一人作案； 2） A、 D不可能是同案犯； 3） A、 E、 F三人中至少有两人参与作案； 4） B、 C或同时作案，或与本案无关； 5） C 、 D中有且仅有一人作案； 6）如果 D没有参与作案，则 E也不可能参与作案。试编一程序，将作案人找出来。



1 1 案情分析：将案情的每一条写成逻辑表达式，第一条用案情分析：将案情的每一条写成逻辑表达式，第一条用 CCC1C1 表示，第二条用表示，第二条用 CC2CC2 表示，……表示，……CC1CC1：： AA和和 BB 至少有一人作案至少有一人作案令令 AA变量表示变量表示 AA作案作案 BB变量表示变量表示 BB作案作案 AA BB CC1 CC1 00 00 0 0 11 00 1 1 00 11 1 1

11 11 1 1 显然这是或的关系，因此有显然这是或的关系，因此有 CC1=(A||B)CC1=(A||B)



CC2CC2：： AA和和 DD不可能是同案犯不可能是同案犯可以分析为：可以分析为： AA如果是案犯，如果是案犯， DD 一定不是案犯，写成一定不是案犯，写成 A&&A&&(!D) D(!D) D如果是案犯，如果是案犯， AA 一定不是案犯，写成一定不是案犯，写成 D&&(!A) D&&(!A) 这两者之间是或的关系，因此有这两者之间是或的关系，因此有 CC2=!(A&&D)CC2=!(A&&D) AA DD A&&D A&&D CC2 CC2 11 00 0 0 1 1 11 11 1 1 0 0 00 00 0 0 1 1 00 11 0 0 1 1



CC3CC3 ：： AA 、、 EE 、、 FF 中有两人涉嫌作案，分析有三中有两人涉嫌作案，分析有三种可能种可能第一种，第一种， AA 和和 EE 作案，（作案，（ A&&EA&&E ））第二种，第二种， AA 和和 FF 作案，（作案，（ A&&FA&&F ））第三种，第三种， EE 和和 FF 作案，（作案，（ E&&FE&&F ））这三种可能性是或的关系，这三种可能性是或的关系，因此有因此有 CC3= (A&&ECC3= (A&&E ）） |||| （（ A&&FA&&F ）） |||| （（ E&&E&&F)F)



CC4CC4：： BB和和 CC或同时作案，或都与本案无关或同时作案，或都与本案无关第一种情况：同时作案（第一种情况：同时作案（ B && CB && C））第二种情况：都与本案无关（第二种情况：都与本案无关（ !B && !C!B && !C））两者为或的关系，因此有两者为或的关系，因此有 CC4=(B && C)||(!B && !C)CC4=(B && C)||(!B && !C)CC5CC5：： CC 、、 DD中有且仅有一人作案中有且仅有一人作案 CC5=(C && !D)||(D && !C)CC5=(C && !D)||(D && !C)CC6CC6：：如果如果 DD没有参与作案，则没有参与作案，则 EE 也不可能参与作案。也不可能参与作案。CC6=!D !E=D||!ECC6=!D !E=D||!E



2 2 采取枚举方法，枚举什么呢？采取枚举方法，枚举什么呢？枚举组合。枚举组合。 66个人每个人都有作案或不作案两种个人每个人都有作案或不作案两种可能，因此有可能，因此有 2266种组合，从这些组合中挑出符合种组合，从这些组合中挑出符合 66条分析的作案者。定义条分析的作案者。定义 66个整数变量，分别表示个整数变量，分别表示 66个人个人 AA ，， BB，， CC ，， DD，， EE，， FF。枚举每个人的可。枚举每个人的可能性能性 : : 让让 00 表示不是罪犯；让表示不是罪犯；让 11 表示就是罪犯。表示就是罪犯。


C 语言程序设计第三讲循环结构for(A=0;A<=1;A++)for(B=0;B<=1;B++)

for(C=0;C<=1;C++)for(D=0;D<=1;D++)

for(E=0;E<=1;E++)for(F=0;F<=1;F++)

计算 CC1 CC2 CC3 CC4 CC5 CC6判断这些值是否都为 1True False

输出 ABCDEF为 1 的


问题：哪只羊最重？中秋佳节，有贵客来到草原，主人要从羊群中中秋佳节，有贵客来到草原，主人要从羊群中选一只肥羊宴请宾客，当然要选最重者。这样选一只肥羊宴请宾客，当然要选最重者。这样就要记录每只羊的重量，如果有成千上万只羊，就要记录每只羊的重量，如果有成千上万只羊，不可能用一般变量来记录。可以用带有下标的不可能用一般变量来记录。可以用带有下标的变量，也就是这里要讲的变量，也就是这里要讲的数组数组。。

第四讲数组


1. 程序分析：max=0.0 将记录最重的羊的重量

for(i=0;i<10;i++)

提示输入第 i只羊的重量输入第 i只羊的重量 sheep[i]max<sheep[i]Yes No

max=sheep[i]k=i

输出 max和 k的值

第四讲数组


2. 程序main()main() // // 主函数主函数 { { float sheep[10];float sheep[10]; // // 数组，有数组，有 1010个浮点类型元素个浮点类型元素float max;float max; // // 浮点类型变量，存放最肥羊的重量浮点类型变量，存放最肥羊的重量int i,k; //int i,k; //整型变量，整型变量， ii 用于计数循环，用于计数循环， kk用于记录最肥羊的号用于记录最肥羊的号max = 0.0;max = 0.0; // // 赋初值赋初值 0 0 for ( i=0; i<10; i=i+1 )for ( i=0; i<10; i=i+1 ) // // 计数循环计数循环 {printf(“{printf(“请输入羊的重量请输入羊的重量 sheep[%d]=”, i);sheep[%d]=”, i); scanf(“%f”, &(sheep[i]));scanf(“%f”, &(sheep[i])); if ( max < sheep[i] ) if ( max < sheep[i] ) {max = sheep[i];{max = sheep[i]; // // 让第让第 ii只羊为当前最肥羊只羊为当前最肥羊 k=i;} k=i;} }}printf(“max=%f\n number=%d\n”, max , k);}printf(“max=%f\n number=%d\n”, max , k);}

第四讲数组


3. 归纳分析(1) 数组的定义类型说明符数组名 [ 常量表达式 ] 例： float sheep[10]; int a2001[1000]; 说明 ①数组名的第一个字符应为英文字母； ②用方括号将常量表达式括起； ③常量表达式定义了数组元素的个数；

第四讲数组


④④数组下标从数组下标从 00 开始。如果定义开始。如果定义 55个元素，是从第个元素，是从第 00个元素至第个元素至第 44 个元素；个元素；例如例如 int a[5] int a[5] 定义了定义了 55个数组元素如下：个数组元素如下： a[0], a[1], a[2], a[3], a[4] a[0], a[1], a[2], a[3], a[4] 这是这是 55个带下标的变量，这个带下标的变量，这 55个变量的类型是相同的个变量的类型是相同的 ⑤⑤常量表达式中不允许包含变量；常量表达式中不允许包含变量；例如例如 int n; int n; n = 5; n = 5; int a[n];int a[n]; 不合法！不合法！

第四讲数组


(2) 数组初始化数组初始化是定义数组完成赋初值的任务是定义数组完成赋初值的任务例如例如 int a[5] = { 3, 5, 4, 1, 2 }; int a[5] = { 3, 5, 4, 1, 2 }; aa

a[0] = 3; a[1] = 5; a[2] = 4; a[0] = 3; a[1] = 5; a[2] = 4; a[3] = 1; a[4] = 2;a[3] = 1; a[4] = 2;

3 5 4 1 2下标 0 1 2 3 4

第四讲数组


(3) 数组在内存中分配一段连续的存储空间内存地址变量名

FF02FF01FF00

FF03FF04FF05FF06FF07

a[0]

a[1]

a[2]

a[3]

00000000

000000110000000000000101

00000000

000001000000000000000001

0000000000000010FF08

FF09a[4]

a数组名

第四讲数组


思考 :1.#include <stdio.h> void main() { int a[4]; // 声明项 printf(“a[0]=%d; a[1]=%d; a[2]=%d; a[3]=%d\n”, a[0], a[1], a[2], a[3]); } 2. 其他不变，改变声明项为 int a[4] = { 0, 1, 2, 3 };

第四讲数组


3.3. 其他不变，改变声明项为其他不变，改变声明项为 int a[4] = { 3, 8 }; 4.4. 其他不变，改变声明项为其他不变，改变声明项为 int a[4] = { 2, 4, 6, 8, 10 };5.5. 其他不变，改变声明项为其他不变，改变声明项为 int a[4] = { 2, 4, 6, d };6.6. 其他不变，改变声明项为其他不变，改变声明项为 int n=4; int a[n] = { 0, 1, 2, 3 };

第四讲数组

C 语言程序设计第四讲数组【实例】将几个数从大到小排序并输出，冒泡排序法 i=1 i=2 i=3 i=4 i=5 i=6

a[1] a[2] a[3] a[4] a[5] a[6]初始值 1 8 3 2 4 9比较 1 和 8, 调换 1 8 3 2 4 9比较 1 和 3, 调换 8 1 3 2 4 9比较 1 和 2, 调换 8 3 1 2 4 9比较 1 和 4, 调换 8 3 2 1 4 9比较 1 和 4, 调换 8 3 2 4 1 91 到达位置 8 3 2 4 9 1比较 8 和 3, 不动 8 3 2 4 9 1比较 3 和 2, 不动 8 3 2 4 9 1比较 2 和 4, 调换 8 3 2 4 9 1比较 2 和 9, 调换 8 3 4 2 9 12 到达位置 8 3 4 9 2 1


i=1 i=2 i=3 i=4 i=5 i=6

a[1] a[2] a[3] a[4] a[5] a[6]中间值 8 3 4 9 2 1

比较 8 和 3, 不动 8 3 4 9 2 1比较 3 和 4, 调换 8 3 4 9 2 1比较 3 和 9, 调换 8 4 3 9 2 13 到达位置 8 4 9 3 2 1比较 8 和 4, 不动 8 4 9 3 2 1比较 4 和 9, 调换 8 4 9 3 2 14 到达位置 8 9 4 3 2 1比较 8 和 9, 调换 8 9 4 3 2 18 到达位置 9 8 4 3 2 1

第四讲数组


从表中可以看出最小的一个数第一遍扫描就交换从表中可以看出最小的一个数第一遍扫描就交换到到 a[6]a[6]如果将如果将 a[1]a[1] 视为水底，视为水底， a[6]a[6] 视为水面：视为水面：最轻的最轻的 (( 最小的最小的 ))一个数一个数 1 1 最先浮到水面，交最先浮到水面，交换到换到 a[6];a[6];次轻的次轻的 2 2 第二遍扫描交换到第二遍扫描交换到 a[5]a[5]；；再轻的再轻的 3 3 第三遍扫描交换到第三遍扫描交换到 a[4]a[4]；； ……依此类推，有依此类推，有 66个数，前个数，前 55个数到位需个数到位需 55遍扫遍扫描，第描，第 66个最重的数自然落在个最重的数自然落在 a[1]a[1]中。中。因此，因此， 66 个数只需个数只需 55遍扫描，即遍扫描，即 j=n-1, n=6j=n-1, n=6 。。

第四讲数组


再看在每遍扫描中，相邻两数组元素的比较次数。再看在每遍扫描中，相邻两数组元素的比较次数。当当 j=1j=1时，时， i=1,2,…,n-ji=1,2,…,n-j。。n=6n=6时，比较时，比较 55次之后次之后 a[6]a[6]中有一个最小数到达，这时中有一个最小数到达，这时a[6]a[6]不必再参与比较了。不必再参与比较了。因此在第二遍搜索时，因此在第二遍搜索时， j=2, i=1,2,…,n-jj=2, i=1,2,…,n-j，即，即 i=1,2,3,i=1,2,3,44 。比较。比较 44次之后次小的一个数到达了次之后次小的一个数到达了 a[5]a[5]。。这时这时 a[5]a[5]不必再参与比较了。不必再参与比较了。因此，因此，j=3j=3时，时， i=1,2,3i=1,2,3 ；；j=4j=4时，时， i=1,2i=1,2 ；；j=5j=5时，时， i=1i=1

第四讲数组


为了表述方便，定义以下为了表述方便，定义以下 33个变量：个变量： n —— n —— 待排序的数的个数，这里待排序的数的个数，这里 n=6 n=6 j —— j —— 扫描遍数，扫描遍数， j=1,2,…,n-1 j=1,2,…,n-1 i —— i —— 第第 jj 遍扫描待比较元素的下标，遍扫描待比较元素的下标， i=1,2,i=1,2,…,n-j …,n-j

第四讲数组


采用两重计数型循环：采用两重计数型循环：步骤步骤 11 ：：将待排序的数据放入数组中；将待排序的数据放入数组中；步骤步骤 22 ：：置置 jj为为 11 ；；步骤步骤 33 ：：让让 ii从从 11 到到 n-jn-j，比较，比较 a[i]a[i]与与 a[i+1]a[i+1]，，如果如果 a[i] >= a[i+1]a[i] >= a[i+1]，位置不动；，位置不动；如果如果 a[i] < a[i+1]a[i] < a[i+1]，位置交换，，位置交换，即即 p=a[i]; a[i]=a[i+1]; a[i+1]=p; p=a[i]; a[i]=a[i+1]; a[i+1]=p;

步骤步骤 33 结束后结束后 a[n-j+1]a[n-j+1]中的数为最小的数中的数为最小的数步骤步骤 44 ：：让让 j=j+1j=j+1 ；只要；只要 j<nj<n就返回步骤就返回步骤 33 ，，将将 a[n-j+1]a[n-j+1]的值排好。当的值排好。当 j==nj==n时执行步时执行步骤骤 5 5 步骤步骤 55 ：：输出排序结果输出排序结果

第四讲数组


2.程序main()main() // // 主函数主函数 { { int i, j, p, a[7];int i, j, p, a[7];// // 整型变量整型变量 for (i=1; i<=6; i=i+1)for (i=1; i<=6; i=i+1) // // 键入键入 66个数，放入个数，放入 aa 数组中数组中 { { printf(“printf(“请输入待排序的数请输入待排序的数 a[%d]=”, i);a[%d]=”, i);scanf (“%d”, &a[i]);scanf (“%d”, &a[i]); } } for ( j=1; j<=5; j=j+1)for ( j=1; j<=5; j=j+1) // // 冒泡排序，外层循环冒泡排序，外层循环 for ( ifor ( i=1; i<=6-j; i=i+1 )=1; i<=6-j; i=i+1 ) // // 内层循环内层循环 { if ( a[i] < a[i+1] ) { if ( a[i] < a[i+1] ) {p = a[i]; a[i] = a[i+1]; a[i+1] = p;} }{p = a[i]; a[i] = a[i+1]; a[i+1] = p;} }for ( i=1; i<=6; i=i+1)for ( i=1; i<=6; i=i+1) // // 输出排序结果输出排序结果 printf(“%d\printf(“%d\n”, a[i]);n”, a[i]);}}

第四讲数组


作业：船长与水手的问题：有载有 50个人的大船，突然触礁，船底撞了一个大窟窿，水不停地涌进船里，船不断下沉。这时，聪明的船长把所有人召集到一起，给每人一个编号，手拉手围成一圈，从 1号开始报数，报的数为 9时，这个人出列，跳入大海，剩下的人继续围成一圈，后面的人从 1开始继续报数，重复上面地步骤 ,聪明的船长却最后留在了船上。问 : 船长是几号才能最后一个跳入大海？

第四讲数组


讨论问题讨论问题 : : 使用筛法求使用筛法求 100100 以内的所有素数以内的所有素数思路思路 1.1. 想象将想象将 100100个数看作沙子和小石头子，让小石头子当个数看作沙子和小石头子，让小石头子当作素数；让沙子当作非素数。弄一个筛子，只要将沙作素数；让沙子当作非素数。弄一个筛子，只要将沙子筛走，剩下的就是素数了。子筛走，剩下的就是素数了。 2.2.非素数一定是非素数一定是 22 、、 33 、、 4 …… 4 …… 的倍数。的倍数。 3.3.使用数组，让下标就是使用数组，让下标就是 100100 以内的数，让数组元素的以内的数，让数组元素的值作为筛去与否的标志。比如筛去以后让元素值为值作为筛去与否的标志。比如筛去以后让元素值为 11 。。

第四讲数组


11至至 100100 这些自然数可以分为三类：这些自然数可以分为三类：单位数：仅有一个数 1。素数：是这样一个数，它大于 1 ，且只有1和它自身这样两个正因数。合数：除了 1 和自身以外，还有其他正因数。11 不是素数，除不是素数，除 11以外的自然数，当然只有素数与合数。以外的自然数，当然只有素数与合数。筛法实际上是筛去合数，留下素数。筛法实际上是筛去合数，留下素数。为了提高筛选法效率，注意到：为了提高筛选法效率，注意到：令令 nn 为合数（这里是为合数（这里是 100100 ），）， cc为为 nn 的最小正因数，则据初等数论的最小正因数，则据初等数论只要找到只要找到 cc 就可以确认就可以确认 nn 为合数，将其筛去。为合数，将其筛去。nc1

第四讲数组


for(i=2;i<=100:i++)prim[i]=0;

for(i=3;i<=100:i++)a=sqrt(i)

for(j=2;j<=a:j++)i%j==0

prim[i]=1for(i=2;i<=100;i++)

prim[i]==0

输出 i

Yes

Yes

No

No

第四讲数组


二维数组问题：求矩阵 a 的最大值 1 3 5 a= 7 9 2 4 6 8

第四讲数组


1 ．二维数组定义格式：类型说明符数组名 [常量表达式 ] [常量表达式 ] 例 : int a[2] [3] ={{3,5},{4,1},{2,6}};说明： a ）每一维的下标从 0开始，整个数组元素为： 2×3=6个 b） C 语言中，二维数组中元素排列的顺序是按行存放。即：先存放第一行的元素，再存放第二行的元素

第四讲数组


二维数组在内存中的分配情况内存地址变量名

FF02FF01FF00

FF03FF04FF05FF06FF07

a[0][0]

a[0][1]

a[1][0]a[1][1]

00000000

000000110000000000000101

00000000

000001000000000000000001

0000000000000010FF08

FF09a[2][0]

a

数组名

……

第四讲数组


c）可以计算数组元素在数组中的序号假设 m×n 的数组 a，计算 a[i][j]序号的公式： i×n+j 如 3×3 数组中 : a[0][1] 0×3+1=1( 第二个 ) a[1][2] 1×3+2=5( 第六个 ) a[2][2] 2×3+2=8( 第九个 )

第四讲数组


求矩阵 a 的最大值 1 3 5 a= 7 9 2 4 6 8问题分析：将矩阵放入二维数组 a[3][3]中首先定义变量 max=a[0][0]， max与 a[0][1]比较，若发现 max<a[0][1]，则将 max=a[0][1]，这样 max与数组元素逐个比较，最后找到数组中最大的一个。采用二重循环分别对行和列进行控制。外层控制行标，内层控制列标。

第四讲数组


作业1.打印魔方阵：8 1 63 5 74 9 2

算法 :1. 将 1放到第 1行的中间。2.下一个数放在该数的前一行后一列。3.若该位置已经有数 ,则放在前一数的正下方。4.当前数是右上角时 , 其下一个数放在其下方。5.若当前是第 1行 ,则其前一行为第 n行 ,若当前列是第 n列 ,则其后一列为第 1列。

第四讲数组


1

nk

x

x问题：编程求解

我们用函数来编写这个题的程序，参考程序如下：我们用函数来编写这个题的程序，参考程序如下：#include <stdio.h> //#include <stdio.h> // 预编译命令预编译命令 #define n 6 //#define n 6 // 定义定义 nn 为为 6 6 #define k 4 //#define k 4 // 定义定义 kk 为为 4 4 void main() //void main() // 主函数主函数 {printf("sum of %dth powers of integers from 1 to {printf("sum of %dth powers of integers from 1 to %d=",k,n ); %d=",k,n ); printf("%d\n",SOP(n,k)); printf("%d\n",SOP(n,k)); ////输出结果输出结果 ,, 其中其中 SOP(n,k)SOP(n,k) 为被调用函数为被调用函数 }}

6

1

( 4)l

x

sum x l

第五讲函数


int SOP(m,l) //整型自定义函数 ,m,l 为形参 int m,l; //形参 m,l 为整型变量 { int i,sum=0; //整型变量 i,sum

for (i=1; i<=m; i=i+1 ) {sum=sum+power( i ,l ); } return (sum) ; } //返回值 sum给函数 sop(n,k)

// 以下函数是被函数 sop(n,k) 调用的函数 int power(p,q) //整型自定义函数 int p,q; //形参 p,q 为整型变量 {int i,product=1; for(i=1; i<=q; i=i+1) { product=product*p; } return(product); } //累乘值 product返回给 power

第五讲函数


< 数据类型 > < 函数名 > (<参数表>)例 : int power(p,n) power 为函数名，要以英文字母开头。 int 是函数值的数据类型，这里是 int（整型）。 (p,n)括号中的 p,n 为函数的形式参数，形式参数也要定义其数据类型。函数定义的一般格式：< 数据类型 > < 函数名 > (<参数表 >) <参数说明 ;> { <说明语句 > < 执行语句 > }

函数的定义格式：第五讲函数

C 语言程序设计第五讲函数1 、形式参数是在定义函数时放在函数名后括号中的参数。在未进行函数调用时，并不对形式参数分配内存单元。在发生函数调用时，立刻给形式参数分配内存单元。调用结束后，释放掉行参所占的内存单元。 2、因此，形参变量属于局部变量，其作用域在它所在的函数体内。 3、在定义函数的时候，必须指定形参变量的类型，如何指定？有二种方法：

形式参数与实在参数

(1) int power(p,n) int p,n; {

…… }

(2) int power(int p,int n) {

…… }

有些编译系统不认识第（ 2）种形式


4 、实在参数是一个具有确定值的表达式。函数在调用时，将实在参数赋给形式参数。比如，主函数调用 SOP(n,k) ，这时， n,k为实在参数， n的值为 6， k的值为 4。在被调用函数定义中， int SOP(m,l)中的 m,l 为形式参数，在 SOP 被调用时，系统给 m,l 这两个形式参数分配了内存单元之后， n的值 6赋给 m ， k的值 4赋给l 。实在参数的个数及类型应与形式参数一致。赋值时前后对应关系不会改变。下面画出主函数与 SOP函数，调用与被调用时参数传递关系：

第五讲函数


主函数执行下述语句时，主函数执行下述语句时， printf(“%d\n”,Sprintf(“%d\n”,SOP(n,k)); OP(n,k)); 传值给被调用函数传值给被调用函数 int SOPint SOP(m,l) (m,l) nn 的值的值 66传给传给 m, km, k的值的值 44传给传给 ll 。。 66 和和 44 为实在参数，为实在参数， mm 和和 ll为形式参数。为形式参数。被调用函数在其形式参数被赋值之后，开始执行函数体，先是被调用函数在其形式参数被赋值之后，开始执行函数体，先是让累加器初始化为让累加器初始化为 00 （（ sum=0sum=0），接着进入以），接着进入以 ii 为控制变量为控制变量的计算循环，的计算循环， ii从从 11 变到变到 mm（（ m=6m=6），即累加），即累加 mm次（即次（即 66次）。循环体为次）。循环体为 sum=sum+power(i,l)sum=sum+power(i,l) 。当。当 66次循环执行完后，次循环执行完后，实现的是实现的是 6

1

( 4)l

x

sum x l

注意注意这里这里 xxl l 是由另一个自定义函数是由另一个自定义函数 power(i,l)power(i,l) 实现实现的。的。 li

第五讲函数


power(i,l)处在 SOP(m,l) 函数中，表示 SOP函数去调用 power 函数。其中 i,l 为实在参数，而 int power(p,q) 中的 p,q为形式参数。比如，执行 SOP(6,4)时， l=4,m=6, 当 i=1时， sum=sum+power(1,4) 这里 1 ， 4为实在参数，调用 power(p,q) ，两个形式参数 p,q分别被赋以 1， 4。

第五讲函数


6

i=2: sum = sum + power(i,l) = 1 + 16= 17

调用返回

执行 power(2, 4):product = 2*2*2*2return(16) = 16

i=3: sum = sum + power(i,l)= 17 + 81= 98

调用返回


i=4: sum = sum + power(i,l)= 98 + 256= 354

调用返回


i=5: sum = sum + power(i,l)= 354 + 625= 979

调用返回执行 power(5, 4):

product = 5*5*5*5return(625) = 625

执行 power(6, 4):produ ct = 6*6*6*

return(1296) = 1296

调用= 0 + 1= 1

返回执行 SOP(6,4) l=4

sum=0i=1: sum = sum + power(i,l)


SOP(n,k) 调用

i=6: sum = sum + power(i,l)= 979 + 1296= 2275

return (sum)2275返回

调用返回

C 语言程序设计第五讲函数Main()

调用 a 函数

结束

a 函数

调用 b 函数

结束

b 函数

结束


例：求函数 f(x)=x3+x+5 的值，其中 x=y3+y2+5y+6 ，求当 y=1,2,3,4…,100 时 f(x) 的值。

第五讲函数


作业 : 1. 设计一个函数 ,求解 1000 以内的所有素数 .第五讲函数


递归算法在可计算性理论中占有重要地位，它是算法设计的有力工具，对于拓展编程思路非常有用。就递归算法而言并不涉及高深数学知识，只不过初学者要建立起递归概念不十分容易。我们先从一个最简单的例子导入。用递归算法求 n! 定义：函数 fact(n) = n! fact(n-1) = (n-1)! 则有 fact(n) = n*fact(n-1) 已知 fact(1) = 1

第六讲递归及其实现


下面我们以 3！为例画出了调用和返回的递归示意图

Bfact(2)=2*fact(1)=2*1=2 返回

Afact(3)=3*fact(2)=3*2=6 返回

Cfact(1)=1

调用调用



从图可以想象：欲求 fact(3) ，先要求 fact(2) ；要求 fact(2)先求 fact(1) 。就象剥一颗圆白菜，从外向里，一层层剥下来，到了菜心，遇到 1的阶乘，其值为 1，到达了递归的边界。然后再用 fact(n)=n*fact(n-1) 这个普遍公式，从里向外倒推回去得到 fact(n) 的值。为了把这个问题说得再透彻一点。我们画了如下的流程图：



2

) )

1

3 1

2

* )

2 1

2 1

* 1

1 1

)) )

)

＝＝fact(3)

真假

调用fact(

计算3 fact(

fact( fact(

＝＝真假

调用fact(1

计算2 fact(

＝＝真假

fact(＝1

返回返回



将上图改为下图

1

)

假真

fact(3)

真假3==1

调用 fact( 2

真假2==1

1==1

f act(2)=2*fact(1) 返回

f act(3)=3*fact(2) 返回

调用 fact( )

fact(1) =1返回



在这个图中“内层”与“外层”有着相同的结构。它们之间“你中有我，我中有你”，呈现相互依存的关系。为了进一步讲清递归的概念，将递归与递推做一比较。仍以求阶乘为例。递推是从已知的初始条件出发，逐次去求所需要的阶乘值。如求 3！初始条件 fact(1) = 1 fact(2) = 2*fact(1) = 2 fact(3) = 3*fact(2) = 6



这相当于从菜心“推到”外层。而递归算法的出发点不放在初始条件上，而放在求解的目标上，从所求的未知项出发逐次调用本身的求解过程，直到递归的边界（即初始条件）。就本例而言，读者会认为递归算法可能是多余的，费力而不讨好。但许多实际问题不可能或不容易找到显而易见的递推关系，这时递归算法就表现出了明显的优越性。下面我们将会看到，递归算法比较符合人的思维方式，逻辑性强，可将问题描述得简单扼要，具有良好的可读性，易于理解，许多看来相当复杂，或难以下手的问题，如果能够使用递归算法就会使问题变得易于处理。



故事：相传在古代印度的 Bramah庙中，有位僧人整天把三根柱子上的金盘倒来倒去，原来他是想把 64个一个比一个小的金盘从一根柱子上移到另一根柱子上去。移动过程中恪守下述规则：每次只允许移动一只盘，且大盘不得落在小盘上面。有人会觉得这很简单，真的动手移盘就会发现，如以每秒移动一只盘子的话，按照上述规则将 64只盘子从一个柱子移至另一个柱子上，所需时间约为 5800亿年。CA B



怎样编写这种程序？思路上还是先从最简单的情况分析起，搬一搬看，慢慢理出思路。1、在 A柱上只有一只盘子，假定盘号为 1，这时只需将该盘从 A搬至 C ，一次完成，记为 move 1 from A to C

CA B

1



2 、在 A柱上有二只盘子， 1为小盘， 2为大盘。第（ 1）步将 1号盘从 A移至 B，这是为了让 2号盘能移动；第（ 2）步将 2号盘从 A移至 C ；第（ 3）步再将 1号盘从 B移至 C ；这三步记为： move 1 from A to B; move 2 from A to C; move 1 form B to C;CA B

1 3

2



3 、在 A柱上有 3只盘子，从小到大分别为 1号， 2号， 3号第（ 1）步将 1号盘和 2号盘视为一个整体；先将二者作为整体从 A移至 B，给 3号盘创造能够一次移至 C 的机会。这一步记为 move( 2, A, C, B) 意思是将上面的 2只盘子作为整体从 A借助 C移至 B。第（ 2）步将 3号盘从 A移至 C ，一次到位。记为

move 3 from A to C 第（ 3）步处于 B上的作为一个整体的 2只盘子，再移至 C 。这一步记为 move( 2, B, A, C) 意思是将 2只盘子作为整体从 B借助 A移至 C 。



移动过程如下图A B C

1 3

2



4 、从题目的约束条件看，大盘上可以随便摞小盘，相反则不允许。在将 1号和 2号盘当整体从 A移至 B的过程中 move(2, A, C, B) 实际上是分解为以下三步第（ 1）步： move 1 form A to C; 第（ 2）步： move 2 form A to B; 第（ 3）步： move 1 form C to B; 经过以上步骤，将 1号和 2号盘作为整体从 A移至 B，为 3号盘从 A移至 C 创造了条件。同样， 3号盘一旦到了 C ，就要考虑如何实现将 1号和 2号盘当整体从 B移至 C 的过程了。实际上 move(2, B, A, C) 也要分解为三步：第（ 1）步： move 1 form B to A; 第（ 2）步： move 2 form B to C; 第（ 3）步： move 1 form A to C;



5 、看 move(2, A, C, B) 是说要将 2只盘自从 A搬至 B，但没有 C是不行的，因为第（ 1）步就要将 1盘从 A移到 C，给2盘创造条件从 A移至 B，然后再把 1盘从 C移至 B。看到这里就能明白借助 C 的含义了。因此，在构思搬移过程的参量时，要把 3个柱子都用上。 6、定义搬移函数 move(n, A, B, C) ，物理意义是将 n只盘子从 A经 B搬到 C move(n, A, B, C) 分解为 3步 (1)move(n-1, A, C, B) 理解为将上面的 n-1只盘子作为一个整体从 A经 C移至 B； (2) 输出 n： A to C ，理解将 n号盘从 A移至 C ； (3)Move(n-1, B, A, C) 理解为将上面的 n-1只盘子作为一个整体从 B经 A移至 C 。



这里显然是一种递归定义，当解 move(n-1, A, C, B)时又可想到，将其分解为 3步：第 1步：将上面的 n-2只盘子作为一个整体从 A经 B到 C，move(n-2, A, B, C) ；第 2步：第 n-1号盘子从 A直接移至 B，即输出 n-1:A to B；第 3步：再将上面的 n-2只盘子作为一个整体从 C经 A移至B， move(n-2, C, A, B) ；



4

7

返回

move(3,A,B,C)

C Bmove(2,A, , )

, ,2 Amove( B ,C)

,B,move(2 A,C)

调用

返回

返回

调用

调用

返回

, ,1move( B C,A)

,1 ,move( A B,C)

1move( ,A,B,C)

输出 1: A to C1

,,A,move(2 C B)

1 B Cmove( ,A, , )

输出 2: A to B

C1 , ,move( , A B)

2

1move( ,B,C,A)

输出 1: B to A5

输出 2: B to C6

输出 3: A to C

调用

调用

返回

调用

调用

输出 1: C to B

3

move (1,C,A,B)

输出 1: A to C

move (1,A,B,C)

第六讲递归


B

输出 3: A to C

调用move(1,C,A,B) 输出：1: C to

输出： A to

move(1,C,A,B)

调用move(1,A,B,C) 1: A to C

move(1,A,B,C)move(2,A,C,B)

调用move(2,A,C,B)

调用move(2,B,A,C)

调用move(1,A,B,C) 输出 1: A to C

输出： to

调用 move(1,B,C,A) 输出 1: B to A

move(1,B,C,A)move(2,B,A,C)

move(1,A,B,C)

move(3,A,B,C)

2: B

输出

2: B C

1

2

3

4

5

6

7


C 语言程序设计int step=1 ; //整型全局变量 ,预置 1,步数 void move(int , char ,char,char); // 声明要用到的被调用函数 void main() { int n; printf(“请输入盘数 n=” ); scanf("%d",&n); printf(“在 3根柱子上移 %d只盘的步骤为 :\n”,n); move(n,'a','b','c');} void move(int m, char p, char q, char r) { if (m==1) {printf("[%d] move 1# from %c to %c\n", step, p,r); step=step+1; } else{move(m-1,p,r,q); printf("[%d] move %d# from %c to %c\n",step, m,p,r); step=step+1; move(m-1,q,p,r); } }


该题是 2000年全国青少年信息学奥林匹克的一道试题。叙述如下：一条小溪尺寸不大，青蛙可以从左岸跳到右岸，在左岸有一石柱 L，面积只容得下一只青蛙落脚，同样右岸也有一石柱R，面积也只容得下一只青蛙落脚。有一队青蛙从尺寸上一个比一个小。我们将青蛙从小到大，用 1， 2，…， n编号。规定初始时这队青蛙只能趴在左岸的石头 L上，当然是按号排一个落一个，小的落在大的上面。不允许大的在小的上面。在小溪中有 S 个石柱，有 y片荷叶，规定溪中的柱子上允许一只青蛙落脚，如有多只同样要求按号排一个落一个，大的在下，小的在上。对于荷叶只允许一只青蛙落脚，不允许多只在其上。对于右岸的石柱 R，与左岸的石柱 L一样，允许多个青蛙按号排一个落一个，小的在上，大的在下。当青蛙从左岸的 L上跳走后就不允许再跳回来；同样，从左岸 L上跳至右岸 R，或从溪中荷叶或溪中石柱跳至右岸 R上的青蛙也不允许再离开。问在已知溪中有 S根石柱和 y片荷叶的情况下，最多能跳过多少只青蛙？



思路： 1 、简化问题，探索规律。先从个别再到一般，要善于对多个因素作分解，孤立出一个一个因素来分析，化难为易。 2. 定义函数 Jump(S,y) —— 最多可跳过河的青蛙数其中： S —— 河中柱子数 y —— 荷叶数



3. 先看简单情况，河中无柱子： S=0 ， Jump(0,y) 当 y=1时， Jump(0,1)=2 ；说明：河中有一片荷叶，可以过两只青蛙，起始时 L上有两只青蛙， 1# 在 2#上面。第一步： 1# 跳到荷叶上；第二步： 2# 从 L直接跳至 R上；第三步： 1# 再从荷叶跳至 R上。如下图：2#

1#

2

1 3

L左岸 R右岸



当 y=2时， Jump(0,2)=3 ；说明：河中有两片荷叶时，可以过 3只青蛙。起始时： 1# ， 2# ， 3# 3只青蛙落在 L上，第一步： 1# 从 L跳至叶 1上，第二步： 2# 从 L跳至叶 2上，第三步： 3# 从 L直接跳至 R上，第四步： 2# 从叶 2跳至 R上，第五步： 1# 从叶 1跳至 R上，

叶 1

3

1 5

L R

叶 22 4

采用归纳法： Jump(0,y)=y+1 ；意思是：在河中没有石柱的情况下，过河的青蛙数仅取决于荷叶数，数目是荷叶数 +1 。



再看 Jump(S, y)先看一个最简单情况： S=1 ， y=1 。从图上看出需要 9步，跳过 4只青蛙。1# 青蛙从 L － > Y；2# 青蛙从 L － > S；1# 青蛙从 Y － > S；3# 青蛙从 L － > Y；4# 青蛙从 L － > R；3# 青蛙从 Y － > R；1# 青蛙从 S － > Y；2# 青蛙从 S － > R；1# 青蛙从 Y － > R；S

Y

5

46

L R

1

2

3 7

8

91#

2#

4#

3#3#

1#

2#1#1#


C 语言程序设计用 L1 L2 L3 L4 表示左岸石柱上落在一起的青蛙的高度位置。L1 在最上面， L4 在最下面的位置。引入这个信息就可比较容易地看出对青蛙占位的约束条件。同理 R1 R2 R3 R4 也是如此。对水中石柱 S，也分成两个高度位置 S1 S2 。对荷叶 Y无须分层，因为它只允许一只青蛙落在其上。t=0 为初始时刻，青蛙从小到大落在石柱 L上。t=1 为第一步： 1#从 L跳至荷叶 Y上； L上只剩 2# 3# 4# 。T=2 为第二步； 2#从 L跳至石柱 S上，处在 S2位置上， L上只剩 3# 和 4# 。T=3 为第三步， 1#从 Y跳至 S，将 Y清空。这时可看出， S上有 1#、 2#， L上有 3#、 4# ，好象是原来在 L上的 4只青蛙，分成了上下两部分，上面的 2只通过荷叶 y 转移到了 S上。这一过程是一分为二的过程。即将 L上的一队青蛙，分解为两个队，每队各二只，且将上面的二只转移到了 S上。这时我们可以考虑形成两个系统，一个是 L， Y，R系统，一个是 S， Y， R系统。前者二只青蛙号大；后者二只青蛙号小。先跳号大的，再跳号小的。从第五步到第九步可以看出的确是这么做的。



对于 LYR系统，相当于 Jump(0,1)对于 SYR系统，相当于 Jump(0,1)两个系统之和为 2*Jump(0,1) ，因此有：Jump(1,1)=2*Jump(0,1)=2*2=4 。

现在再看 S=2 ， y=1 Jump(2,1) 我们将河中的两个石柱称作 S1 和 S2 ，荷叶叫 y，考虑先将 L上的青蛙的一半借助于 S2和 y转移到 S1上，当然是一半小号的青蛙在S1上，大的留在 L上。

yL R

S1 S2



这样 L S1 S2 y R 系统分解为：（ L S2 y R 系统） + （ S1 S2 y R 系统）= 2 * （ L S2 y R 系统）= 2 * Jump(1,1)用归纳法Jump(S, y)=2*Jump(S-1, y)



main() { int s,y,sum; //整型变量 ,s 为河中石柱数 ,y为荷叶数 printf("请输入石柱数 s=" ); scanf("%d",&s); printf("请输入荷叶数 y=" ); scanf("%d",&y); sum=Jump(s,y); //Jump(s,y) 为被调用函数 printf(“Jump(%d,%d)=%d\n”,s,y,sum);}int Jump(int r,int z) { int k;if (r==0) {k=z+1; } else{k=2*Jump(r-1,z);} return(k); }



指针是 C语言中的一个重要概念。掌握指针的用法，可使程序简洁、高效、灵活，但并不难学。为了了解什么是指针，先看一个小故事地下工作者阿金接到上级指令，要去寻找打开密电码的密钥，这是一个整数。几经周折，才探知如下线索，密钥藏在一栋三年前就被贴上封条的小楼中。一个风雨交加的夜晚，阿金潜入了小楼，房间很多，不知该进哪一间，正在一筹莫展之际，忽然走廊上的电话铃声响起。艺高人胆大，阿金毫不迟疑，抓起听筒，只听一个陌生人说：“去打开 211房间，那里有线索”。阿金疾步上楼，打开 211房间，用电筒一照，只见桌上赫然 6个大字：地址 1000 。阿金眼睛一亮，迅速找到 1000房间，取出重要数据 66，完成了任务。

第七讲指针


211 1000

P

说明： 1 、数据藏在一个内存地址单元中，地址是 1000 。 2 、地址 1000又由 P单元所指认， P单元的地址为 211 。 3 、 66 的直接地址是 1000 ； 66 的间接地址是 211 ； 211 中存的是直接地址 1000 。 4 、称 P为指针变量， 1000 是指针变量的值，实际上是有用数据藏在存储器中的地址。

1000 66

第七讲指针


指针变量——用来存放另一变量地址的变量变量的指针就是变量的地址。 1、指针的概念指针是一种特殊的变量，特殊性表现在类型和值上。从变量讲，指针也具有变量的三个要素：（ 1）变量名，这与一般变量取名相同，由英文字符开始。（ 2）指针变量的类型，是指针所指向的变量的类型，而不是自身的类型。（ 3）指针的值是某个变量的内存地址。

第七讲指针


从上面的概念可知，指针本身类型是 int 型，因为任何内存地址都是整型的。但是指针变量的类型却定义成它所指向的变量的类型。 2、指针的定义（说明，先说明后引用）例如： int *p, *q; // 定义 p,q为指向整数类型变量的指针 float *point; // 定义 point 为指向 float 型变量的指针double *pd; // 定义 pd 为指向 double 型变量的指针 int (*pa)[10];// 定义 pa 为指向 int 型数组的指针 int (*pu)(); // 定义 pu 为指向 int 型函数的指针 int **qq; // 定义 qq为指向 int 型指针的指针还有指向结构、联合的指针，后面再介绍

第七讲指针


3 、指针赋值例 int akey; // 定义一个整型变量 akey int *p,*q; // 定义 p,q为指向整型变量的指针变量 akey=66; // 将 66 赋给 akey p = &akey; // 将变量 akey的地址赋给 p ，这时见图 1 q = p; // 将 p的值赋给 q，见图 2

66&akey

p akey

&p

p变量的地址&akey

akey变量的地址

图 1的说明：将akey变量的地址赋给指针 p，意味着让指针p 指向 akey

图 1

第七讲指针

C 语言程序设计第七讲指针66&a

p a

pq

图 2 的说明：当着执行q=p;之后，中所存的a 变量的地址值，也就被放到变量中，意味着让指针 q 也指向a

图 2

&a

q

&p

&q

q=p;


#include <stdio.h>void main(){ int a[5]={0,1,2,3,4}; // 定义数组，赋初值 int *p1,*p2; // 定义指针变量 p1=&a[1]; // 赋值给指针变量，让 p1 指向 a[1] p2=&a[2]; // 赋值给指针变量，让 p2指向 a[2]printf("a[1]=%d;a[2]=%d\n",*p1,*p2); }

第七讲指针


43210&a[0]&a[0] &a[1]&a[1] &a[2]&a[2] &a[3]&a[3] &a[4]&a[4]

&a[1] &a[2]

&p1 &p2

p1 p2

p1 和 p2 分别指向 a[1],a[2]，这里 & —— 取地址运算符 * —— 指针运算符（间接访问运算符） *p1——间接访问 p1所指向的内存单元，当然是输出 a[1]的值 *p2——间接访问 p2所指向的内存单元，当然是输出 a[2]的值

第七讲指针


4 、向指针所指向的内存单元赋值void main(){ int akey,b;int *p,*q; akey=66; p=&akey; q=&b; *q=*p; printf(“b=%d\n”,b); printf(“*q=%d\n”,*q); }

第七讲指针


66

66

&akey

p

&akey *q=*p

&b

q

&b

第七讲指针


5 、指针与数组void main() { int a[5]={1,3,5,7,9}; int *p; int i; p=a; for(i=0;i<5;i=i+1)

{printf("a[%d]=%d\n",i,*p); p=p+1; } }

第七讲指针


说明 (1) p=a; 这里数组名作为数组的起始地址，即 a[0]的地址。因此 p=a 等效于 p=&a[0]; (2) p=p+1; 如 p指向 a[0], 则 p=p+1 之后， p指向 a[1] (3) 如果 p=a 等效于 p=&a[0];则 p=a+4 等效于 p=&a[4];

a[5]a[5]a[4]a[4]a[3]a[3]a[2]a[2]a[1]a[1]

*(p+3)*(p+3)*(p+4)*(p+4)

*(p+2)*(p+2)*(p+1)*(p+1)

*p*pp

p+1

p+2

p

p+1

p+2

等效

第七讲指针


void main() { int a[5]={1,3,5,7,9}; int *p; int i=0; for(p=a;p<a+5;p=p+1) {

printf("a[%d]=%d\n",i,*p); i=i+1; } }

第七讲指针


数组名是一个常量指针，指向该数组的首地址，例void main() { char *p; static char s[] = “abcdefgh”; p=s; while (*p != ‘\0’) { p=p+1; } printf(“字串长度为 %d\n”,p-s); }

第七讲指针


\0\0hhggffeeddccbbaas

s p

图中数组的首地址是 s[0]的地址，即 &s[0]。 s可看作是指向 s[0]的指针。 s是不会动的，是常量指针。

第七讲指针


任务：我们要作一张登记表，登记排队求职信息，包括：姓名、年龄、性别、电话四个参数。希望便于管理，即可以插入和删除，这时可采用结构类型变量。 struct ST { char name[20];// 字符串，姓名 int age; // 整数，年龄 char sex; // 字符，性别 long num; // 电话号码 }; // 注意，这里必须有分号struct ST student1,student2 ;

第八讲结构体


在定义一个结构体类型时，可以用另一个结构类型来定义其中的成员，即可以嵌套定义。例： struct date { int month; int day; int year; }; struct person { char name[10]; struct date birthday; long certificate; };

第八讲结构体


结构体类型变量的引用引用方式：结构体变量．成员名对成员变量可以像普通变量一样使用，进行各种运算。即： worker ． name 、 worker ． birthday 、 worker ． certificate

第八讲结构体


结构指针设一个指针变量，用来指向一个结构体变量，此时该变量的值是结构体变量的起始地址。即：结构指针就是对已经定义的结构变量的一个起始地址例：main (){ struct student { long int num; char name[20]; char sex; float score; };

第八讲结构体


struct student stu_1; struct student *p; p=&stu_1; stu_1.num=10001; strcpy(stu_1.name,"Li Lin"); stu_1.sex='M'; stu_1.score=92.5; printf("No.:%ld\n name:%s\n sex:%c\n score:%4.1f\n",

stu_1.num,stu_1.name,stu_1.sex,stu_1.score); printf("\n No.:%ld\n name:%s\n sex:%c\n score:%4.1f\n",

(*p).num,(*p).name,(*p).sex,(*p).score);}

第八讲结构体


注： C 语言中，为了使用方便和直观，可以把 (*p).num 用 p->num来代替即以下三种形式是等价的： a）结构体变量．成员名 b） (*p) ．成员名 c） p-> 成员名

第八讲结构体


用指针处理链表（ 1）链表的基本概念链表是一种重要的数据结构，主要用以实现对数据的动态存储，链表中包含若干个结点 ( 又可称为元素 ) ，每个结点包含的数据有两部分：一是用户的实际数据，二是下个结点的地址信息，这样，结点都按这个原则“连接”起来，在这种链式结构中，每个结点只有一个“前驱”和一个“后继”，所以，只要知道链中第一个结点的地址，就可以遍访链中的其他结点。

第八讲结构体


头指针：存储第一个结点的指针变量（ *head）表头：由头指针指向的结点，有后继而无前驱表尾：表的最后一个结点，有前驱而无后继，其下一个的地址信息为空（ NULL）结点的表述：以结构体变量描述： struct student { int num; int score; struct student *next; };

第八讲结构体

C 语言程序设计第八讲结构体

40 1 10 2 20

3 15 4 NULL

头指针 head

数据指针

首地址 40 首地址 10

首地址 20 首地址 15

如下所示为典型的单链表结构：


55head 66

1010

nullnull

1515121288

链表的建立例子：已有一个如图所示的链表。它是按结点中的整数域从小到大排序的。现在要插入一个结点，该节点中的数为 10。

待插入结点p

第八讲结构体


分析：考虑将结点 p插入链表 head 中，分如下三种情况：1 、第一种情况，链表还未建成（空链表），待插入结点 p实际上是第一个结点。这时必然有 head==null 。只要让头指针指向 p就可以了。语句为head = p; p->next = null;2 、第二种情况，链表已建成，待插入结点 p的数据要比头结点的数据还要小，这时有 p->num <head->num 。当然 p 结点要插在 head 结点前。3、第三种情况，链表已建成，待插入结点 p的数据比头结点的数据大，需要找到正确的插入位置。这时，可以借助两个结构指针 r和 q，利用循环比较来找到正确位置。然后将结点 p插入到链表中正确的位置。

第八讲结构体


66head

88 1212

nullnull

1313p

1515

qr

说明：这种情况下， p结点已经与链表的第一个结点比较过了，所以从链表的下一个结点开始比较。 13>8 ，继续比较。

第八讲结构体


说明： 13>12 ，继续比较。

66head

88 1212

nullnull

1313p

nullnull

1515

qr第八讲结构体


说明：13<15 ，找到了正确的插入位置，则插入结点 p。语句为： r->next = p; p->next = q;

66head

88 1212

1313p

nullnull

1515

qr第八讲结构体


#include <stdio.h> // 预编译命令 #include <malloc.h> // 内存空间分配 #define null 0 // 定义空指针常量 #define LEN sizeof(struct numST) struct numST { int num; struct numST *next; };

第八讲结构体


// 被调用函数 insert() ，两个形参分别表示链表和待插入的结点 void insert (struct numST **phead, struct numST *p) { struct numST *q,*r; if ((*phead)==null) // 第一种情况，链表为空 { *phead = p; // 链表头指向 p return; // 完成插入操作，返回 } else // 链表不为空 { // 第二种情况， p结点 num值小于链表头结点的 num值 if ( (*phead)->num > p->num){ // 将 p结点插到链表头部 p->next = *phead;// 将 p的 next指针指向链表头 (*phead) *phead = p; // 将链表头赋值为 p return; // 返回 }

第八讲结构体


// 第三种情况，循环查找正确位置 r = *phead; // r 赋值为链表头 q = (*phead)->next; // q赋值为链表的下一个结点 while (q!=null) // 利用循环查找正确位置 { // 判断当前结点 num 是否小于 p结点的 num if (q->num < p->num) {r = q; // r 赋值为 q，即指向 q所指的结点 q = q->next;// q指向链表中相邻的下一个结点 } else // 找到了正确的位置 break; // 退出循环 } // 将 p结点插入正确的位置 r->next = p; p->next = q; } }

第八讲结构体


void main() // 主函数开始 { // 函数体开始 struct numST *head, *p; // ST型结构指针 head = null;// 分配两个 ST结构的内存空间，用于构造链表 head = (struct numST *) malloc(LEN); head->next = (struct numST *) malloc(LEN); // 为链表中的两个结点中的 num 赋值为 5和 10 head->num = 5; head->next->num = 10; head->next->next = null; // 链表尾赋值为空 // 构造一个结点 p，用于插入链表 p = (struct numST *) malloc(LEN); p->num = 8; p->next = null; insert(&head, p);}

第八讲结构体


动态地开辟和释放存储单元的函数 malloc( size ) ——在内存的动态存储区中分配一个长度为 size 的连续空间。此函数值是一个指向分配域起始地址的指针。 calloc( n, size ) ——在内存的动态存储区中分配n 个长度为 size 的连续空间此函数值是一个指向分配域起始地址的指针。 free( ptr ) —— 释放由 ptr指向的内存区。 ptr 是最近一次调用 calloc或 malloc 函数时返回的值（指针）

第八讲结构体


例： a ） p=(float *)malloc(4); 开辟 4个字节的存储空间，并把此地址赋给指针 p b ） new=(struct work *)malloc(struct work); 开辟一个能容纳结构变量 work 的空间，并把这个空间的首地址赋给结构指针 new

第八讲结构体

一、教学对象 计算机科学与技术系新生 ( 第二学期） 二、教学目标...

Documents

一、教学对象计算机科学与技术系新生 ( 第二学期）二、教学目标...