p=p->next;
++j;
}
if（!
（p->next）||j>i-1）returnL;/*删除位置不合理*/
q=p->next;p->next=q->next;
*e=q->data;free（q）;
returnL;
}
voidListTraverse（LinkListL）
{LinkListp=L->next;
while（p）
{printf（"%d",p->data）;
p=p->next;
}
printf（"\n"）;
}
voidmain（）
{
LinkListLb;
int*p=NULL;
Lb=CreateList（N）;/*逆位序输入n个元素的值*/
printf（"Lb="）;/*输出链表Lb的内容*/
ListTraverse（Lb）;
Lb=insert（Lb,2,9）;/*在带头结点的单链线性表L中第i个位置之前插入元素e*/
printf（"Lb="）;/*输出链表Lb的内容*/
ListTraverse（Lb）;
Lb=delete（Lb,3,p）;/*在带头结点的单链线性表L中，删除第i个元素，并由p返回其值*/
printf（"Deletenumber:
%d\n",*p）;
printf（"Lb="）;/*输出链表Lb的内容*/
ListTraverse（Lb）;
}
实验二栈的建立、插入和删除
参考程序
#include
#include
#defineSTACK_INIT_SIZE100/*存储空间初始分配量*/
#defineINC10/*存储空间分配增量*/
typedefstruct
{char*base;/*在栈构造之前和销毁之后，base值为NULL*/
char*top;/*栈顶指针*/
intstacksize;/*当前已分配的存储空间，以元素为单位*/
}sqstack;
voidInitstack（sqstack*s）
{/*构造一个空栈S*/
（*s）.base=（char*）malloc（STACK_INIT_SIZE*sizeof（char））;
if（!
（*s）.base）exit（0）;/*存储分配失败*/
（*s）.top=（*s）.base;
（*s）.stacksize=STACK_INIT_SIZE;
}
voidpush（sqstack*s,charx）/*插入元素e为新的元素*/
{if（（（*s）.top-（*s）.base）>=（*s）.stacksize）
{（*s）.base=（char*）realloc（（*s）.base,（（*s）.stacksize+INC）*sizeof（char））;
if（!
（*s）.base）exit（0）;/*存储分配失败*/
（*s）.top=（*s）.base+（*s）.stacksize;
（*s）.stacksize+=INC;
}
*（（*s）.top）++=x;
}
intpop（sqstack*s,char*x）
{/*若栈不空，则删除S的栈顶元素，用e返回其值，并返回值*/
if（（*s）.top==（*s）.base）return0;
else{（*s）.top=（*s）.top-1;
*x=*（（*s）.top）;
}
return1;
}
main（）
{sqstacks;
charch;
Initstack（&s）;
push（&s,'a'）;
push（&s,'b'）;
push（&s,'c'）;
pop（&s,ch）;printf（"%c",ch）;
pop（&s,ch）;printf（"%c",ch）;
pop（&s,ch）;printf（"%c",ch）;
}
实验三队列的建立、插入和删除
参考程序
#include
#include
#include/*exit（）*/
typedefstructQNode{
chardata;
structQNode*next;
}QNode,*QueuePtr;
typedefstruct{
QueuePtrfront;/*队头指针*/
QueuePtrrear;/*队尾指针*/
}LinkQueue;
voidInitQueue（LinkQueue*Q）
{/*构造一个空队列Q*/
（*Q）.front=（*Q）.rear=（QueuePtr）malloc（sizeof（QNode））;
if（!
（*Q）.front）exit（0）;
（*Q）.front->next=NULL;
}
voidEnQueue（LinkQueue*Q,chare）
{/*插入元素e为Q的新的队尾元素*/
QueuePtrp=（QueuePtr）malloc（sizeof（QNode））;
if（!
p）exit（0）;/*存储分配失败*/
p->data=e;p->next=NULL;
（*Q）.rear->next=p;（*Q）.rear=p;
}
voidDeQueue（LinkQueue*Q,char*e）
{/*若队列不空，删除Q的队头元素，用e返回其值，并返回OK，否则返回ERROR*/
QueuePtrp;
if（（*Q）.front==（*Q）.rear）exit（0）;/*空队列退出*/
p=（*Q）.front->next;
*e=p->data;
（*Q）.front->next=p->next;
if（（*Q）.rear==p）（*Q）.rear=（*Q）.front;
free（p）;
}
voidprintfQueue（LinkQueueQ）
{
QueuePtrp;
p=Q.front->next;
while（p）
{
printf（"%3c",p->data）;
p=p->next;
}
printf（"\n"）;
}
main（）
{LinkQueueQ;
chare;
InitQueue（&Q）;
EnQueue（&Q,'a'）;
EnQueue（&Q,'b'）;
EnQueue（&Q,'c'）;
EnQueue（&Q,'d'）;
EnQueue（&Q,'e'）;
printf（"Queueelement:
"）;
printfQueue（Q）;
printf（"Nowinseraelementinthequeue,outputthequeue:
"）;
EnQueue（&Q,'f'）;
printfQueue（Q）;
DeQueue（&Q,&e）;
printf（"Nowdeleteaelementinthequeue,theelementis:
%c\n",e）;
printf（"outputthequeue:
"）;
printfQueue（Q）;
}
实验四循环队列的建立、插入和删除
参考程序
#include
#include
#include
#defineMAX_QSIZE5/*最大队列长度+1*/
typedefstruct
{
int*base;/*初始化的动态分配存储空间*/
intfront;/*头指针，若队列不空，指向队列头元素*/
intrear;/*尾指针，若队列不空，指向队列尾元素的下一个位置*/
}SqQueue;
voidInitQueue（SqQueue*Q）
{/*构造一个空队列Q*/
（*Q）.base=（int*）malloc（MAX_QSIZE*sizeof（int））;
if（!
（*Q）.base）/*存储分配失败*/
exit（0）;
（*Q）.front=（*Q）.rear=0;
}
voidEnQueue（SqQueue*Q,inte）
{/*插入元素e为Q的新的队尾元素*/
if（（（*Q）.rear+1）%MAX_QSIZE==（*Q）.front）/*队列满*/
exit（0）;;
（*Q）.base[（*Q）.rear]=e;
（*Q）.rear=（（*Q）.rear+1）%MAX_QSIZE;
}
voidDeQueue（SqQueue*Q,int*e）
{/*若队列不空，则删除Q的队头元素，用e返回其值，并返回OK；否则返回ERROR*/
if（（*Q）.front==（*Q）.rear）/*队列空*/
exit（0）;
*e=（*Q）.base[（*Q）.front];
（*Q）.front=（（*Q）.front+1）%MAX_QSIZE;
}
voidQueueTraverse（SqQueueQ）
{/*从队头到队尾依次对队列Q中每个元素输出*/
inti;
i=Q.front;
while（i!
=Q.rear）
{
printf（"%3d",Q.base[i]）;
i=（i+1）%MAX_QSIZE;
}
printf（"\n"）;
}
voidmain（）
{
intd,i=0;
SqQueueQ;
InitQueue（&Q）;
printf（"Pleaseinputtheelementsofthequeue（%dnumber）,-1istheend:
",MAX_QSIZE-1）;
do
{
scanf（"%d",&d）;
if（d==-1）
break;
i++;
EnQueue（&Q,d）;
}while（iDeQueue（&Q,&d）;
printf（"Deletetheelementis:
%d\n",d）;
printf（"Nowtheelementsare:
\n"）;
QueueTraverse（Q）;
DeQueue（&Q,&d）;
printf（"Deletetheelementis:
%d\n",d）;
printf（"Nowtheelementsare:
\n"）;
QueueTraverse（Q）;
}
实验五数组的顺序存储表示和实现
参考程序
#include/*标准头文件,提供宏va_start,va_arg,va_end,用于存放变长文件*/
#include
#include
#defineMAX_ARRAY_DIM8
typedefstruct
{
int*base;/*数组元素基址，由InitArray分配*/
intdim;/*数组维数*/
int*bounds;/*数组维界基址，由InitArray分配*/
int*constants;/*数组映象函数常量基址，由InitArray分配*/
}Array;
intInitArray（Array*A,intdim,...）
{/*若维数dim和各维长度合法，则构造相应的数组A*/
intelemtotal=1,i;/*elemtotal是数组元素总数，初值为1（累乘器）*/
va_listap;
if（dim<1||dim>MAX_ARRAY_DIM）
return0;
（*A）.dim=dim;
（*A）.bounds=（int*）malloc（dim*sizeof（int））;
if（!
（*A）.bounds）
exit（0）;
va_start（ap,dim）;
for（i=0;i{
（*A）.bounds[i]=va_arg（ap,int）;
if（A.bounds[i]<0）
return0;
elemtotal*=（*A）.bounds[i];
}
va_end（ap）;
（*A）.base=（int*）malloc（elemtotal*sizeof（int））;
if（!
A.base）
exit（0）;
（*A）.constants=（int*）malloc（dim*sizeof（int））;
if（!
（*A）.constants）
exit（0）;
（*A）.constants[dim-1]=1;
for（i=dim-2;i>=0;--i）
（*A）.constants[i]=（（*A）.bounds[i+1]）*（（*A）.constants[i+1]）;
return1;
}
intLocate（ArrayA,va_listap,int*off）/*Value（）、Assign（）调用此函数*/
{/*若ap指示的各下标值合法，则求出该元素在A中的相对地址off*/
inti,ind;
*off=0;
for（i=0;i{
ind=va_arg（ap,int）;
if（ind<0||ind>=A.bounds[i]）
return0;
*off+=A.constants[i]*ind;
}
return1;
}
}
intValue（ArrayA,int*e,...）
{/*...依次为各维的下标值，若各下标合法，则e被赋值为A的相应的元素值*/
va_listap;
intresult;
intoff;
va_start（ap,e）;
if（（result=Locate（A,ap,&off））<=0）
returnresult;
*e=*（A.base+off）;
return1;
}
intAssign（ArrayA,inte,...）
{/*...依次为各维的下标值，若各下标合法，则将e的值赋给A的指定的元素*/
va_listap;
intresult;
intoff;
va_start（ap,e）;
if（（result=Locate（A,ap,&off））<=0）
returnresult;
*（A.base+off）=e;
return1;
}
voidmain（）
{ArrayA;
inti,j,e;
InitArray（&A,2,3,4）;
Printf（"TheArrayelementsare:
\n"）;
for（i=0;i<3;i++）
for（j=0;i<4;j++）
Assign（A,（i+1）*10+j,i,j）;
for（i=0;i<3;i++）
{printf（"\n"）;
for（j=0;i<4;j++）
{
value（A,&e,i,j）;
printf（"%4d",e）;
}
}
}
实验六二叉树的建立和实现
参考程序
#include
#include
typedefstructBiTNode{
chardata;
structBiTNodelchild,rchild;/*左右孩子指针*/
}BiTNode,*BiTree;
voidvisit（chare）
{
printf（"%c",e）;
}
voidInitBiTree（BiTree*T）
{
*T=NULL;
}
voidCreateBiTree（BiTree*T）{
/*按先序次序输入二叉树中结点的值（一个字符），空格字符表示空树*/
/*构造二叉链表表示的二叉树T*/
charch;
scanf（"%c",&ch）;
if（ch==''）*T=NULL;
else{
*T=（BiTree）malloc（sizeof（BiTNode））;
if（!
*T）
exit（0）;
（*T）->data=ch;/*生成根结点*/
CreateBiTree（&（*T）->lchild）;/*构造左子树*/
CreateBiTree（&（*T）->rchild）;/*构造右子树*/
}
}
voidPreorder（BiTreeT,void（*visit）（chare））
{if（T）{
visit（T->data）;
Preorder（T->lchild,visit）;
Preorder（T->rchild,visit）;
}
}
voidmain（）
{BiTreeT;
InitBiTree（&T）;
CreateBiTree（&T）;
Preorder（T,visit）;
}
实验七赫夫曼树的建立和实现
参考程序
#include
#include
typedefstruct
{/*赫夫曼树和赫夫曼编码的存储表示*/
unsignedintweight;
unsignedintparent,lchild,rchild;
}HTNode,*HuffmanTree;/*动态分配数组存储赫夫曼树*/
typedefchar**HuffmanCode;/*动态分配数组存储赫夫曼编码表*/
intmin1（HuffmanTreet,inti）
{/*返回i个结点中权值最小的树的根结点序号，函数select（）调用*/
intj,flag;
unsignedintk=UINT_MAX;/*取k为不小于可能的值（无符号整型最大值）*/
for（j=1;j<=i;j++）
if（t[j].weightk=t[j].weight,flag=j;
t[flag].parent=1;/*给选中的根结点的双亲赋1，避免第2次查找该结点*/
returnflag;
}
voidselect（HuffmanTreet,inti,int*s1,int*s2）
{/*在i个结点中选择2个权值最小的树的根结点序号，s1为其中序号小的那个*/
intj;
*s1=min1（t,i）;
*s2=min1（t,i）;
if（*s1>*s2）
{
j=*s1;
*s1=*s2;
*s2=j;
}
}
voidHuffmanCoding（HuffmanTree*HT,HuffmanCode*HC,int*w,intn）/*算法6.12*/
{/*w存放n个字符的权值（均>0），构造赫夫曼树HT，并求出n个字符的赫夫曼编码HC*/
intm,i,s1,s2,start;
unsignedc,f;
HuffmanTreep;
char*cd;
if（n<=1）
return;
m=2*n-1;
*HT=（HuffmanTree）malloc（（m+1）*sizeof（HTNode））;/*0号单元未用*/
for（p=*HT+1,i=1;i<=n;++i,++p,++w）
{
（*p）.weight=*w;
（*p）.parent=0;
（*p）.lchild=0;
（*p）.rchild=0;
}
for（;i<=m;++i,++p）
（*p）.parent=0;
for（i=n+1;i<=m;++i）/*建赫夫曼树*/
{/*在HT[1～i-1]中选择parent为0且weight最小的两个结点，其序号分别为s1和s2*/
select（*HT,i-1,&s1,&s2）;
（*HT）[s1].parent=（*HT）[s2
升级会员 