null第十一章第十一章 本章要点 本章要点结构体的概念
结构体的定义和引用
结构体数组 主要内容 主要内容11.1 概述
11.2 定义结构体类型变量的方法
11.3 结构体变量的引用
11.4 结构体变量的初始化
11.5 结构体数组
11.６指向结构体类型数据的指针
11.7 用指针处理链
表
关于同志近三年现实表现材料材料类招标技术评分表图表与交易pdf视力表打印pdf用图表说话 pdf
11.8 共用体
11.9 枚举类型
11.10 用typedef定义类型
§11.1 概述 §11.1 概述问题定义：
有时需要将不同类型的数据组合成一个有机
的整体，以便于引用。如：
一个学生有学号/姓名/性别/年龄/地址等属性 int num; char name[20]; char sex;
int age; int char addr[30];
应当把它们组织成一个组合项，在一个组合
项中包含若干个类型不同（当然也可以相同）
的数据项。
§11.1 概述§11.1 概述 声明一个结构体类型的一般形式为：
struct 结构体名
｛成员表列｝；
如：struct student
{
int num;char name[20];char sex;
int age;float score;char addr[30];
}
结构体名类型名成员名 §11.2 定义结构体类型变量的方法 §11.2 定义结构体类型变量的方法 可以采取以下3种方法定义结构体类型变量：
(1)先声明结构体类型再定义变量名
例如：struct student student1, student2;
| | |
结构体类型名 结构体变量名
定义了student1和student2为struct student类型的变量，即它们具有struct student类型的结构.
§11.2 定义结构体类型变量的方法 §11.2 定义结构体类型变量的方法 在定义了结构体变量后，系统会为之分配内存单元。
例如:student1和student2在内存中各占59个字节（2+20+1+2+4+30=59）。
注意：
将一个变量定义为标准类型（基本数据类型）与定义为结构体类型不同之处在于后者不仅要求指定变量为结构体类型，而且要求指定为某一特定的结构体类型，因为可以定义出许许多多种具体的结构体类型。 §11.2 定义结构体类型变量的方法 §11.2 定义结构体类型变量的方法(2)在声明类型的同时定义变量
这种形式的定义的一般形式为:
struct 结构体名
｛
成员表列
｝变量名表列；
§11.2 定义结构体类型变量的方法 §11.2 定义结构体类型变量的方法例如：
struct student
｛ int num；
char name[20]；
char sex；
int age；
float score；
char addr[30]；
｝student1,student2;
它的作用与第一种方法相同，即定义了两个struct student 类型的变量student1,
student2 §11.2 定义结构体类型变量的方法§11.2 定义结构体类型变量的方法(3) 直接定义结构体类型变量
其一般形式为:
struct
｛
成员表列
｝变量名表列；
即不出现结构体名。 注意：
(1) 类型与变量是不同的概念，不要混同。只能对变量赋值、存取或运算，而不能对一个类型赋值、存取或运算。在编译时，对类型是不分配空间的，只对变量分配空间。注意：
(2)对结构体中的成员（即“域”），可以单独使用，它的作用与地位相当于普通变量。
(3)成员也可以是一个结构体变量。
(4) 成员名可以与程序中的变量名相同,二者不代表同一对象。 §11.2 定义结构体类型变量的方法 §11.2 定义结构体类型变量的方法例如：struct date /*声明一个结构体类型*/
int num；
char name[20]；
char sex；
int age；
float score；
struct date birthday；
/*birthday是struct date类型*/
char addr[30]；
｝student1,student2;先声明一个struct date类型，它代表“日期”，包括3个成员：month（月）、day（日）、year（年）。然后在声明struct student类型时，将成员birthday指定为struct date类型。 §11.3结构体变量的引用 §11.3结构体变量的引用 在定义了结构体变量以后,当然可以引用这个变量。但应遵守以下规则:
(1)不能将一个结构体变量作为一个整体进行输入和输出。
例如: 已定义student1和student2为结构体变量并且它们已有值。
printf(″%d,%s,%c,%d,%f,%＼n″,student1);
§11.3结构体变量的引用 §11.3结构体变量的引用引用结构体变量中成员的方式为
结构体变量名.成员名
例如， student1.num表示student1变量中的num成员,即student1的num(学号)项。可以对变量的成员赋值,例如:student1.num=10010;“.”是成员(分量)运算符,它在所有的运算符中优先级最高,因此可以把student1.num作为一个整体来看待。上面赋值语句的作用是将整数10010赋给student1变量中的成员num。
§11.3结构体变量的引用 §11.3结构体变量的引用(2) 如果成员本身又属一个结构体类型,则要用若干个成员运算符,一级一级地找到最低的一级的成员。只能对最低级的成员进行赋值或存取以及运算。
例如: 对上面定义的结构体变量student1, 可以这样访问各成员:
student1.num
student1.birthday.month注意：
不能用student1.birthday来访问student1变量中的成员birthday,因为birthday本身是一个结构体变量。 §11.3结构体变量的引用 §11.3结构体变量的引用(3) 对结构体变量的成员可以像普通变量一样进行各种运算（根据其类型决定可以进行的运算）。
例如：
student2.score=student1.score;
sum=student1.score+student2.score;
student1.age++;
++student2.age;
由于“．”运算符的优先级最高，因此ｓｔｕｄｅｎｔ１．ａｇｅ＋＋是对ｓｔｕｄｅｎｔ１．ａｇｅ进行自加运算，而不是先对ａｇｅ进行自加运算。 §11.3结构体变量的引用 §11.3结构体变量的引用(4) 可以引用结构体变量成员的地址，也可以引用结构体变量的地址。
例如：
scanf(″%d″，&student1.num);
（输入student1.num的值）
printf(″%o″，＆student1）；
（输出student1的首地址）
§11.3结构体变量的引用 §11.3结构体变量的引用但不能用以下语句整体读入结构体变量，
例如：
scanf（″%d，％s，％c，％d，％f，％s″，＆student1）；
结构体变量的地址主要用作函数参数，
传递结构体变量的地址。 §11.４结构体变量的初始化 §11.４结构体变量的初始化 但不能用以下语句整体读入结构体变量，
例如：
scanf（″%d，％s，％c，％d，％f，％s″，＆student1）；
结构体变量的地址主要用作函数参数，传递结构体变量的地址。 例11.1 对结构体变量初始化.
#include
void main（）
{struct student
｛long int num；
char name[20];
char sex；
char addr[20]；
｝a={10101，″LiLin″，′M′，″123 Beijing Road″｝； /* 对结构体变量a赋初值*/
printf(″No.:%ld＼nname:%s＼nsex:%c＼naddress:%s＼n″，a.num，a.name，a.sex，a.addr); ｝ 运行结果：
No.：10101
name：LiLin
sex：Ｍ
address：123 Beijing Road §11.5 结构体数组 §11.5 结构体数组 一个结构体变量中可以存放一组数
据（如一个学生的学号、姓名、成绩等
数据）。如果有１０个学生的数据需要
参加运算，显然应该用数组，这就是结
构体数组。结构体数组与以前介绍过的
数值型数组不同之处在于每个数组元素
都是一个结构体类型的数据，它们都分
别包括各个成员（分量）项。 §11.5 结构体数组 §11.5 结构体数组11.5.1定义结构体数组
和定义结构体变量的方法相仿，只需说明其为数组即可。例如：
struct student
{int num;char name[20];char sex;int age;
float score;char addr[30];
};struct student[3];
以上定义了一个数组stu，数组有３个元素，均为struct student类型数据。 §11.5 结构体数组 §11.5 结构体数组也可以直接定义一个结构体数组，例如：
struct student
{int num;
…};stu[3];
或：
strcut student
{int num;
…};stu[3]; §11.5 结构体数组 §11.5 结构体数组11.5.2 结构体数组的初始化
与其他类型的数组一样，对结构体数组可以初始化。例如：
struct student
｛int num;char name[20]； char sex；
int age； float score; char addr[30]；
｝;stu［2］＝{{10101，″LiLin″，′M′，18，87.5，″103 BeijingRoad″｝，｛10102，″Zhang Fun″，′M′，19，99，″130 Shanghai Road″}}； §11.5 结构体数组 §11.5 结构体数组当然，数组的初始化也可以用以下形式：
struct student
｛int num；
…
｝；
struct student str[]{{…},{…},{…}}；
即先声明结构体类型，然后定义数组为该结构体类型，在定义数组时初始化。
结构体数组初始化的一般形式是在定义数组的后面加上“＝｛初值表列｝；”。 §11.5 结构体数组 §11.5 结构体数组11.5.3 结构体数组应用举例例11.2对候选人得票的统计程序。设有3个候选人，每次输入一个得票的候选人的名字，要求最后输出各人得票结果。
#include
#include
struct person
{
char name[20];in count;
};
leader[3]={“Li”,0,”Zhang”,0,”Fun”,0}例11.2
void main()
{ int i,j; char leader_name[20];
for(i=1;i<=10;i++)
{
scanf(“%s”,leader_name);
for(j=0;j<3;j++)
if(strcmp(leader_name,leader[j].name)==0)
leader[j].count++;
}
printf(“\n”);
for(i=0;i<3;i++) printf(“%5s:%d\n”,leader[i].name,leader[i].count);}例11.2
void main()
{ int i,j; char leader_name[20];
for(i=1;i<=10;i++)
{
scanf(“%s”,leader_name);
for(j=0;j<3;j++)
if(strcmp(leader_name,leader[j].name)==0)
leader[j].count++;
}
printf(“\n”);
for(i=0;i<3;i++) printf(“%5s:%d\n”,leader[i].name,leader[i].count);}运行结果：
Ｌｉ↙
Ｆｕｎ↙
Ｚｈａｎｇ↙
Ｚｈａｎｇ↙
Ｆｕｎ↙
Ｌｉ↙
Ｆｕｎ↙
Ｚｈａｎｇ↙
Ｌｉ↙
Ｌｉ:４
Ｚｈａｎｇ:３
Ｆｕｎ:３ §11.5 结构体数组 §11.5 结构体数组 程序定义一个全局的结构体数组leader，它有３个元素，每一个元素包含两个成员name（姓名）和count（票数）。在定义数组时使之初始化，使3位候选人的票数都先置零.
在主函数中定义字符数组leader-name，它代表被选人的姓名，在10次循环中每次先输入一个被选人的具体人名，然后把它与3个候选人姓名相比，看它和哪一个候选人的名字相同。在输入和统计结束之后，将3人的名字和得票数输出。 §11.6 指向结构体类型数据的指针 §11.6 指向结构体类型数据的指针 一个结构体变量的指针就是该变量所占据的内存段的起始地址。可以设一个指针变量，用来指向一个结构体变量，此时该指针变量的值是结构体变量的起始地址。指针变量也可以用来指向结构体数组中的元素.
11.6.1 指向结构体变量的指针
下面通过一个简单例子来说明指向结构体变量的指针变量的应用。
例１1．３指向结构体变量的指针的应用
#include
#include
void main()
{struct student{long num;char name[20];
char sex; float score;};
struct student stu_1;
struct student* p; p=&stu_1;
stu_1.num=89101;strcpy(stu_1.name,”LiLin”);
stu_1.sex=‘M’;stu_1.score=89.5;
printf(″No.:%ld＼nname:%s＼nsex:%c＼nscore:%f＼n″，stu-1.num，stu-1.name，stu-1.sex，stu-1.score);
printf(″No.:%ld＼nname:%s＼nsex:%c＼nscore:%f＼n″，(*p).num，(*p).name，(*p).sex，(*p).score);
}例１1．３指向结构体变量的指针的应用
#include
#include
void main()
{struct student{long num;char name[20];
char sex; float score;};
struct student stu_1;
struct student* p; p=&stu_1;
stu_1.num=89101;strcpy(stu_1.name,”LiLin”);
stu_1.sex=‘M’;stu_1.score=89.5;
printf(″No.:%ld＼nname:%s＼nsex:%c＼nscore:%f＼n″，stu-1.num，stu-1.name，stu-1.sex，stu-1.score);
printf(″No.:%ld＼nname:%s＼nsex:%c＼nscore:%f＼n″，(*p).num，(*p).name，(*p).sex，(*p).score);
}定义指针变量p，指向struct student 类型的数据ｐ指向的结构体变量中的成员 运行结果：
Ｎｏ．：89101
name：LiLin
sex：Ｍ
score：89.500000
Ｎｏ．：89101
name：LiLin
sex：Ｍ
score：89.500000
§11.6 指向结构体类型数据的指针 §11.6 指向结构体类型数据的指针 程序分析：
在函数的执行部分将结构体变量ｓｔｕ-１的起始地址赋给指针变量ｐ，也就是使ｐ指向ｓｔｕ-１,然后对ｓｔｕ-１的各成员赋值。第一个ｐｒｉｎｔｆ函数是输出ｓｔｕ-１的各个成员的值。用ｓｔｕ-１．ｎｕｍ表示ｓｔｕ-１中的成员ｎｕｍ，依此类推。第二个ｐｒｉｎｔｆ函数也是用来输出ｓｔｕ-１各成员的值，但使用的是（*ｐ）．ｎｕｍ这样的形式。 §11.6 指向结构体类型数据的指针 §11.6 指向结构体类型数据的指针 以下3种形式等价：
① 结构体变量．成员名
②（*ｐ）．成员名
ｐ->成员名
其中->称为指向运算符。
请分析以下几种运算：
ｐ->ｎ得到ｐ指向的结构体变量中的成员ｎ的值。
ｐ->ｎ＋＋ 得到ｐ指向的结构体变量中的成员ｎ的值，用完该值后使它加１。
＋＋ｐ->ｎ 得到ｐ指向的结构体变量中的成员ｎ的值加１，然后再使用它。 §11.6 指向结构体类型数据的指针 §11.6 指向结构体类型数据的指针 11.6.2 指向结构体数组的指针例11.4 指向结构体数组的指针的应用
#include
struct student
{int num;char name[20];char sex;int age;};
struct student stu[3]=｛｛10101，″Li Lin″，′M′，18｝，｛10102，″Zhang Fun″，′M′，19｝，｛10104，″WangMing″，′F′，20｝｝;
void main()
{ struct student *p;
printf(″ No. Name sex age＼ｎ″）；
for （ｐ＝str；ｐ＜str＋３；p＋＋）
printf(″%5d %-20s %2c %4d＼n″，p->num， p->name， p->sex， p->age);
}运行结果：
Ｎｏ． Ｎａｍｅ ｓｅｘ ａｇｅ
１０１０１ LiLin Ｍ 18
１０１０２ Zhang Fun Ｍ 19
１０１０４ WangMing Ｆ 20 §11.6 指向结构体类型数据的指针 §11.6 指向结构体类型数据的指针 程序分析：
ｐ是指向struct student结构体类型数据的指针变量。在for语句中先使ｐ的初值为stu，也就是数组stu第一个元素的起始地址。在第一次循环中输出stu[0]的各个成员值。然后执行ｐ＋＋，使ｐ自加１。ｐ加１意味着p所增加的值为结构体数组stu的一个元素所占的字节数。执行ｐ++后p的值等于stu ＋1，ｐ指向stu[1]。在第二次循环中输出stu[1]的各成员值。在执行ｐ＋＋后,p的值等于stu+2，再输出stu [2]的各成员值。在执行ｐ++后，ｐ的值变为stu +３， 已不再小于stu+3了，不再执行循环。 §11.6 指向结构体类型数据的指针 §11.6 指向结构体类型数据的指针 注意：
(1) 如果ｐ的初值为stu，即指向第一个元素，则ｐ加１后p就指向下一个元素。例如:
(++p)->num 先使ｐ自加１，然后得到它指向的元素中的num成员值（即10102）。
(p++)->num 先得到ｐ->num的值（即10101），然后使ｐ自加１，指向stu[1]。
请注意以上二者的不同。 §11.6 指向结构体类型数据的指针 §11.6 指向结构体类型数据的指针 注意：
(2) 程序已定义了ｐ是一个指向struct student类型数据的指针变量，它用来指向一个struct student类型的数据,不应用来指向stu数组元素中的某一成员。
例如: ｐ＝ｓｔｕ［1］．ｎaｍｅ;
如果要将某一成员的地址赋给p，可以用强制类型转换，先将成员的地址转换成p的类型。
例如：ｐ＝（ｓｔｒｕｃｔ ｓｔｕｄｅｎｔ *）ｓｔｕ［0］．ｎaｍｅ； §11.6 指向结构体类型数据的指针 §11.6 指向结构体类型数据的指针 11.6.3 用结构体变量和指向结构体的指针
作函数参数
将一个结构体变量的值传递给另一个函数，有3个方法:
用结构体变量的成员作参数。
(2) 用结构体变量作实参。
(3) 用指向结构体变量（或数组）的指针作实参，将结构体变量（或数组）的地址传给形参.
§11.6 指向结构体类型数据的指针 §11.6 指向结构体类型数据的指针 11.6.2 指向结构体数组的指针例11.5 有一个结构体变量stu，内含学生学号、姓名和3门课程的成绩。要求在main函数中赋予值，在另一函数print中将它们输出。今用结构体变量作函数参数。
#include
struct student
{
int num;
char name[20];
float score[3];
};
§11.6 指向结构体类型数据的指针 §11.6 指向结构体类型数据的指针 void main()
{
void print(struct student);
struct student stu;
stu.num=12345;strcpy(stu.name, ″LiLin″;stu.score[0]=67.5;stu.score[1]=89;stu.score[2]
=78.6);
print(stu);
}
void print(struct student stu)
{ printf(FORMAT，stu.num，stu.name， stu.score[0]， stu.score[1]，stu.score[2]）；
printf（″\n″）；}运行结果：
１２３４５
Ｌｉ Ｌｉ
67.500000
89.000000
78.599998例11.6 将上题改用指向结构体变量的指针作实参。 #include
struct student
{
int num;
char name[20];
float score[3];
};stu={12345, ″LiLi″,67.5,89,78.6};
void main()
{void print(struct student *);
/*形参类型修改成指向结构体的指针变量*/
print(&stu);} /*实参改为stu的起始地址*/
void print(struct student *p) /*形参类型修改了*/
{ printf(FORMAT，p->num，p->name，
p->score［0］，p->score［1］，p->score［2］）；
/*用指针变量调用各成员的值*/
printf（″＼ｎ″）；}例11.6 将上题改用指向结构体变量的指针作实参。 #include
struct student
{
int num;
char name[20];
float score[3];
};stu={12345, ″LiLi″,67.5,89,78.6};
void main()
{void print(struct student *);
/*形参类型修改成指向结构体的指针变量*/
print(&stu);} /*实参改为stu的起始地址*/
void print(struct student *p) /*形参类型修改了*/
{ printf(FORMAT，p->num，p->name，
p->score［0］，p->score［1］，p->score［2］）；
/*用指针变量调用各成员的值*/
printf（″＼ｎ″）；}运行结果：
１２３４５
Ｌｉ Ｌｉ
67.500000
89.000000
78.599998 §11.6 指向结构体类型数据的指针 §11.6 指向结构体类型数据的指针 程序分析：
此程序改用在定义结构体变量stu时赋初值，这样程序可简化些。print函数中的形参ｐ被定义为指向struct student类型数据的指针变量。注意在调用print函数时，用结构体变量str的起始地址＆stu作实参。在调用函数时将该地址传送给形参p(p是指针变量）。这样ｐ就指向stu。在print函数中输出ｐ所指向的结构体变量的各个成员值，它们也就是stu的成员值.
main函数中的对各成员赋值也可以改用scanf函数输入.§ 11.7 用指针处理链表 § 11.7 用指针处理链表 11.7.1 链表概述
链表是一种常见的重要的数据结构,是动
态地进行存储分配的一种结构。
链表的组成：
头指针：存放一个地址，该地址指向一个元素
结点：用户需要的实际数据和链接节点的指针§ 11.7 用指针处理链表 § 11.7 用指针处理链表 用结构体建立链表：
struct student
｛ int num；
float score；
struct student *next ；};
其中成员num和score用来存放结点中的有用数据（用户需要用到的数据），next是指针类型的成员，它指向struct student类型数据（这就是next所在的结构体类型）§ 11.7 用指针处理链表 § 11.7 用指针处理链表 11.7.2 简单链表 #include
#define NULL 0
struct student
{long num; float score; struct student *next; };
main()
{ struct student a,b,c,*head,*p;
a. num=99101; a.score=89.5;
b. num=99103; b.score=90;
c. num=99107; c.score=85;
head=&a; a.next=&b; b.next=&c;
c.next=NULL; p=head;
do {printf("%ld %5.1f\n",p->num,p->score);
p=p->next; } while(p!=NULL);
}运行结果：
1010189.5
1010390.0
1010785.0 § 11.7 用指针处理链表 § 11.7 用指针处理链表程序分析：
开始时使head指向a结点，a.next指向b结点，b.next指向c结点，这就构成链表关系。“c.next=NULL” 的作用是使c.next不指向任何有用的存储单元。在输出链表时要借助p，先使p指向a结点，然后输出a结点中的数据，“p=p->next” 是为输出下一个结点作准备。p->next的值是b结点的地址，因此执行“p=p->next”后p就指向b结点，所以在下一次循环时输出的是b结点中的数据。§ 11.7 用指针处理链表 § 11.7 用指针处理链表 11.7.3处理动态链表所需的函数
库函数提供动态地开辟和释放存储单元的
有关函数：
malloc函数
其函数原型为void *malloc(unsigned int size);其
作用是在内存的动态存储区中分配一个长度为
size的连续空间。此函数的值（即“返回值”）
是一个指向分配域起始地址的指针（类型为
void）。如果此函数未能成功地执行（例如内
存空间不足），则返回空指针(NULL)。
§ 11.7 用指针处理链表 § 11.7 用指针处理链表 (2) calloc函数
其函数原型为void *calloc（unsigned ｎ，
unsigned size）;其作用是在内存的动态存储区
中分配ｎ个长度为size的连续空间。函数返回
一个指向分配域起始地址的指针；如果分配不
成功，返回NULL。
用calloc函数可以为一维数组开辟动态存
储空间，n为数组元素个数，每个元素长度为
size
§ 11.7 用指针处理链表 § 11.7 用指针处理链表 (3) free函数
其函数原型为void free（void *p）;其作用
是释放由ｐ指向的内存区，使这部分内存区能
被其他变量使用。ｐ是最近一次调用calloc或
malloc函数时返回的值。free函数无返回值.
以前的Ｃ版本提供的malloc和calloc函数
得到的是指向字符型数据的指针。 ANSI Ｃ提
供的malloc和calloc函数规定为void类型。
§ 11.7 用指针处理链表 § 11.7 用指针处理链表 11.7.4 建立动态链表
所谓建立动态链表是指在程序执行过程中从
无到有地建立起一个链表，即一个一个地开辟结
点和输入各结点数据，并建立起前后相链的关系
例11.5 写一函数建立一个有3名学生数据的单向动
态链表.
算法如图§ 11.7 用指针处理链表 § 11.7 用指针处理链表 算法的实现：
我们约定学号不会为零，如果输入的学号为
０，则表示建立链表的过程完成，该结点不应连
接到链表中。
如果输入的p1->num不等于０，则输入的是第
一个结点数据（n=1），令head＝p1，即把p1的值
赋给head，也就是使head也指向新开辟的结点p1
所指向的新开辟的结点就成为链表中第一个结点§ 11.7 用指针处理链表 § 11.7 用指针处理链表 算法的实现：
再开辟另一个结点并使p1指向它，接着输入该
结点的数据.如果输入的p1->num≠０，则应链入第２个结点
（n=2), 将新结点的地址赋给第一个结点的
next成员.接着使ｐ２＝ｐ１，也就是使ｐ２指向刚才建
立的结点§ 11.7 用指针处理链表 § 11.7 用指针处理链表 算法的实现：
再开辟一个结点并使p1指向它，并输入该结点的
数据.在第三次循环中，由于ｎ＝３（ｎ≠１），又
将ｐ１的值赋给ｐ２->ｎｅｘｔ，也就是将第
３个结点连接到第２个结点之后，并使ｐ２＝
ｐ１，使ｐ２指向最后一个结点.§ 11.7 用指针处理链表 § 11.7 用指针处理链表 算法的实现：
再开辟一个新结点，并使p1指向它，输入该结
点的数据。由于p1->num的值为０，不再执行循环
，此新结点不应被连接到链表中.将NULL赋给p2->next.建立链表过程至此结束，p1最后所指的结点
未链入链表中，第三个结点的next成员的值
为NULL，它不指向任何结点。§ 11.7 用指针处理链表 § 11.7 用指针处理链表 建立链表的函数如下:
#include
#include
#define NULL 0 //令NULL代表０，用它表示“空地址
#define LEN sizeof(struct student) //令LEN代表struct //student类型数据的长度
struct student
{ long num;
float score; struct student *next;
};int n; //n为全局变量，本文件模块中各函数均可使用它§ 11.7 用指针处理链表 § 11.7 用指针处理链表 struct student *creat()
{struct student *head; struct student *p1,*p2; n=0;
p1=p2=( struct student*) malloc(LEN);
scanf("%ld,%f",&p1->num,&p1->score);
head=NULL;
while(p1->num!=0)
{ n=n+1; if(n==1)head=p1; else p2->next=p1;
p2=p1; p1=(struct student*)malloc(LEN);
scanf("%ld,%f",&p1->num,&p1->score);
}
p2->next=NULL; return(head);}§ 11.7 用指针处理链表 § 11.7 用指针处理链表 11.7.5 输出链表
首先要知道链表第一个结点的地址，也就是
要知道head的值。然后设一个指针变量p,先指向
第一个结点，输出ｐ所指的结点，然后使ｐ后移
一个结点，再输出，直到链表的尾结点。 § 11.7 用指针处理链表 § 11.7 用指针处理链表 例１1．9 编写一个输出链表的函数print.
void print(struct student *head)
{struct student *p;
printf("\nNow,These %d records are:\n",n); p=head;
if(head!=NULL)
do
{printf("%ld %5.1f\n",p->num,p->score);
p=p->next;
}while(p!=NULL);
}
§ 11.7 用指针处理链表 § 11.7 用指针处理链表 11.7.6 对链表的删除操作
从一个动态链表中删去一个结点，并不是真
正从内存中把它抹掉，而是把它从链表中分离开
来，只要撤销原来的链接关系即可。§ 11.7 用指针处理链表 § 11.7 用指针处理链表 例11.10写一函数以删除动态链表中指定的结点.
解题思路:
从p指向的第一个结点开始，检查该结点中的
num值是否等于输入的要求删除的那个学号。如果
相等就将该结点删除，如不相等，就将p后移一个
结点，再如此进行下去，直到遇到表尾为止。§ 11.7 用指针处理链表 § 11.7 用指针处理链表 可以设两个指针变量p1和p2，先使p1指向
第一个结点 . 如果要删除的不是第一个结点，则使p1后
移指向下一个结点(将p1->next赋给p1)，在此
之前应将p1的值赋给p2 ，使p2指向刚才检查
过的那个结点 § 11.7 用指针处理链表 § 11.7 用指针处理链表 注意：
①要删的是第一个结点（ｐ１的值等于ｈｅａｄ的值，如图１1-２0（ａ）那样），则应将ｐ１->ｎｅｘｔ赋给ｈｅａｄ。这时ｈｅａｄ指向原来的第二个结点。第一个结点虽然仍存在，但它已与链表脱离，因为链表中没有一个结点或头指针指向它。虽然ｐ１还指向它，它仍指向第二个结点，但仍无济于事，现在链表的第一个结点是原来的第二个结点，原来第一个结点已“丢失” ，即不再是链表中的一部分了。§ 11.7 用指针处理链表 § 11.7 用指针处理链表 注意：
②如果要删除的不是第一个结点，则将ｐ１->ｎｅｘｔ赋给ｐ２->ｎｅｘｔ，见图１1２0（ｄ）。ｐ２->ｎｅｘｔ原来指向ｐ１指向的结点（图中第二个结点），现在ｐ２->ｎｅｘｔ改为指向ｐ１->ｎｅｘｔ所指向的结点（图中第三个结点）。ｐ１所指向的结点不再是链表的一部分。
还需要考虑链表是空表（无结点）和链表中找不到要删除的结点的情况。§ 11.7 用指针处理链表 § 11.7 用指针处理链表 § 11.7 用指针处理链表 § 11.7 用指针处理链表 算法：
图11-21
§ 11.7 用指针处理链表 § 11.7 用指针处理链表 删除结点的函数del:
struct student *del(struct student *head,long num)
{struct student *p1,*p2;
if (head==NULL){printf("\nlist null!\n");goto end;}
p1=head;
while(num!=p1->num && p1->next!=NULL) {p2=p1;p1=p1->next;}
if(num==p1->num)
{if(p1==head) head=p1->next;
else p2->next=p1->next;
printf("delete:%ld\n",num); n=n-1; }
else printf("%ld not been found!\n",num);
end;return(head);} § 11.7 用指针处理链表 § 11.7 用指针处理链表 11.7.7对链表的插入操作
对链表的插入是指将一个结点插入到一个已有的链表中。
为了能做到正确插入，必须解决两个问题：
① 怎样找到插入的位置；
② 怎样实现插入。§ 11.7 用指针处理链表 § 11.7 用指针处理链表 先用指针变量p0指向待插入的结点，p1指向第
一个结点将p0->num与p1->num相比较，如果p0->num＞
p1-> num ，则待插入的结点不应插在p1所指的
结点之前。此时将p1后移，并使p2指向刚才p1
所指的结点.§ 11.7 用指针处理链表 § 11.7 用指针处理链表 再将p1->num与p0->num比,如果仍然是p0->num
大，则应使p1继续后移，直到p0->p1-> num为止。
这时将p0所指的结点插到p1所指结点之前。但是如
果p1所指的已是表尾结点，则p1就不应后移了。如
果p0-> num比所有结点的num都大，则应将p0所指
的结点插到链表末尾。 如果插入的位置既不在第一个结点之前，又不
在表尾结点之后，则将p0的值赋给p2->next，使
p2->next指向待插入的结点，然后将p1的值赋给
p0->next，使得p0->next指向p1指向的变量§ 11.7 用指针处理链表 § 11.7 用指针处理链表 如果插入位置为第一个结点之前(即p1等于
head时)，则将p0赋给head，将p1赋给p0->next如果要插到表尾之后，应将p0赋给p1->next，
NULL赋给p0->next§ 11.7 用指针处理链表 § 11.7 用指针处理链表 算法：
图11-23
§ 11.7 用指针处理链表 § 11.7 用指针处理链表 例11.11插入结点的函数insert如下。
struct student *insert(struct student *head, struct student *stud)
{struct student *p0,*p1,*p2;
p1=head;p0=stud; if(head==NULL)
{head=p0; p0->next=NULL;}
else{while((p0->num>p1->num) && (p1->next!=NULL))
{p2=p1; p1=p1->next;}
if(p0->num<=p1->num) {if(head==p1) head=p0;
else p2->next=p0; p0->next=p1;}
else {p1->next=p0; p0->next=NULL;}}
n=n+1; return(head);
}§ 11.7 用指针处理链表 § 11.7 用指针处理链表 11.7.8 对链表的综合操作
将以上建立、输出、删除、插入的函数组织
在一个C程序中，用ｍａｉｎ函数作主调函数。 void main()
{
struct student *head,stu;long del_num;
prinf(″intput records:\n″) ;
head=creat();print(head);printf (″ \n intput the deleted number:\n″);
scanf (″%ld″,&del_num) ;head=del(head,del_num);
print(head);
printf (″ \n intput the deleted number:\n″);
scanf (″%ld″,&stu.num,&stu.score) ;
head=insert(head,&stu);
print(head);
}§ 11.7 用指针处理链表 § 11.7 用指针处理链表 此程序运行结果是正确的。它只删除一个结
点，插入一个结点。但如果想再插入一个结点，
重复写上程序最后4行，共插入两个结点，运行结
果却是错误的。Input records： （建立链表）
10１０１，９０↙
10１０３，９８↙
10１０５，７６↙
０，０↙§ 11.7 用指针处理链表 § 11.7 用指针处理链表 Now,these 3 records are：
10１０１９０．０
10１０３９８．０
10１０５７６．０
intput the deleted number ：10103（删除）
ｄｅｌｅｔｅ：10１０３↙
Now,these 4 records are：
10１０１９０．０
10１０５７６．０ § 11.7 用指针处理链表 § 11.7 用指针处理链表 input the inserted record （插入第一个结点）
10102，90↙
Now,these 3 records are：
10１０１９０．０
10１０２９０．０
10１０５７６．０input the inserted record （插入第二个结点）
10104，99↙
Now,these 4 records are：
10１０１９０．０
10１０４９９．０
10１０４９９．０
10１０４９９．０ § 11.7 用指针处理链表 § 11.7 用指针处理链表 出现以上结果的原因是：
stu是一个有固定地址的结构体变量。第一次把stu结点插入到链表中，第二次若再用它来插入第二个结点，就把第一次结点的数据冲掉了，实际上并没有开辟两个结点。为了解决这个问题，必须在每插入一个结点时新开辟一个内存区。我们修改main函数，使之能删除多个结点（直到输入要删的学号为0），能插入多个结点（直到输入要插入的学号为0）。 § 11.7 用指针处理链表 § 11.7 用指针处理链表 main()
{struct student *head,*stu;
long del_num;printf("input records:\n");
head=creat(); print (head);
printf("\ninput the deleted number:");
scanf("%ld",&del_num);
while (del_num!=0){head=del(head,del_num);
print (head);printf ("input the deleted number:");
scanf("%ld",&del_num);} printf("\ninput the inserted record:");stu=(struct student *) malloc(LEN);
scanf("%ld,%f",&stu->num,&stu->score);
while(stu->num!=0){head=insert(hea
浙公网安备 33021202002483