数据结构严蔚敏上机代码完整版Word文件下载.docx
《数据结构严蔚敏上机代码完整版Word文件下载.docx》由会员分享，可在线阅读，更多相关《数据结构严蔚敏上机代码完整版Word文件下载.docx（18页珍藏版）》请在冰豆网上搜索。
〃当前存储空间已满，增加分配
*）realloc（L.elem
（L」istsize
+LISTINCREMENT）*sizeof（ElemType））;
if（!
newbase）exit（OVERFLOW）;
//存储分配失败
L.elem=newbase;
〃新基址
L.listsize+=LISTINCREMENT;
//增加存储容量
}
q=&
（L.elem[i-1]）;
〃q为插入位置
for（p=&
（L.clcm[L.lcngth-l]）;
p>
=q;
-p）
*（p+l）=*p;
//插入位置及之后的元素右移
*q=e;
〃插入e
++L.length;
〃表长增1
returnOK;
）//ListInsert_Sq
StatusListDclete_Sq（SqList&
L,intLElcmTypc&
c）{
〃在顺序线性表L中删除第i个元素，并用c返回其值
//i的合法值为l<
=ListLength_Sq（L）
=L.length）returni;
elsereturn0;
）//LocateEIem_Sq
voidMergeList_Sq（SqListLa.SqListLb,SqList&
Lc）{
〃已知顺序线性表La和Lb的元素按值非递减排列
〃归并La和Lb得到新的顺序线性表Lc,Lc的元素也按非递减排列
ElemType*pa,*pb,*pc,*pajast,*pbJast;
pa=La.elem;
pb=Lb.elem;
Lc.listsize=Lc」ength=La」ength+LK1ength;
pc=Lc.eleni=（ElemType*）inalloc（Lc.listsize*sizeof（ElemType））;
Lc.elem）exit（OVERFLOW）;
//存储分配失败
paJast=La.elem+La.length-1;
pb_last=Lb.elem+Lb」ength-1;
while（pa<
=pa_last&
&
pb<
=pb」ast）
{
〃归并
if（*pa<
=*pb）
*pc++=*pa++;
else
*pc++=*pb++;
=pa_last）*pc++=*pa++;
〃插入La的剩余元素
while（pb<
=pb_last）*pc++=*pb++:
〃插入Lb的剩余元素
）//MergeList_Sqvoidmain（）
SqListL;
〃龙义线性表
InitList_Sq（L）y/调用空表
〃插入数据
ListInsert_Sq（L」,10）;
ListInsert_Sq（L,2,20）;
ListInsert_Sq（L」,30）;
ListInsert_Sq（L,3.40）;
printf（H插入后：
\nH）;
display（L）7/调用循环函数
ListInsert_Sq（L3J00）;
//在L表第三个位置插入100printf（H插入后:
display（L）;
ElemTypec;
〃定义e
ListDclete_Sq（L.3,e）y/删除L表的第三个元素，用e表示print”删除后：
printf（"
被删除元素：
%d\n\n\n\nH,e）;
*/
SqListLa.Lb.Lc:
InitList_Sq（La）;
ListInsert_Sq（La丄3）;
ListInsert_Sq（La,2,5）;
ListInsert_Sq（La,3,8）;
ListInsert_Sq（La,4Jl）;
printfC'
La插入后:
\nN）;
display（La）;
InitList_Sq（Lb）;
ListInsert_Sq（Lb」,2）；
ListInsert_Sq（Lb,2,6）;
ListInsert_Sq（Lb3,8）;
ListInsert_Sq（Lb,4,9）;
ListInsert_Sq（Lb,5J1）;
ListInsert_Sq（Lb,6,15）;
ListInsert_Sq（Lb,7,20）;
printf（HLb插入后:
display（Lb）;
MergeList_Sq（La,Lb.Lc）;
printfC*归并后：
\n"
）;
display（Lc）;
printf（H\nH）;
inta=LocateElem_Sq（Lc,5）;
printf（H%d\n,\a）;
第三次上机：
#defineOK1
#dcfineINFEASIBLE-1
#dcfineOVERFLOW-2
typedefintStatus;
typedefintElemTypc:
typedefstmetLNode
ElemTypedata;
structLNode*next;
}LNOdc卢LinkList;
StatusGetElem_L（LinkListL.inti.ElemType&
c）
//L为带头结点的单链表的头指针
〃当第i个元素存在时，其值賦给e并返回OK,否则返回ERRORLinkListp;
p=L->
next:
intj=l;
〃初始化，p指向第一个结点，j为计数器
while（p&
jvi）
〃顺指针向后查找，直到p指向第i个元素或p为空p=p->
++j;
pllj>
i）
returnERROR;
〃第i个元素不存在
e=p->
data;
〃取第i个元素
returnOK:
）//GetEIem_L
StatusListInsert_L（LinkList&
LJnti,ElemTypee）
〃在带头结点的单链线性表L中第i个位宜之前插入元素e
LinkListp,s;
p=L;
intj=0;
jvi・l）
p=p->
next;
}〃寻找第i-1个结点
i-l）returnERROR;
//i小于或者大于表长+1s=（LinkList）nialloc（sizeof（LNode））;
〃生成新结点
s->
data=e;
next=p->
〃插入L中
p->
next=s;
}//ListInsert_L
StatusListDeIete_L（LinkList&
L・inti.ElemType&
〃在带头结点的单链线性表L中，删除第i个元素，并由c返回其值
LinkListp.q;
while（p->
next&
j<
i-1）
〃寻找第i个结点，并令p指向其前趋
（p->
next）llj>
i-l）returnERROR;
〃删除位垃不合理
q=p->
next=q->
〃删除并释放结点
e=q->
free（q）;
）//ListDelete_L
voidCreateList_L（LinkList&
Ljntn）
〃逆位序输入n个元素的值，建立带表头结点的单链线性表L
LinkListp;
L=（LinkList）malloc（sizeof（LNode））;
L->
next=NULL：
〃先建立一个带头结点的单链表
for（inti=n;
i>
0;
-i）
p=（LinkList）malloc（sizeof（LNode））;
scanf（n%dM,&
data）;
〃输入元素值
next=L->
next=p;
〃插入到表头
）//CreateList_L
voiddisplay（LinkListL）
{LinkListp=L->
〃泄义for循环函数while（p）
（
printf（n%d/\p->
p=p->
Xn11）;
voidinain（）
LinkListL;
CreateList_L（L.3）;
display（L）;
ListInsert_L（L,2J00）;
ElemTypee;
ListDelete_LXL,2,e）;
printfC被删除的值=%d\n”,e）;
GetElem_L（U3x）;
prin叱获取的值=%d\n,\e）;
第四次上机
#include<
include<
#dcfineERROR0
#defineOVERFLOW-2typcdefintSElemType;
typcdefintStatus;
#dcfineSTACKJNIT_SIZE100
#dcfineSTRCKINCREMENT10typcdefstmct{
SElemType*base;
//存储空间初始分配量
〃存储空间分配增量
//在栈构造之前和销毀之后，base的值为NULL
SElemTypc*top:
〃栈顶指针
intstacksize;
JSqStack;
〃当前已分配的存储空间，以元素为单位
StatusInitStack（SqStack&
S）{
//构造一个空栈s
S.base=（SElemT\fpe*）malloc（STACK_INIT_SIZE*sizeof（SElemType））;
S.base）exit（OVERFLOW）;
S.top=S.base;
S.stacksize=STACKJNIT_SIZE;
}//InitStack
StatusGetTop（SqStackS.SElemType&
〃若栈不空，则用e返回S的栈顶元素，并返回OK；
否则返回ERRORif（S.top==S.base）
e=*（S.top-1）;
）//GetTop
StatusPush（SqStack&
S.SElemTypee）{
//插入元素e为新的栈顶元素
if（S.top・S.base>
=S.stacksize）{
//栈满,追加存储空间
S.base=（SElemType*）realloc（S.baseJS.stacksize+STRCKINCREMENT）*sizeof（SElemType））;
S.top=S.base+S.stacksize;
S.stacksize+=STRCKINCREMENT:
*S.top++=c：
returnOK;
）//Push
StatusPop（SqStack&
S.SElemType&
〃若栈不空，则删除S的栈顶元素，用e返回其值，并返回0K；
否则返回ERROR
if（S.top=S.base）returnERROR;
e=*-S.top;
}//Pop
StatusStackEmpty（SqStackS）{
if（S.top=S.base）
returnTRUE;
elsereturnERROR:
}voidconversion（）{
//对于输入的任意一个非负十进制整数，打印输出与其等值的八进制数
SqStackS;
intN;
SElcmTypce;
InitStack（S）;
〃构造空栈
scanf（,,%d,\&
N）;
while（N）{
Push（S,N%8）;
N=N/8;
printf（”转换成八进制后的数为：
”）；
while（!
StackEmpty（S））{
Pop（S.e）;
printf（,,%d,\e）;
printf（H\nM）;
}//conversionvoidmain（）
SElemTypec,x;
Push（S・5）;
Push（S・4）;
Push（S・3）;
Push（S・2）;
Push（SJ）;
GetTop（Sx）;
printfC*栈顶元素为%d\ii'
\e）;
printf（H\n,r）;
Pop（S.x）;
删除的栈顶元素为％d\n"
x）;
printf（,,\nH）;
输入一个十进制数：
conversion（）;
第五次上机
/*队列的链式存储钉
#defineFALSE0
typedefintQElemT\pe;
typcdcfintStatus;
typedefstmetQNode{
QElemTypedata;
structQNode*next;
}QNode,*QueuePtr;
typedefstnict{
QueuePtrfront;
〃队头指针
QueuePtrrear;
〃队尾指针
JLinkQueue;
StatusInitQueuc（LinkQueue&
Q）{
//构造一个空队列Q
Q.front=Q.rear=（QueuePtr）malloc（sizeof（QNode））;
Q.front）exit（OVERFLOW）;
Q.front->
next=NULL;
StatusDestroyQueue（LinkQucue&
〃销毁队列Q
while（Q.front）{
Q.rear=Q.front->
free（Q.front）;
Q.front=Q.rear;
StatusEnQueue（LinkQueue&
Q.QElcmTypce）{
〃插入元素e为Q的新的队尾元素
QueuePtrp;
p=（QueucPtr）maIloc⑸zcof（QNodc））;
p）exit（OVERFLOW）;
next=NULL;
Q.rear・>
Q.rear=p:
StatusDeQucue（LinkQueue&
Q.QElemType&
〃若队列不为空，则删除Q的队头元素，用e返回其值，并返回0K：
〃否则返回ERROR
if（Q.front=Q.rear）returnERROR;
p=Q.front->
next=p->
if（Q.rear==p）
Q.rear=Q.front;
free（p）;
）
voiddisp（LinkQueucQ）
p=Q.front->
〃左义for循环函数
while（p）
printf（H%d*\p->
printf（M\nH）;
voidmain（）
LinkQueueQ;
QElemTypee;
InitQueue（Q）;
插入的元素为:
EnQueue（Q,25）;
EnQueue（Q.5）;
EnQueue（QJ2）;
EnQueue（Q,60）;
EnQueue（Q33）;
disp（Q）;
printfC删除队头元素后：
DeQueue（Qx）;
DestroyQueue（Q）;
if（DestroyQueue（Q）=1）printfC销毁队列成功!
\n"
）；
else
printfC销毁队列失败!
附加：
/*队列的顺序存储*/
//最大队列长度
#dcfineMAXQSIZE100
typcdefstmct{QElemType*baseintfront;
intrear;
JSqQueue;
//初始化的动态分配存储空间
〃头指针，若队列不空，指向队列头元素
〃尾指针，若队列不空，指向队列尾元素的下一个位置
StatusInitQueue（SqQueue&
〃构造一个空队列
Q.base=（QElcmTypc*）malloc（MAXQSIZE*sizeof（QElcmType））;
Q.base）exit（OVERFLOW）;
Q.front=Q.rear=0;
intQueueLenth（SqQueueQ）{
〃返回Q的元素个数，即队列的长度
return（Q.rear・Q.from+MAXQSIZE）%MAXQSIZE:
StatusEnQueue（SqQueue&
Q.QElemTypee）{
if（（Q.rear+1）%MAXQSIZE==Q.front）returnERROR;
〃队列满Q.base[Q.rear]=e;
Q.rear=（Q.rear+1）%MAXQSIZE;
StatusDeQueue（SqQueue&
〃若队列不为空，则删除Q的队头元素，用e返回其值，并返回OK：
if（Q.front=Q.rear）returnERROR;
e=Q.base[Q.front];
Q.front=（Q.front+l）%MAXQSIZE:
第六次上机
#defineTRUE1
typedefcharTElemType;
//二叉树的二叉链表存储表示
typedefstmetBiTNode{
TEIemT\-pedata;
structBiTNode*lchild?
rchild;
//左右孩子指针
}BiTNode,*BiTree;
StatusCrcatcBiTree（BiTree&
T）{
//按先序次序输入二叉树中结点的值（一个字符），空格字符表示空树,
〃构造二叉树链表表示的二叉树T
charch;
scai】f（”％c：
ch）;
if（ch=**）
T=NULL;
else{
（T=（BiTNode*）malloc（sizeof（BiTNode））））exit（OVERFLOW）;
T->
data=ch;
〃生成根结点
CreateBiTree（T->
lchild）;
〃构造左子树
rchild）;
〃构造右子树
）//CreateBiTrec
voidPreOrderTraverse（BiTreeT）{
〃先序遍历
printf（H%cgdata）;
〃输出结点
PreOrderTraverse（T->
lchild）;
rchild）;
voidInOrderTraverse（BiTreeT）{
〃中序遍历
print
升级会员 