清华严蔚敏《数据结构》的全部代码实现C语言

创作编号：
GB8878185555334563BT9125XW
创作者：凤呜大王*
/* c1.h (程序名) */
#include<string.h>
#include<ctype.h>
#include<malloc.h> /* malloc()等*/
#include<limits.h> /* INT_MAX等*/
#include<stdio.h> /* EOF(=^Z或F6),NULL */
#include<stdlib.h> /* atoi() */
#include<io.h> /* eof() */
#include<math.h> /* floor(),ceil(),abs() */
#include<process.h> /* exit() */
/* 函数结果状态代码*/
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
/* #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行*/
typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等*/ typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */
/* algo2-1.c 实现算法2.1的程序*/
#include"c1.h"
typedef int ElemType;
#include"c2-1.h"
/*c2-1.h 线性表的动态分配顺序存储结构*/
#define LIST_INIT_SIZE 10 /* 线性表存储空间的初始分配量*/
#define LISTINCREMENT 2/* 线性表存储空间的分配增量*/
typedef struct
{
ElemType*elem; /* 存储空间基址*/
int length; /* 当前长度*/
int listsize; /* 当前分配的存储容量(以sizeof(ElemType)为单位) */
}SqList;
#include"bo2-1.c"
/* bo2-1.c 顺序表示的线性表(存储结构由c2-1.h定义)的基本操作(12个) */ Status InitList(SqList*L) /* 算法2.3 */
{ /* 操作结果：构造一个空的顺序线性表*/
(*L).elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
if(!(*L).elem)
exit(OVERFLOW); /* 存储分配失败*/
(*L).length=0; /* 空表长度为0 */
(*L).listsize=LIST_INIT_SIZE; /* 初始存储容量*/
return OK;
}
Status DestroyList(SqList*L)
{ /* 初始条件：顺序线性表L已存在。

操作结果：销毁顺序线性表L */ free((*L).elem);
(*L).elem=NULL;
(*L).length=0;
(*L).listsize=0;
return OK;
}
创作编号：
GB8878185555334563BT9125XW
创作者：凤呜大王*
Status ClearList(SqList*L)
{ /* 初始条件：顺序线性表L已存在。

操作结果：将L重置为空表*/
(*L).length=0;
return OK;
}
Status ListEmpty(SqList L)
{ /* 初始条件：顺序线性表L已存在。

操作结果：若L为空表，则返回TRUE，否则返回FALSE */
if(L.length==0)
return TRUE;
else
return FALSE;
}
int List Length(SqList L)
{ /* 初始条件：顺序线性表L已存在。

操作结果：返回L中数据元素个数*/
return L.length;
}
Status Get Elem(SqList L,int i,ElemType *e)
{ /* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：用e返回L中第i个数据元素的值*/
if(i<1||i>L.length)
exit(ERROR);
*e=*(L.elem+i-1);
return OK;
}
int Locate Elem(SqList L,ElemType e,Status(*compare)(ElemType,ElemType))
{ /* 初始条件：顺序线性表L已存在，compare()是数据元素判定函数(满足为1,否则为0) */
/* 操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。

*/ /* 若这样的数据元素不存在，则返回值为0。

算法2.6 */
ElemType *p;
int i=1; /* i的初值为第1个元素的位序*/
p=L.elem; /* p的初值为第1个元素的存储位置*/
while(i<=L.length&&!compare(*p++,e))
++i;
if(i<=L.length)
return i;
return 0;
}
Status Prior Elem(SqList L,ElemType cur_e,ElemType *pre_e)
{ /* 初始条件：顺序线性表L已存在*/
/* 操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，*/
/* 否则操作失败，pre_e无定义*/
int i=2;
ElemType *p=L.elem+1;
while(i<=L.length&&*p!=cur_e)
{
p++;
i++;
}
if(i>L.length)
return INFEASIBLE;
else
{
*pre_e=*--p;
return OK;
}
}
Status Next Elem(SqList L,ElemType cur_e,ElemType *next_e)
{ /* 初始条件：顺序线性表L已存在*/
/* 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继，*/
创作编号：
GB8878185555334563BT9125XW
创作者：凤呜大王*
/* 否则操作失败，next_e无定义*/
int i=1;
ElemType *p=L.elem;
while(i<L.length&&*p!=cur_e)
{
p++;
}
if(i==L.length)
return INFEASIBLE;
else
{
*next_e=*++p;
return OK;
}
}
Status ListInsert(SqList*L,int i,ElemType e) /* 算法2.4 */
{ /* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)+1 */
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */ ElemType *newbase,*q,*p;
if(i<1||i>(*L).length+1) /* i值不合法*/
return ERROR;
if((*L).length>=(*L).listsize) /* 当前存储空间已满,增加分配*/
{
newbase=(ElemType
*)realloc((*L).elem,((*L).listsize+LISTINCREMENT)*sizeof(ElemType));
if(!newbase)
exit(OVERFLOW); /* 存储分配失败*/
(*L).elem=newbase; /* 新基址*/
(*L).listsize+=LISTINCREMENT; /* 增加存储容量*/
}
q=(*L).elem+i-1; /* q为插入位置*/
for(p=(*L).elem+(*L).length-1;p>=q;--p) /* 插入位置及之后的元素右移*/
*(p+1)=*p;
*q=e; /* 插入e */
++(*L).length; /* 表长增1 */
return OK;
}
Status ListDelete(SqList*L,int i,ElemType *e) /* 算法2.5 */
{ /* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */ ElemType *p,*q;
if(i<1||i>(*L).length) /* i值不合法*/
return ERROR;
p=(*L).elem+i-1; /* p为被删除元素的位置*/
*e=*p; /* 被删除元素的值赋给e */
q=(*L).elem+(*L).length-1; /* 表尾元素的位置*/
for(++p;p<=q;++p) /* 被删除元素之后的元素左移*/
*(p-1)=*p;
(*L).length--; /* 表长减1 */
return OK;
}
Status ListTraverse(SqList L,void(*vi)(ElemType*))
{ /* 初始条件：顺序线性表L已存在*/
/* 操作结果：依次对L的每个数据元素调用函数vi()。

一旦vi()失败，则操作失败*/
/* vi()的形参加'&'，表明可通过调用vi()改变元素的值*/
ElemType *p;
int i;
p=L.elem;
for(i=1;i<=L.length;i++)
vi(p++);
pr int f("\n");
return OK;
}
Status equal(ElemType c1,ElemType c2)
{ /* 判断是否相等的函数，Union()用到*/
if(c1==c2)
return TRUE;
else
return FALSE;
}
void Union(SqList*L a,SqList Lb) /* 算法2.1 */
创作编号：
GB8878185555334563BT9125XW
创作者：凤呜大王*
{ /* 将所有在线性表Lb中但不在La中的数据元素插入到La中*/
ElemType e;
int La_len,Lb_len;
int i;
La_len=List Length(*L a); /* 求线性表的长度*/
Lb_len=List Length(Lb);
for(i=1;i<=Lb_len;i++)
{
Get Elem(Lb,i,&e); /* 取Lb中第i个数据元素赋给e */
if(!Locate Elem(*L a,e,equal)) /* La中不存在和e相同的元素,则插入之*/ ListInsert(La,++La_len,e);
}
}
void pr int(ElemType *c)
{
pr int f("%d ",*c);
}
void main()
{
SqList La,Lb;
Status i;
int j;
i=InitList(&La);
if(i==1) /* 创建空表La成功*/
for(j=1;j<=5;j++) /* 在表La中插入5个元素*/
i=ListInsert(&La,j,j);
pr int f("La= "); /* 输出表La的内容*/
ListTraverse(La,pr int);
InitList(&Lb); /* 也可不判断是否创建成功*/
for(j=1;j<=5;j++) /* 在表Lb中插入5个元素*/
i=ListInsert(&Lb,j,2*j);
pr int f("Lb= "); /* 输出表Lb的内容*/
ListTraverse(Lb,pr int);
Union(&La,Lb);
pr int f("new La= "); /* 输出新表La的内容*/
ListTraverse(La,pr int);}
/* algo2-2.c 实现算法2.2的程序*/
#include"c1.h"
typedef int ElemType;
#include"c2-1.h"
#include"bo2-1.c"
void MergeList(SqList La,SqList Lb,SqList*L c) /* 算法2.2 */
{ /* 已知线性表La和Lb中的数据元素按值非递减排列。

*/
/* 归并La和Lb得到新的线性表Lc,Lc的数据元素也按值非递减排列*/ int i=1,j=1,k=0;
int La_len,Lb_len;
ElemType ai,bj;
InitList(Lc); /* 创建空表Lc */
La_len=List Length(La);
Lb_len=List Length(Lb);
while(i<=La_len&&j<=Lb_len) /* 表La和表Lb均非空*/
{
Get Elem(La,i,&ai);
Get Elem(Lb,j,&bj);
if(ai<=bj)
{
ListInsert(Lc,++k,ai);
++i;
}
else
{
ListInsert(Lc,++k,bj);
++j;
}
}
while(i<=La_len) /* 表La非空且表Lb空*/
{
Get Elem(La,i++,&ai);
ListInsert(Lc,++k,ai);
}
while(j<=Lb_len) /* 表Lb非空且表La空*/
{
Get Elem(Lb,j++,&bj);
ListInsert(Lc,++k,bj);
}
}
void pr int(ElemType *c)
{
pr int f("%d ",*c);
}
void main()
创作编号：
GB8878185555334563BT9125XW
创作者：凤呜大王*
{
SqList La,Lb,Lc;
int j,a[4]={3,5,8,11},b[7]={2,6,8,9,11,15,20};
InitList(&La); /* 创建空表La */
for(j=1;j<=4;j++) /* 在表La中插入4个元素*/
ListInsert(&La,j,a[j-1]);
pr int f("La= "); /* 输出表La的内容*/
ListTraverse(La,pr int);
InitList(&Lb); /* 创建空表Lb */
for(j=1;j<=7;j++) /* 在表Lb中插入7个元素*/
ListInsert(&Lb,j,b[j-1]);
pr int f("Lb= "); /* 输出表Lb的内容*/
ListTraverse(Lb,pr int);
MergeList(La,Lb,&Lc);
pr int f("Lc= "); /* 输出表Lc的内容*/
ListTraverse(Lc,pr int);
}
/* algo2-3.c 实现算法2.7的程序*/
#include"c1.h"
typedef int ElemType;
#include"c2-1.h"
#include"bo2-1.c"
void MergeList(SqList La,SqList Lb,SqList*L c) /* 算法2.7 */
{ /* 已知顺序线性表La和Lb的元素按值非递减排列。

*/
/* 归并La和Lb得到新的顺序线性表Lc,Lc的元素也按值非递减排列*/ ElemType *pa,*pa_last,*pb,*pb_last,*pc;
pa=La.elem;
pb=Lb.elem;
(*L c).listsize=(*L c).length=La.length+Lb.length;/*不用InitList()创建空表Lc */ pc=(*L c).elem=(ElemType *)malloc((*L c).listsize*sizeof(ElemType));
if(!(*L c).elem) /* 存储分配失败*/
exit(OVERFLOW);
pa_last=La.elem+La.length-1;
pb_last=Lb.elem+Lb.length-1;
while(pa<=pa_last&&pb<=pb_last) /* 表La和表Lb均非空*/
{ /* 归并*/
if(*pa<=*pb)
*pc++=*pa++;
else
*pc++=*pb++;
}
while(pa<=pa_last) /* 表La非空且表Lb空*/
*pc++=*pa++; /* 插入La的剩余元素*/
while(pb<=pb_last) /* 表Lb非空且表La空*/
*pc++=*pb++; /* 插入Lb的剩余元素*/
}
void pr int(ElemType *c)
{
pr int f("%d ",*c);
}
void main()
{
SqList La,Lb,Lc;
int j;
InitList(&La); /* 创建空表La */
for(j=1;j<=5;j++) /* 在表La中插入5个元素*/
ListInsert(&La,j,j);
pr int f("La= "); /* 输出表La的内容*/
ListTraverse(La,pr int);
InitList(&Lb); /* 创建空表Lb */
for(j=1;j<=5;j++) /* 在表Lb中插入5个元素*/
ListInsert(&Lb,j,2*j);
pr int f("Lb= "); /* 输出表Lb的内容*/
ListTraverse(Lb,pr int);
MergeList(La,Lb,&Lc);
pr int f("Lc= "); /* 输出表Lc的内容*/
ListTraverse(Lc,pr int);
}
/* algo2-4.c 修改算法2.7的第一个循环语句中的条件语句为开关语句，且当*/ /* *pa=*pb时，只将两者中之一插入Lc。

此操作的结果和算法2.1相同*/
#include"c1.h"
typedef int ElemType;
#include"c2-1.h"
#include"bo2-1.c"
int comp(ElemType c1,ElemType c2)
{
int i;
if(c1<c2)
i=1;
else if(c1==c2)
i=0;
else
i=-1;
return i;
}
void MergeList(SqList La,SqList Lb,SqList*L c)
{ /* 另一种合并线性表的方法（根据算法2.7下的要求修改算法2.7）*/
创作编号：
GB8878185555334563BT9125XW
创作者：凤呜大王*
ElemType*pa,*pa_last,*pb,*pb_last,*pc;
pa=La.elem;
pb=Lb.elem;
(*L c).listsize=La.length+Lb.length; /* 此句与算法2.7不同*/
pc=(*L c).elem=(ElemType *)malloc((*L c).listsize*sizeof(ElemType));
if(!(*L c).elem)
exit(OVERFLOW);
pa_last=La.elem+La.length-1;
pb_last=Lb.elem+Lb.length-1;
while(pa<=pa_last&&pb<=pb_last) /* 表La和表Lb均非空*/
switch(comp(*pa,*pb)) /* 此句与算法2.7不同*/
{
case 0: pb++;
case 1: *pc++=*pa++;
break;
case -1: *pc++=*pb++;
}
while(pa<=pa_last) /* 表La非空且表Lb空*/
*pc++=*pa++;
while(pb<=pb_last) /* 表Lb非空且表La空*/
*pc++=*pb++;
(*L c).length=pc-(*L c).elem; /* 加此句*/
}
void pr int(ElemType *c)
{
pr int f("%d ",*c);
}
void main()
{
SqList La,Lb,Lc;
int j;
InitList(&La); /* 创建空表La */
for(j=1;j<=5;j++) /* 在表La中插入5个元素*/ ListInsert(&La,j,j);
pr int f("La= "); /* 输出表La的内容*/ ListTraverse(La,pr int);
InitList(&Lb); /* 创建空表Lb */
for(j=1;j<=5;j++) /* 在表Lb中插入5个元素*/ ListInsert(&Lb,j,2*j);
pr int f("Lb= "); /* 输出表Lb的内容*/ ListTraverse(Lb,pr int);
MergeList(La,Lb,&Lc);
pr int f("Lc= "); /* 输出表Lc的内容*/ ListTraverse(Lc,pr int);
}
/* algo2-5.c 实现算法2.11、2.12的程序*/
#include"c1.h"
typedef int ElemType;
#include"c2-2.h"
/* c2-2.h 线性表的单链表存储结构*/
struct LNode
{
ElemType data;
struct LNode *next;
};
typedef struct LNode *L inkList; /* 另一种定义LinkList的方法*/
#include"bo2-2.c"
/* bo2-2.c 单链表线性表(存储结构由c2-2.h定义)的基本操作(12个) */
Status InitList(LinkList *L)
{ /* 操作结果：构造一个空的线性表L */
*L=(LinkList)malloc(sizeof(struct LNode)); /* 产生头结点,并使L指向此头结点*/
if(!*L) /* 存储分配失败*/
exit(OVERFLOW);
(*L)->next=NULL; /* 指针域为空*/
return OK;
}
Status DestroyList(LinkList *L)
{ /* 初始条件：线性表L已存在。

操作结果：销毁线性表L */
LinkList q;
while(*L)
{
q=(*L)->next;
free(*L);
*L=q;
}
return OK;
}
Status ClearList(LinkList L) /* 不改变L */
{ /* 初始条件：线性表L已存在。

操作结果：将L重置为空表*/
LinkList p,q;
p=L->next; /* p指向第一个结点*/
while(p) /* 没到表尾*/
{
q=p->next;
free(p);
p=q;
}
L->next=NULL; /* 头结点指针域为空*/
return OK;
}
Status ListEmpty(LinkList L)
{ /* 初始条件：线性表L已存在。

操作结果：若L为空表，则返回TRUE，否则返回FALSE */
if(L->next) /* 非空*/
return FALSE;
else
return TRUE;
}
创作编号：
GB8878185555334563BT9125XW
创作者：凤呜大王*
int List Length(LinkList L)
{ /* 初始条件：线性表L已存在。

操作结果：返回L中数据元素个数*/
int i=0;
LinkList p=L->next; /* p指向第一个结点*/
while(p) /* 没到表尾*/
{
i++;
p=p->next;
}
return i;
}
Status Get Elem(LinkList L,int i,ElemType *e) /* 算法2.8 */
{ /* L为带头结点的单链表的头指针。

当第i个元素存在时,其值赋给e并返回OK,否则返回ERROR */
int j=1; /* j为计数器*/
LinkList p=L->next; /* p指向第一个结点*/
while(p&&j<i) /* 顺指针向后查找,直到p指向第i个元素或p为空*/
{
p=p->next;
j++;
}
if(!p||j>i) /* 第i个元素不存在*/
return ERROR;
*e=p->data; /* 取第i个元素*/
return OK;
}
int Locate Elem(LinkList L,ElemType e,Status(*compare)(ElemType,ElemType)) { /* 初始条件: 线性表L已存在,compare()是数据元素判定函数(满足为1,否则为0) */
/* 操作结果: 返回L中第1个与e满足关系compare()的数据元素的位序。

*/ /* 若这样的数据元素不存在,则返回值为0 */
int i=0;
LinkList p=L->next;
while(p)
{
i++;
if(compare(p->data,e)) /* 找到这样的数据元素*/
return i;
p=p->next;
}
return 0;
}
Status Prior Elem(LinkList L,ElemType cur_e,ElemType *pre_e)
{ /* 初始条件: 线性表L已存在*/
/* 操作结果: 若cur_e是L的数据元素,且不是第一个,则用pre_e返回它的前驱, */ /* 返回OK;否则操作失败,pre_e无定义,返回INFEASIBLE */
LinkList q,p=L->next; /* p指向第一个结点*/
while(p->next) /* p所指结点有后继*/
{
q=p->next; /* q为p的后继*/
if(q->data==cur_e)
{
*pre_e=p->data;
return OK;
}
p=q; /* p向后移*/
}
return INFEASIBLE;
}
Status Next Elem(LinkList L,ElemType cur_e,ElemType *next_e)
{ /* 初始条件：线性表L已存在*/
/* 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继，*/
/* 返回OK;否则操作失败，next_e无定义，返回INFEASIBLE */ LinkList p=L->next; /* p指向第一个结点*/
while(p->next) /* p所指结点有后继*/
{
if(p->data==cur_e)
{
*next_e=p->next->data;
return OK;
}
p=p->next;
}
return INFEASIBLE;
}
Status ListInsert(LinkList L,int i,ElemType e) /* 算法2.9。

不改变L */
{ /* 在带头结点的单链线性表L中第i个位置之前插入元素e */
int j=0;
LinkList p=L,s;
while(p&&j<i-1) /* 寻找第i-1个结点*/
{
p=p->next;
j++;
}
if(!p||j>i-1) /* i小于1或者大于表长*/
return ERROR;
s=(LinkList)malloc(sizeof(struct LNode)); /* 生成新结点*/
s->data=e; /* 插入L中*/
s->next=p->next;
p->next=s;
return OK;
}
Status ListDelete(LinkList L,int i,ElemType *e) /* 算法2.10。

不改变L */
{ /* 在带头结点的单链线性表L中，删除第i个元素,并由e返回其值*/
int j=0;
LinkList p=L,q;
while(p->next&&j<i-1) /* 寻找第i个结点,并令p指向其前趋*/
{
p=p->next;
j++;
}
if(!p->next||j>i-1) /* 删除位置不合理*/
return ERROR;
q=p->next; /* 删除并释放结点*/
p->next=q->next;
*e=q->data;
free(q);
return OK;
}
Status ListTraverse(LinkList L,void(*vi)(ElemType))
创作编号：
GB8878185555334563BT9125XW
创作者：凤呜大王*
/* vi的形参类型为ElemType，与bo2-1.c中相应函数的形参类型ElemType&不同*/ { /* 初始条件：线性表L已存在*/
/* 操作结果:依次对L的每个数据元素调用函数vi()。

一旦vi()失败,则操作失败*/ LinkList p=L->next;
while(p)
{
vi(p->data);
p=p->next;
}
pr int f("\n");
return OK;
}
void CreateList(LinkList *L,int n) /* 算法2.11 */
{ /* 逆位序(插在表头)输入n个元素的值，建立带表头结构的单链线性表L */
int i;
LinkList p;
*L=(LinkList)malloc(sizeof(struct LNode));
(*L)->next=NULL; /* 先建立一个带头结点的单链表*/
pr int f("请输入%d个数据\n",n);
for(i=n;i>0;--i)
{
p=(LinkList)malloc(sizeof(struct LNode)); /* 生成新结点*/
scanf("%d",&p->data); /* 输入元素值*/
p->next=(*L)->next; /* 插入到表头*/
(*L)->next=p;
}
}
void CreateList2(LinkList *L,int n)
{ /* 正位序(插在表尾)输入n个元素的值，建立带表头结构的单链线性表*/ int i;
LinkList p,q;
*L=(LinkList)malloc(sizeof(struct LNode)); /* 生成头结点*/
(*L)->next=NULL;
q=*L;
pr int f("请输入%d个数据\n",n);
for(i=1;i<=n;i++)
{
p=(LinkList)malloc(sizeof(struct LNode));
scanf("%d",&p->data);
q->next=p;
q=q->next;
}
p->next=NULL;
}
void MergeList(LinkList La,LinkList *L b,LinkList *L c)/* 算法2.12 */
{ /* 已知单链线性表La和Lb的元素按值非递减排列。

*/
/* 归并La和Lb得到新的单链线性表Lc，Lc的元素也按值非递减排列*/ LinkList pa=La->next,pb=(*L b)->next,pc;
*L c=pc=La; /* 用La的头结点作为Lc的头结点*/
while(pa&&pb)
if(pa->data<=pb->data)
{
pc->next=pa;
pc=pa;
pa=pa->next;
}
else
{
pc->next=pb;
pc=pb;
pb=pb->next;
}
pc->next=pa?pa:pb; /* 插入剩余段*/
free(*L b); /* 释放Lb的头结点*/
Lb=NULL;
}
void visit(ElemType c) /* ListTraverse()调用的函数(类型要一致) */
{
pr int f("%d ",c);
}
void main()
{
int n=5;
LinkList La,Lb,Lc;
pr int f("按非递减顺序, ");
CreateList2(&La,n); /* 正位序输入n个元素的值*/
pr int f("La="); /* 输出链表La的内容*/
ListTraverse(La,visit);
pr int f("按非递增顺序, ");
CreateList(&Lb,n); /* 逆位序输入n个元素的值*/
pr int f("Lb="); /* 输出链表Lb的内容*/
ListTraverse(Lb,visit);
MergeList(La,&Lb,&Lc); /* 按非递减顺序归并La和Lb,得到新表Lc */ pr int f("Lc="); /* 输出链表Lc的内容*/
ListTraverse(Lc,visit);
}
/* algo2-6.c 利用单链表结构处理教科书图2.1(学生健康登记表) */
#include"c1.h"
#define NAMELEN 8 /* 姓名最大长度*/
#define CLASSLEN 4 /* 班级名最大长度*/
struct stud /* 记录的结构*/
{
char name[NAMELEN+1];
long num;
char sex;
int age;
char Class[CLASSLEN+1];
int health;
};
typedef struct stud ElemType; /* 链表结点元素类型为结构体*/
#include"c2-2.h"
char sta[3][9]={"健康","一般","神经衰弱"}; /* 健康状况(3类) */ FILE *fp;
Status InitList(LinkList *L) /* 拷自bo2-2.c */
{ /* 操作结果：构造一个空的线性表L */
*L=(LinkList)malloc(sizeof(struct LNode)); /* 产生头结点,并使L指向此头结点*/ if(!*L) /* 存储分配失败*/
exit(OVERFLOW);
(*L)->next=NULL; /* 指针域为空*/
return OK;
}
Status ListTraverse(LinkList L,void(*vi)(ElemType)) /* 拷自bo2-2.c */
{ /* 初始条件：线性表L已存在*/
/* 操作结果:依次对L的每个数据元素调用函数vi()。

一旦vi()失败,则操作失败*/ LinkList p=L->next;
while(p)
{
创作编号：
GB8878185555334563BT9125XW
创作者：凤呜大王*
vi(p->data);
p=p->next;
}
pr int f("\n");
return OK;
}
void InsertAscend(LinkList L,ElemType e) /* 此函数是由bo2-9.c中的同名函数改写*/
{ /* 按学号非降序插入*/
LinkList q=L,p=L->next;
while(p&&e.num>p->data.num)
{
q=p;
p=p->next;
}
q->next=(LinkList)malloc(sizeof(struct LNode)); /* 插在q后*/
q->next->data=e;
q->next->next=p;
}
void Pr int(struct stud e)
{ /* 显示记录e的内容*/
pr int f("%-8s %6ld",,e.num);
if(e.sex=='m')
pr int f(" 男");
else
pr int f(" 女");
pr int f("%5d %-4s",e.age,e.Class);
pr int f("%9s\n",sta[e.health]);
}
void ReadIn(struct stud *e)
{ /* 由键盘输入结点信息*/
pr int f("请输入姓名(<=%d个字符): ",NAMELEN);
scanf("%s",e->name);
pr int f("请输入学号: ");
scanf("%ld",&e->num);
pr int f("请输入性别(m:男f:女): ");
scanf("%*c%c",&e->sex);
pr int f("请输入年龄: ");
scanf("%d",&e->age);
pr int f("请输入班级(<=%d个字符): ",CLASSLEN);
scanf("%s",e->Class);
pr int f("请输入健康状况(0:%s 1:%s 2:%s):",sta[0],sta[1],sta[2]); scanf("%d",&e->health);
}
void WriteToFile(struct stud e)
{ /* 将结点信息写入fp指定的文件*/
fwrite(&e,sizeof(struct stud),1,fp);
}
Status ReadFromFile(struct stud *e)
{ /* 由fp指定的文件读取结点信息到e */
int i;
i=fread(e,sizeof(struct stud),1,fp);
if(i==1) /* 读取文件成功*/
return OK;
else
return ERROR;
}
Status FindFromNum(LinkList L,long num,LinkList *p,LinkList *q)
{ /* 查找表中学号为num的结点,如找到,q指向此结点,p指向q的前驱, */
/* 并返回TRUE;如无此元素,则返回FALSE */
*p=L;
while(*p)
{
*q=(*p)->next;
if(*q&&(*q)->data.num>num) /* 因为是按学号非降序排列*/
break;
if(*q&&(*q)->data.num==num) /* 找到该学号*/
return TRUE;
*p=*q;
}
return FALSE;
}
Status FindFromName(LinkList L,char name[],LinkList *p,LinkList *q)
{ /* 查找表中姓名为name的结点,如找到,q指向此结点,p指向q的前驱, */
/* 并返回TRUE;如无此元素,则返回FALSE */
*p=L;
while(*p)
{
*q=(*p)->next;
if(*q&&!strcmp((*q)->,name)) /* 找到该姓名*/
return TRUE;
*p=*q;
}
return FALSE;
}
Status Delete Elem Num(LinkList L,long num)
{ /* 删除表中学号为num的元素，并返回TRUE；如无此元素，则返回FALSE */ LinkList p,q;
if(FindFromNum(L,num,&p,&q)) /* 找到此结点,且q指向其,p指向其前驱*/ {
p->next=q->next;
free(q);
return TRUE;
}
return FALSE;
}
Status Delete Elem Name(LinkList L,char name[])
{ /* 删除表中姓名为name的元素，并返回TRUE；如无此元素，则返回FALSE */ LinkList p,q;
if(FindFromName(L,name,&p,&q)) /* 找到此结点,且q指向其,p指向其前驱*/ {
p->next=q->next;
free(q);
return TRUE;
}
return FALSE;
}
void Mod if y(ElemType *e)
{ /* 修改结点内容*/
char s[80];
Pr int(*e); /* 显示原内容*/
pr int f("请输入待修改项的内容，不修改的项按回车键保持原值:\n");
pr int f("请输入姓名(<=%d个字符): ",NAMELEN);
gets(s);
if(strlen(s))
strcpy(e->name,s);
pr int f("请输入学号: ");
gets(s);
if(strlen(s))
e->num=atol(s);
pr int f("请输入性别(m:男f:女): ");
gets(s);
if(strlen(s))
e->sex=s[0];
pr int f("请输入年龄: ");
gets(s);
if(strlen(s))
创作编号：
GB8878185555334563BT9125XW
创作者：凤呜大王*
e->age=atoi(s);
pr int f("请输入班级(<=%d个字符): ",CLASSLEN);
gets(s);
if(strlen(s))
strcpy(e->Class,s);
pr int f("请输入健康状况(0:%s 1:%s 2:%s):",sta[0],sta[1],sta[2]);
gets(s);
if(strlen(s))
e->health=atoi(s); /* 修改完毕*/
}
#define N 4 /* student记录的个数*/
void main()
{
struct stud student[N]={{"王小林",790631,'m',18,"计91",0},
{"陈红",790632,'f',20,"计91",1},
{"刘建平",790633,'m',21,"计91",0},
{"张立立",790634,'m',17,"计91",2}}; /* 表的初始记录*/
int i,j,flag=1;
long num;
char filename[13],name[NAMELEN+1];
ElemType e;
LinkList T,p,q;
InitList(&T); /* 初始化链表*/
while(flag)
{
pr int f("1:将结构体数组student中的记录按学号非降序插入链表\n");
pr int f("2:将文件中的记录按学号非降序插入链表\n");
pr int f("3:键盘输入新记录，并将其按学号非降序插入链表\n");
pr int f("4:删除链表中第一个有给定学号的记录\n");
pr int f("5:删除链表中第一个有给定姓名的记录\n");
pr int f("6:修改链表中第一个有给定学号的记录\n");
pr int f("7:修改链表中第一个有给定姓名的记录\n");
pr int f("8:查找链表中第一个有给定学号的记录\n");
pr int f("9:查找链表中第一个有给定姓名的记录\n");
pr int f("10:显示所有记录11:将链表中的所有记录存入文件12:结束\n");
pr int f("请选择操作命令: ");
scanf("%d",&i);
switch(i)
{
case 1: for(j=0;j<N;j++)
InsertAscend(T,student[j]);
break;
case 2: pr int f("请输入文件名: ");
scanf("%s",filename);
if((fp=fopen(filename,"rb"))==NULL)
pr int f("打开文件失败!\n");
else
{
while(ReadFromFile(&e))
InsertAscend(T,e);
fclose(fp);
}
break;
case 3: ReadIn(&e);
InsertAscend(T,e);
break;
case 4: pr int f("请输入待删除记录的学号: ");
scanf("%ld",&num);
if(!Delete Elem Num(T,num))
pr int f("没有学号为%ld的记录\n",num);
break;
case 5: pr int f("请输入待删除记录的姓名: ");
scanf("%s",name);
if(!Delete Elem Name(T,name))
pr int f("没有姓名为%s的记录\n",name);
break;
case 6: pr int f("请输入待修改记录的学号: ");
scanf("%ld%*c",&num); /* %*c吃掉回车符*/
if(!FindFromNum(T,num,&p,&q))
pr int f("没有学号为%ld的记录\n",num);
else
{
Mod if y(&q->data);
if(q->data.num!=num) /* 学号被修改*/
{
p->next=q->next; /* 把q所指的结点从L中删除*/
InsertAscend(T,q->data); /* 把元素插入L */
free(q); /* 删除q */
}
}
break;
case 7: pr int f("请输入待修改记录的姓名: ");
scanf("%s%*c",name); /* %*c吃掉回车符*/
if(!FindFromName(T,name,&p,&q))
pr int f("没有姓名为%s的记录\n",name);
else
{
num=q->data.num; /* 学号存入num */
Mod if y(&q->data);
if(q->data.num!=num) /* 学号被修改*/
{
p->next=q->next; /* 把q所指的结点从L中删除*/
InsertAscend(T,q->data); /* 把元素插入L */
free(q); /* 删除q */
}
}
break;
case 8: pr int f("请输入待查找记录的学号: ");
scanf("%ld",&num);
if(!FindFromNum(T,num,&p,&q))
pr int f("没有学号为%ld的记录\n",num);
else
Pr int(q->data);
break;
case 9: pr int f("请输入待查找记录的姓名: ");
scanf("%s",name);
if(!FindFromName(T,name,&p,&q))
pr int f("没有姓名为%s的记录\n",name);
else
Pr int(q->data);
break;
case 10:pr int f(" 姓名学号性别年龄班级健康状况\n");
ListTraverse(T,Pr int);
break;
case 11:pr int f("请输入文件名: ");
scanf("%s",filename);
if((fp=fopen(filename,"wb"))==NULL)
pr int f("打开文件失败!\n");
else
ListTraverse(T,WriteToFile);
fclose(fp);
break;
case 12:flag=0;
}
}
}
/* algo2-7.c 教科书中图2.10 静态链表示例*/
/* 第一个结点的位置在[0].cur中，成员cur的值为0，则到链表尾*/ #include"c1.h"
#define N 6 /* 字符串长度*/
typedef char ElemType[N];
#include"c2-3.h"
/* c2-3.h 线性表的静态单链表存储结构*/
#define MAXSIZE 100 /* 链表的最大长度*/
typedef struct
{
ElemType data;
int cur;
}component,SLinkList[MAXSIZE];
void main()
创作编号：
GB8878185555334563BT9125XW
创作者：凤呜大王*
{
SLinkList
s={{"",1},{"ZHAO",2},{"QIAN",3},{"SUN",4},{"LI",5},{"ZHOU",6},{"WU",7},{"ZHE NG",8},{"WANG",0}};
int i;
i=s[0].cur;
while(i) /* 输出教科书中图2.10(a)的状态*/
{
pr int f("%s ",s[i].data); /* 输出链表的当前值*/
i=s[i].cur; /* 找到下一个*/
}
pr int f("\n");
s[4].cur=9; /* 按教科书中图2.10(b)修改*/
s[6].cur=8;
s[9].cur=5;
strcpy(s[9].data,"SHI");
i=s[0].cur;
while(i) /* 输出教科书中图2.10(b)的状态*/
{
pr int f("%s ",s[i].data); /* 输出链表的当前值*/
i=s[i].cur; /* 找到下一个*/
}
pr int f("\n");
}
/* algo2-8.c 实现算法2.17的程序*/
#include"c1.h"
#define N 2
typedef char ElemType;
#include"c2-3.h"
#include"bo2-3.c"
/* bo2-3.c 实现算法2.15、2.16的程序(数据结构由c2-3.h定义) (3个) */
int Malloc(SLinkList space) /* 算法2.15 */
{ /* 若备用链表非空,则返回分配的结点下标(备用链表的第一个结点),否则返回0 */ int i=space[0].cur;
if(i) /* 备用链表非空*/
space[0].cur=space[i].cur; /* 备用链表的头结点指向原备用链表的第二个结点*/
return i; /* 返回新开辟结点的坐标*/
}
void Free(SLinkList space,int k) /* 算法2.16 */
{ /* 将下标为k的空闲结点回收到备用链表(成为备用链表的第一个结点) */
space[k].cur=space[0].cur; /* 回收结点的＂游标＂指向备用链表的第一个结点*/ space[0].cur=k; /* 备用链表的头结点指向新回收的结点*/
}
void DestroyList()
{ /* 静态数组不能被销毁*/
}
#include"bo2-32.c"
/* bo2-32.c 一个数组可生成若干静态链表(数据结构由c2-3.h定义)的基本操作(12个) */
void InitSpace(SLinkList L) /* 算法2.14。

另加*/
{ /* 将一维数组L中各分量链成一个备用链表，L[0].cur为头指针。

“0”表示空指针*/
int i;
for(i=0;i<MAXSIZE-1;i++)
L[i].cur=i+1;
L[MAXSIZE-1].cur=0;
}
int InitList(SLinkList L)
{ /* 构造一个空链表，返回值为空表在数组中的位序*/
int i;
i=Malloc(L); /* 调用Malloc()，简化程序*/
L[i].cur=0; /* 空链表的表头指针为空(0) */
return i;
}
Status ClearList(SLinkList L,int n)
{ /* 初始条件：L中表头位序为n的静态链表已存在。

操作结果：将此表重置为空表*/
int j,k,i=L[n].cur; /* 链表第一个结点的位置*/
L[n].cur=0; /* 链表空*/
k=L[0].cur; /* 备用链表第一个结点的位置*/
L[0].cur=i; /* 把链表的结点连到备用链表的表头*/
while(i) /* 没到链表尾*/
{
j=i;
i=L[i].cur; /* 指向下一个元素*/
}
L[j].cur=k; /* 备用链表的第一个结点接到链表的尾部*/
return OK;
}
Status ListEmpty(SLinkList L,int n)
{ /* 判断L中表头位序为n的链表是否空,若是空表返回TRUE;否则返回FALSE */ if(L[n].cur==0) /* 空表*/
return TRUE;
else
return FALSE;
}
int List Length(SLinkList L,int n)
{ /* 返回L中表头位序为n的链表的数据元素个数*/
int j=0,i=L[n].cur; /* i指向第一个元素*/
while(i) /* 没到静态链表尾*/
{
i=L[i].cur; /* 指向下一个元素*/
j++;
}
return j;
}
Status Get Elem(SLinkList L,int n, int i,ElemType *e)
{ /* 用e返回L中表头位序为n的链表的第i个元素的值*/
int l,k=n; /* k指向表头序号*/
if(i<1||i>List Length(L,n)) /* i值不合理*/
return ERROR;
for(l=1;l<=i;l++) /* 移动i-1个元素*/
k=L[k].cur;
*e=L[k].data;
return OK;
}
int Locate Elem(SLinkList L,int n,ElemType e)
{ /* 在L中表头位序为n的静态单链表中查找第1个值为e的元素。

*/
/* 若找到，则返回它在L中的位序，否则返回0 */
int i=L[n].cur; /* i指示表中第一个结点*/
while(i&&L[i].data!=e) /* 在表中顺链查找(e不能是字符串) */
i=L[i].cur;
return i;
}
Status Prior Elem(SLinkList L,int n,ElemType cur_e,ElemType *pre_e)
{ /* 初始条件：在L中表头位序为n的静态单链表已存在*/
/* 操作结果：若cur_e是此单链表的数据元素，且不是第一个，*/
/* 则用pre_e返回它的前驱，否则操作失败，pre_e无定义*/
int j,i=L[n].cur; /* i为链表第一个结点的位置*/
do
{ /* 向后移动结点*/
j=i;
i=L[i].cur;
}while(i&&cur_e!=L[i].data);
if(i) /* 找到该元素*/
{
*pre_e=L[j].data;
return OK;
}
return ERROR;
}
Status Next Elem(SLinkList L,int n,ElemType cur_e,ElemType *next_e)
{ /* 初始条件：在L中表头位序为n的静态单链表已存在*/
/* 操作结果：若cur_e是此单链表的数据元素，且不是最后一个，*/
/* 则用next_e返回它的后继，否则操作失败，next_e无定义*/
int i;
i=Locate Elem(L,n,cur_e); /* 在链表中查找第一个值为cur_e的元素的位置*/ if(i) /* 在静态单链表中存在元素cur_e */
{
i=L[i].cur; /* cur_e的后继的位置*/
if(i) /* cur_e有后继*/。