啊哈，复活！

本文属于自用笔记，假如对于你有帮助的话，鄙人万分荣幸。若有补充，请在评论区留言~

第三章 算法

1、顺序程序设计举例

【例1】计算存款利息。有1000元，想存一年。有3种方法可选

①活期，年利率为r1；
②一年期定期，年利率为r2；
③存两次半年定期，年利率为r3。
请分别计算出一年后按3种方法所得到的本息和。

解题思路

关键是确定计算本息和的公式。从数学知识可知，若存款额为p0，则:

活期存款一年后本息和为：p1=p0(1+r1)

一年期定期存款，一年后本息和为：p2=p0(1+r2)

两次半年定期存款，一年后本息和为：p3=p0(1+r3/2)(1+r3/2)

N-S流程图

1
2
3
4
5
6
7
8
9
10

#include <stdio.h>
int main ()
{	
	float p0=1000, r1=0.0036, r2=0.0225, r3=0.0198, p1, p2, p3;	//定义变量
	p1=p0*(1+r1);											//计算活期本息和
	p2=p0*(1+r2);											//计算一年定期本息和
	p3=p0*(1+r3/2)*(1+r3/2);								 //计算存两次半年定期的本息和
	printf("p1=%f\np2=%f\np3=%f\n",p1, p2, p3);				   //输出结果
	return 0;
}

2、数据的表现形式

常量

在程序运行过程中，其值不能被改变的量。

指数形式：由于在计算机输入或输出时无法表示上角或下角，故规定以字母e或E代表以10为底的指数。但应注意: e或E之前必须有数字，且e或E后面必须为整数。如不能写成e4，12e2.5。

普通字符：用单撇号括起来的一个字符。

转义字符：C语言还允许用一种特殊形式的字符常量，就是以字符“\”开头的字符序列。这是一种在屏幕上无法显示的“控制字符”。

字符串常量：用双引号把若干个字符括起来，字符串常量是双引号中的全部字符(但不包括双引号本身)。

符号常量：用#define指令，指定用一个符号名称代表一个常量。

变量

在程序运行过程中，其值是可以改变的量。

变量代表内存中具有特定属性的一个存储单元，它用来存放数据，也就是存放变量的值。
在程序运行期间，这些值是可以改变的。
一个变量应该有一个名字，以便被引用。
变量必须先定义，后使用。

类型名 变量名;

类型名 变量名=初值;

1
2

int a,b,c;					//定义a,b,c为整型变量
float m=3.5,n=-7.8,p;		 //定义m,n,p为浮点型变量并对m和n指定初值

常变量

1

Const int a=3

定义a为一个整型变量，指定其值为3，而且在变量存在期间其值不能改变

常变量与常量的异同是: 常变量具有变量的基本属性: 有类型，占存储单元，只是不允许改变其值。可以说，常变量是有名字的不变量，而常量是没有名字的不变量。有名字就便于在程序中被引用。

1
2

#define Pi 3.1415926		//定义符号常量
const float pi=3.1415926;	//定义常变量

标识符

标识符就是一个对象的名字。用于标识变量、符号常量、函数、数组、类型等

标识符只能由字母、数字和下划线3种字符组成，且第1个字符必须为字母或下划线

C语言中的关键字

• 变量名中区分大小写字母
• 不能使用关键字作为变量名
• 变量的名字应该尽量反映变量在程序中的作用与含义

3、C语言中数据的分类

C语言的数据类型

• 基本整型 int

• 短整型 short int

• 长整型 long int

• *双长整型 long long int

• 字符型 char

• *布尔型 bool

• 单精度浮点型 float

• 双精度浮点型 double

• 复数浮点型 float_complex,double_complex,long long _complex

整型数据

整型数据的分类

C标准没有具体规定各种类型数据所占用存储单元的长度，只要求sizeof(short) ≤ sizeof(int) ≤ sizeof(long) ≤ sizeof(long long)，具体由各编译系统自行决定的。

sizeof是测量类型或变量长度的运算符。

整型变量的符号属性

只有整型(包括字符型)数据可以加signed或unsigned修饰符，实型数据不能加。

对无符号整型数据用“%u”格式输出。%u表示用无符号十进制数的格式输出。如:

1
2

unsigned short price=50;	//定义price为无符号短整型变量
printf("%u\n",price); 	//指定用无符号十进制数的格式输出

在将一个变量定义为无符号整型后，不应向它赋予一个负值，否则会得到错误的结果。如:

1
2

unsigned short price = -1;	//不能把一个负整数存储在无符号变量中
printf("%d\n",price);

整型数据运算程序举例

【例2】任务要求：解“鸡兔同笼”问题。在一个笼子里同时养着一些鸡和兔子，你想了解有多少只鸡和多少只兔，主人对你说：我只告诉你鸡和兔的总头数是16，总脚数是40，你能不能自己计算有多少只鸡和多少只兔。

1
2
3
4
5
6
7
8
9
10
11

#include <stdio.h>
int main()
{ 
    int h,f,x,y;			  // 定义整型变量h,f,x,y  
  	h=16; 					 // 对整型变量h赋值，使h的值等于16  
  	f=40; 					 // 对整型变量f赋值，使h的值等于40   
  	y=(f-2* h)/2;			  // 对表达式(f-2* h)/2进行运算，把结果赋给y  
  	x=h-y; 					 // 对表达式h-y进行运算，把结果赋给x  
  	printf("%d,%d\n",x,y); 	  // 输出鸡的个数和兔的个数 
  	return 0; 
}

字符型数据

ASCII字符集

C语言的字符常量是用单撇号括起来的一个字符。

包括：

• 字母: 大写英文字母AZ，小写英文字母az

• 数字: 0～9

• 专门符号: 29个,包括 ! “ # & ‘ ( ) * + , - . / : ; < = > ? [ \ ] ^ _ ` { | } ~

• 空格符: 空格、水平制表符(tab)、垂直制表符、换行、换页(form feed)

• 不能显示的字符:换行(以‘\n’表示)、空(null)字符(以‘\0’表示)、制表符(以‘\t’表示)、警告(以’\a’表示)、退格(以’\b’表示)、回车(以’\r’表示)等

字符′1′和整数1是不同的概念。

字符′1′只是代表一个形状为′1′的符号，在需要时按原样输出，在内存中以ASCII码形式存储，占1个字节。

字符型数据的存储空间和值的范围

在使用有符号字符型变量时，允许存储的值为-128～127，但字符的代码不可能为负值，所以在存储字符时实际上只用到0～127这一部分，其第1位都是0。

如果将一个负整数赋给有符号字符型变量是合法的，但它不代表一个字符，而作为一字节整型变量存储负整数。

字符变量

字符型变量用来存放字符常量，它只能存放一个字符。

1
2
3
4

char c1,c2;	//定义c1和c2为字符型变量，在其中可以存放一个字符。
c1='a';
c2='b';
//将字符常量放到字符变量中，实际上并不是把该字符本身放到变量的内存单元中，而是将该字符对应的ASCII代码放到变量的存储单元中。可以把字符变量看成只有一个字节的整型变量。

字符数据的运算例子

【例3】任务要求：逐个输出英文字母C,H,I,N,A。然后按反序输出，即A,N,I,H,C。

1
2
3
4
5
6
7
8

#include <stdio.h>
int main()
{ 
    char a='C',b='H',c='I',d='N',e='A';	// a,b,c,d,e定义为字符变量并赋初值  
  	printf("%c%c%c%c%c\n",a,b,c,d,e);	// 顺序输出CHINA  
  	printf("%c%c%c%c%c\n",e,d,c,b,a);	// 反序输出CHINA  
  	return 0;
 }

字符型数据和整型数据之间可以通用

字符型数据和整型数据在一定条件下是可以通用的，条件：整数在0到127范围内

1

char c='a';	//将字符常量’a’赋给字符变量c

等同于

1

char c=97;	//将’a’的ASCII代码赋给字符变量c

【例4】任务要求：将一个整数分别赋给两个字符变量，将这两个字符变量分别以字符形式和整数形式输出。

1
2
3
4
5
6
7
8

#include <stdio.h>
int main()
{	
    char c1=97,c2=98; 	// 将’a’和’b’的ASCII码分别赋给字符变量c1,c2  
	printf("%c %c\n",c1,c2);	// 字符数据按字符形式输出 
	printf("%d %d\n",c1,c2);	// 字符数据按整数形式输出  
	return 0;
} 

【例5】任务要求：将小写字母a和b转换为大写字母A和B。

1
2
3
4
5
6
7
8
9

#include<stdio.h>
int main()
{
	char c1='a',c2='b';
	c1=c1-32;	//将c1的ASCII代码减32
	c2=c2-32;	//将c2的ASCII代码减32
	printf("%c,%c\n",c1,c2);	//以字符形式输出c1和c2 
	return 0;
}

浮点型数据

实型数据的分类

实型常量的表示形式

1
2

a=3.14159;		// 十进制小数形式  
a=0.314159e1; 	// 指数形式

① 十进制小数形式。它由数字和小数点组成( 注意必须有小数点)。0.123, 123.23, 0.0都是十进制小数形式，而10,-50在C语言中不属于实型常量，而是整型常量。

② 指数形式。 在数学上，类似123×103 这样形式的数称为指数形式。在计算机的字符中无法表示上角和下角，所以用字母e和E代表以10为底的指数。如用123e3或123E3代表123×103 。

e3, 2.1e3.5,.e3, 2e都不是合法的指数形式。

字母e(或E)之前必须有数字，且e后面的指数必须为整数

实型数据的存储形式

由于小数点位置可以浮动，所以实数的指数形式称为浮点数。

浮点数类型包括float(单精度浮点型)、double(双精度浮点型)、long double(长双精度浮点型)。

实际上在计算机中是用二进制数来表示小数部分，用2的幂次（二进制）来表示指数部分的。

实数一律采用标准化指数存储形式进行存储，所谓标准化指数存储方式是指这样的形式：其数值部分是一个小数，小数点前的数字是零，小数点后的第一位数字不是零。

由于用二进制形式表示一个实数以及存储单元的长度是有限的，因此不可能得到完全精确的值，只能存储成有限的精确度。小数部分占的位（bit）数愈多，数的有效数字愈多，精度也就愈高。指数部分占的位数愈多，则能表示的数值范围愈大。

4、运算符和表达式

自增（++）自减（–）运算符

++i是先执行i=i+1，再使用i的值；而i++是先使用i的值，再执行i=i+1。

自增运算符（++）和自减运算符（–）只能用于变量，而不能用于常量或表达式。

建议谨慎使用++和–运算符，只用最简单的形式，即i++，i–，且把它们作为单独的表达式。

强制类型转换

1
2
3
4
5
6
7
8

(double)a		将ａ转换成double型
(int)(x+y)		将x+y的值转换成int型
(float)(5%3)		将5%3的值转换成float型
(int)x+y		只将x转换成整型，然后与y相加

int a; float x,y;double b;
a=(int)x
进行强制类型运算(int)x后得到一个int类型的临时值，它的值等于ｘ的整数部分，把它赋给a，注意x的值和类型都未变化，仍为float型。该临时值在赋值后就不再存在了。

5、C语句

C语句分类

控制语句

① if()…else…（条件语句）

② for()…（循环语句）

③ while()…（循环语句）

④ do…while ()（循环语句）

⑤ continue（结束本次循环语句）

⑥ break（中止执行switch或循环语句）

⑦ switch（多分支选择语句）

⑧ return（从函数返回语句）

⑨ goto（转向语句，在结构化程序中基本不用goto语句）

()表示括号中是一个判别条件

…表示内嵌的语句

函数调用语句

函数调用语句由一个函数调用加一个分号构成。

1

printf("This is a C statement. ");

其中printf(“This is a C statement. “)是一个函数调用，加一个分号成为一个语句。

表达式语句

表达式语句由一个表达式加一个分号构成，最典型的是由赋值表达式构成一个赋值语句。

例如：a=3是一个赋值表达式，而a=3;是一个赋值语句。

空语句

1

;

只有一个分号的语句即为空语句。

可以用来作为流程的转向点(流程从程序其他地方转到此语句处)；

也可用来作为循环语句中的循环体（循环体是空语句，表示循环体什么也不做）。

复合语句

可以用{}把一些语句和声明括起来成为复合语句(又称语句块)。

1
2
3
4
5
6
7
8
9

{

 float pi=3.14159, r=2.5, area; //定义变量

 area=pi*r*r;

 printf("area=%f",area);

}

复合语句常用在if语句或循环中，此时程序需要连续执行一组语句。

复合语句中最后一个语句末尾的分号不能忽略不写。

【例5】给出三角形的三边长，求三角形面积。

解题思路

假设给定的三个边符合构成三角形的条件: 任意两边之和大于第三边。

从数学知识已知求三角形面积的公式为：area=√(“s(s-a)(s-b)(s-c)” )，其中s=(a+b+c)/2。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#include <stdio.h>
#include <math.h>
int main ()
 {
	double a,b,c,s,area;			//定义各变量，均为double型 
	a=3.67;							//对边长a赋值 
	b=5.43;							//对边长b赋值 
	c=6.21;							//对边长c赋值
	s=(a+b+c)/2; 						//计算s 
	area=sqrt(s*(s-a)*(s-b)*(s-c));		//计算area 
	printf("a=%f\tb=%f\t%f\n",a,b,c); 	//输出三边a,b,c的值 
	printf("area=%f\n",area);			//输出面积area的值
	return 0;
 }

6、数据的输入输出

举例

【例6】求ax2+bx+c=0方程的根。a,b,c由键盘输入，设b2-4ac＞0。

1
2
3
4
5
6
7
8
9
10
11
12
13

#include <stdio.h>
#include<math.h>						//程序中要调用求平方根函数sqrt
int main() 
{	double a,b,c,disc,x1,x2,p,q;			//disc用来存放判别式(bb-4ac)的值
	scanf("%lf%lf%lf",&a,&b,&c);			//输入双精度型变量的值要用格式声明″%lf″
	disc=b*b-4*a*c;
	p=-b/(2.0*a);
	q=sqrt(disc)/(2.0*a);
	x1=p+q;x2=p-q; 						//求出方程的两个根
	printf("x1=%7.2f\nx2=%7.2f\n",x1,x2);	//输出方程的两个根
	return 0;
}

scanf函数用于输入a,b,c的值。

函数中括号内变量a,b,c的前面，要用地址符**&**。&a表示变量a在内存中的地址。

双引号内用**%lf格式声明，表示输入的是双精度**型实数。

格式声明为“%lf%lf%lf”，要求输入3个双精度实数。程序运行时，输入“1 3 2”，两个数之间用空格分开。输入的虽是整数，但由于指定用%lf格式输入，因此系统会先把这3个整数转换成实数1.0,3.0,2.0，然后赋给变量a,b,c。

在printf函数中，在格式符f的前面加了“7.2”，表示在输出x1和x2时，指定数据占7列，其中小数占2列。优点：

①可以根据实际需要来输出小数的位数；

②如果输出多个数据，可使输出数据整齐美观。

printf格式输出函数

printf(格式控制，输出表列)

“格式控制”是用双引号括起来的一个字符串，称为格式控制字符串，简称格式字符串。包括：

​ ① 格式声明。格式声明由“%”和格式字符组成。作用是将输出的数据转换为指定的格式后输出。

​ ② 普通字符。普通字符即需要在输出时原样输出的字符。

输出表列是程序需要输出的一些数据，可以是常量、变量或表达式。

1

printf("i=%d,c=%c\n", i, c )

printf函数的一般形式可表示为

printf(参数1, 参数2, 参数3, ……,参数n)

参数1是格式控制字符串，参数2参数n是需要输出的数据。执行printf函数时，将参数2参数n按参数1指定的格式输出。

scanf格式输入函数

scanf（格式控制，地址表列）

“格式控制”是用双引号括起来的一个字符串，含义同printf函数。包括：

​ ① 格式声明。以%开始，以一个格式字符结束，中间可以插入附加的字符。

​ ② 普通字符。

地址表列是由若干个地址组成的表列，可以是变量的地址，或字符串的首地址。

1

scanf("a=%f,b=%f,c=%f", &a, &b, &c );

【例7】任务要求：用scanf函数输入数据，并输出这些数据。

1
2
3
4
5
6
7
8
9

#include <stdio.h>
int main ( )                 
{	int a,b,c;
	scanf("%d%d%d",&a,&b,&c); 	// 输入a,b,c的值
					// “&”是“地址运算符”，&a指变量a在内存中的地址
	printf("a=%d,b=%d,c=%d\n",a,b,c);
	return 0;
}

字符数据的输入输出

putchar函数

1

putchar(c)

【例8】先后输出BOY三个字符。

1
2
3
4
5
6
7
8
9
10
11

#include <stdio.h>
int main()
{
	char a='B',b='O',c='Y';		//定义3个字符变量并初始化
	putchar(a);				//向显示器输出字符B
	putchar(b);				//向显示器输出字符O
	putchar(c);				//向显示器输出字符Y
	putchar ('\n');			//向显示器输出一个换行符
	return 0;
}

用putchar函数既可以输出可显示字符，也可以输出控制字符和转义字符。

putchar(c)中的c可以是字符常量、整型常量、字符变量或整型变量(其值在字符的ASCII代码范围内)。

getchar函数

1

getchar()

【例9】任务要求：用getchar函数输入B,O,Y三个字符，并用putchar函数输出到屏幕上。

1
2
3
4
5
6
7
8
9
10
11
12

#include <stdio.h>
int main()
{	char a,b,c;	//定义字符变量a,b,c
	a=getchar();	//从键盘输入一个字符，送给字符变量a
	b=getchar();	//从键盘输入一个字符，送给字符变量b
	c=getchar();	//从键盘输入一个字符，送给字符变量c
	putchar(a); 	//将变量a的值输出
	putchar(b); 	//将变量b的值输出 
	putchar(c); 	//将变量c的值输出
	putchar('\n');//换行
	return 0;
}

函数没有参数。

函数的值就是从输入设备得到的字符。

只能接收一个字符。

如果想输入多个字符就要用多个getchar函数。

不仅可以从输入设备获得一个可显示的字符，而且可以获得控制字符。

用getchar函数得到的字符可以赋给一个字符变量或整型变量，也可以作为表达式的一部分。

【例10】从键盘输入一个大写字母，在显示屏上显示对应的小写字母。

1
2
3
4
5
6
7
8
9

#include <stdio.h>
int main()
{
	char c1,c2;
	c1=getchar();	//从键盘读入一个大写字母，赋给字符变量c1
	c2=c1+32;	//得到对应的小写字母的ASCII代码，放在字符变量c2中
	printf("大写字母: %c\n小写字母: %c\n",c1,c2);	//输出c1,c2的值
	return 0;
}