数据结构上机代码整理Word格式.docx
《数据结构上机代码整理Word格式.docx》由会员分享，可在线阅读，更多相关《数据结构上机代码整理Word格式.docx（23页珍藏版）》请在冰豆网上搜索。
1||i>
L.length+1）
returnERROR;
//i值不合法
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
}//ListInsert_Sq
StatusListDelete_Sq（SqList&
L,inti,ElemType&
e）{
//在顺序线性表L中删除第i个元素，并用e返回其值
=ListLength_Sq（L）
ElemType*p,*q;
if（（i<
1）||（i>
L.length））
p=&
//p为被删除元素的位置
e=*p;
//被删除元素的值赋给e
q=L.elem+L.length-1;
//表尾元素的位置
for（++p;
p<
++p）
*（p-1）=*p;
//被删除元素之后的元素左移
--L.length;
//表长减1
}//ListDelete_sq
voiddisplay（SqListL）
{//定义for循环函数
inti;
for（i=0;
i<
=L.length-1;
i++）
printf（"
%d\n"
L.elem[i]）;
}
intLocateElem_Sq（SqListL,ElemTypee）
{
//在顺序线性表L中查找第1个值与e满足compare（）的元素的位序
//若找到，则返回其在L中的位序，否则返回0
ElemType*p;
inti=1;
//i的初值为第一个元素的位序
p=L.elem;
//p的初值为第一个元素的存储位置
while（i<
=L.length&
&
*p++!
=e）++i;
=L.length）returni;
elsereturn0;
}//LocateElem_Sq
voidMergeList_Sq（SqListLa,SqListLb,SqList&
Lc）{
//已知顺序线性表La和Lb的元素按值非递减排列
//归并La和Lb得到新的顺序线性表Lc，Lc的元素也按非递减排列
ElemType*pa,*pb,*pc,*pa_last,*pb_last;
pa=La.elem;
pb=Lb.elem;
Lc.listsize=Lc.length=La.length+Lb.length;
pc=Lc.elem=（ElemType*）malloc（Lc.listsize*sizeof（ElemType））;
Lc.elem）exit（OVERFLOW）;
pa_last=La.elem+La.length-1;
pb_last=Lb.elem+Lb.length-1;
while（pa<
=pa_last&
pb<
=pb_last）
{
//归并
if（*pa<
=*pb）
*pc++=*pa++;
else
*pc++=*pb++;
=pa_last）*pc++=*pa++;
//插入La的剩余元素
while（pb<
=pb_last）*pc++=*pb++;
//插入Lb的剩余元素
}//MergeList_Sq
voidmain（）
/*
SqListL;
//定义线性表
InitList_Sq（L）;
//调用空表
//插入数据
ListInsert_Sq（L,1,10）;
ListInsert_Sq（L,2,20）;
ListInsert_Sq（L,1,30）;
ListInsert_Sq（L,3,40）;
printf（"
插入后：
\n"
）;
display（L）;
//调用循环函数
ListInsert_Sq（L,3,100）;
//在L表第三个位置插入100
ElemTypee;
//定义e
ListDelete_Sq（L,3,e）;
//删除L表的第三个元素，用e表示
删除后：
被删除元素：
%d\n\n\n\n"
e）;
*/
SqListLa,Lb,Lc;
InitList_Sq（La）;
ListInsert_Sq（La,1,3）;
ListInsert_Sq（La,2,5）;
ListInsert_Sq（La,3,8）;
ListInsert_Sq（La,4,11）;
La插入后：
display（La）;
InitList_Sq（Lb）;
ListInsert_Sq（Lb,1,2）;
ListInsert_Sq（Lb,2,6）;
ListInsert_Sq（Lb,3,8）;
ListInsert_Sq（Lb,4,9）;
ListInsert_Sq（Lb,5,11）;
ListInsert_Sq（Lb,6,15）;
ListInsert_Sq（Lb,7,20）;
Lb插入后：
display（Lb）;
MergeList_Sq（La,Lb,Lc）;
归并后：
display（Lc）;
inta=LocateElem_Sq（Lc,5）;
a）;
第三次上机：
typedefstructLNode
ElemTypedata;
structLNode*next;
}LNOde,*LinkList;
StatusGetElem_L（LinkListL,inti,ElemType&
e）
//L为带头结点的单链表的头指针
//当第i个元素存在时，其值赋给e并返回OK，否则返回ERROR
LinkListp;
p=L->
next;
intj=1;
//初始化，p指向第一个结点，j为计数器
while（p&
j<
i）
{
//顺指针向后查找，直到p指向第i个元素或p为空
p=p->
++j;
p||j>
//第i个元素不存在
e=p->
data;
//取第i个元素
}//GetElem_L
StatusListInsert_L（LinkList&
L,inti,ElemTypee）
//在带头结点的单链线性表L中第i个位置之前插入元素e
LinkListp,s;
p=L;
intj=0;
i-1）
}//寻找第i-1个结点
i-1）returnERROR;
//i小于或者大于表长+1
s=（LinkList）malloc（sizeof（LNode））;
//生成新结点
s->
data=e;
next=p->
//插入L中
p->
next=s;
}//ListInsert_L
StatusListDelete_L（LinkList&
//在带头结点的单链线性表L中，删除第i个元素，并由e返回其值
LinkListp,q;
while（p->
next&
//寻找第i个结点，并令p指向其前趋
++j;
（p->
next）||j>
//删除位置不合理
q=p->
next=q->
//删除并释放结点
e=q->
free（q）;
}//ListDelete_L
voidCreateList_L（LinkList&
L,intn）
//逆位序输入n个元素的值，建立带表头结点的单链线性表L
L=（LinkList）malloc（sizeof（LNode））;
L->
next=NULL;
//先建立一个带头结点的单链表
for（inti=n;
i>
0;
--i）
p=（LinkList）malloc（sizeof（LNode））;
scanf（"
%d"
&
p->
data）;
//输入元素值
p->
next=L->
next;
L->
next=p;
//插入到表头
}//CreateList_L
voiddisplay（LinkListL）
{LinkListp=L->
//定义for循环函数
while（p）
%d,"
p->
p=p->
LinkListL;
CreateList_L（L,3）;
ListInsert_L（L,2,100）;
ListDelete_L（L,2,e）;
被删除的值=%d\n"
GetElem_L（L,3,e）;
获取的值=%d\n"
第四次上机
typedefintSElemType;
#defineSTACK_INIT_SIZE100//存储空间初始分配量
#defineSTRCKINCREMENT10//存储空间分配增量
SElemType*base;
//在栈构造之前和销毁之后，base的值为NULL
SElemType*top;
//栈顶指针
intstacksize;
//当前已分配的存储空间，以元素为单位
}SqStack;
StatusInitStack（SqStack&
S）{
//构造一个空栈S
S.base=（SElemType*）malloc（STACK_INIT_SIZE*sizeof（SElemType））;
S.base）exit（OVERFLOW）;
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
}//InitStack
StatusGetTop（SqStackS,SElemType&
//若栈不空，则用e返回S的栈顶元素，并返回OK；
否则返回ERROR
if（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.base,（S.stacksize+STRCKINCREMENT）*sizeof（SElemType））;
S.top=S.base+S.stacksize;
S.stacksize+=STRCKINCREMENT;
*S.top++=e;
}//Push
StatusPop（SqStack&
S,SElemType&
//若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；
if（S.top==S.base）returnERROR;
e=*--S.top;
}//Pop
StatusStackEmpty（SqStackS）{
if（S.top==S.base）
returnTRUE;
elsereturnERROR;
voidconversion（）{
//对于输入的任意一个非负十进制整数，打印输出与其等值的八进制数
SqStackS;
intN;
SElemTypee;
InitStack（S）;
//构造空栈
scanf（"
N）;
while（N）{
Push（S,N%8）;
N=N/8;
转换成八进制后的数为：
"
while（!
StackEmpty（S））{
Pop（S,e）;
}//conversion
SElemTypee,x;
Push（S,5）;
Push（S,4）;
Push（S,3）;
Push（S,2）;
Push（S,1）;
GetTop（S,e）;
栈顶元素为%d\n"
Pop（S,x）;
删除的栈顶元素为%d\n"
x）;
输入一个十进制数：
conversion（）;
第五次上机
/*队列的链式存储*/
typedefintQElemType;
typedefstructQNode{
QElemTypedata;
structQNode*next;
}QNode,*QueuePtr;
QueuePtrfront;
//队头指针
QueuePtrrear;
//队尾指针
}LinkQueue;
StatusInitQueue（LinkQueue&
Q）{
//构造一个空队列Q
Q.front=Q.rear=（QueuePtr）malloc（sizeof（QNode））;
Q.front）exit（OVERFLOW）;
Q.front->
StatusDestroyQueue（LinkQueue&
//销毁队列Q
while（Q.front）{
Q.rear=Q.front->
free（Q.front）;
Q.front=Q.rear;
StatusEnQueue（LinkQueue&
Q,QElemTypee）{
//插入元素e为Q的新的队尾元素
QueuePtrp;
p=（QueuePtr）malloc（sizeof（QNode））;
p）exit（OVERFLOW）;
next=NULL;
Q.rear->
Q.rear=p;
StatusDeQueue（LinkQueue&
Q,QElemType&
//若队列不为空，则删除Q的队头元素，用e返回其值，并返回OK；
//否则返回ERROR
if（Q.front==Q.rear）returnERROR;
p=Q.front->
next=p->
if（Q.rear==p）
Q.rear=Q.front;
free（p）;
voiddisp（LinkQueueQ）
p=Q.front->
//定义for循环函数
%d"
LinkQueueQ;
QElemTypee;
InitQueue（Q）;
插入的元素为：
EnQueue（Q,25）;
EnQueue（Q,5）;
EnQueue（Q,12）;
EnQueue（Q,60）;
EnQueue（Q,33）;
disp（Q）;
删除队头元素后：
DeQueue（Q,e）;
DestroyQueue（Q）;
if（DestroyQueue（Q）==1）
销毁队列成功！
else
销毁队列失败！
附加：
/*队列的顺序存储*/
#defineMAXQSIZE100//最大队列长度
QElemType*base//初始化的动态分配存储空间
intfront;
//头指针，若队列不空，指向队列头元素
intrear;
//尾指针，若队列不空，指向队列尾元素的下一个位置
}SqQueue;
StatusInitQueue（SqQueue&
//构造一个空队列
Q.base=（QElemType*）malloc（MAXQSIZE*sizeof（QElemType））;
Q.base）exit（OVERFLOW）;
Q.front=Q.rear=0;
intQueueLenth（SqQueueQ）{
//返回Q的元素个数，即队列的长度
return（Q.rear-Q.front+MAXQSIZE）%MAXQSIZE;
StatusEnQueue（SqQueue&
if（（Q.rear+1）%MAXQSIZE==Q.front）returnERROR;
//队列满
Q.base
升级会员 