数据结构上机代码整理.docx
《数据结构上机代码整理.docx》由会员分享，可在线阅读，更多相关《数据结构上机代码整理.docx（23页珍藏版）》请在冰豆网上搜索。
数据结构上机代码整理
数据结构
第一、二次上机：
#include
#include
#include
#defineTRUE1
#defineFALSE0
#defineOK1
#defineERROR0
#defineINFEASIBLE-1
#defineOVERFLOW-2
#definelist_init_size100//线性表存储空间的初始分配量
#defineLISTINCREMENT10//线性表存储空间的分配增量
typedefintStatus;
typedefintElemType;
typedefstruct{
ElemType*elem;//存储空间基址
intlength;//当前长度
intlistsize;//当前分配的存储容量（以sizeof（ElemType）为单位）
}SqList;
StatusInitList_Sq（SqList&L）{
//构造一个空的线性表L
L.elem=（ElemType*）malloc（list_init_size*sizeof（ElemType））;
if（!
L.elem）exit（OVERFLOW）;//存储分配失败
L.length=0;//空表长度为0
L.listsize=list_init_size;//初始存储容量
returnOK;
}//Initlist_Sq
StatusListInsert_Sq（SqList&L,inti,ElemTypee）{
//在顺序线性表L中第i个位置之前插入新的元素e，
//i的合法值为1<=i<=ListLength_Sq（L）+1
ElemType*p,*q,*newbase;//定义指针
if（i<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
returnOK;
}//ListInsert_Sq
StatusListDelete_Sq（SqList&L,inti,ElemType&e）{
//在顺序线性表L中删除第i个元素，并用e返回其值
//i的合法值为1<=i<=ListLength_Sq（L）
ElemType*p,*q;//定义指针
if（（i<1）||（i>L.length））
returnERROR;//i值不合法
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
returnOK;
}//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;
if（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））;
if（!
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++;
}
while（pa<=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
printf（"插入后：
\n"）;
display（L）;
ElemTypee;//定义e
ListDelete_Sq（L,3,e）;//删除L表的第三个元素，用e表示
printf（"删除后：
\n"）;
display（L）;
printf（"被删除元素：
%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）;
printf（"La插入后：
\n"）;
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）;
printf（"Lb插入后：
\n"）;
display（Lb）;
MergeList_Sq（La,Lb,Lc）;
printf（"归并后：
\n"）;
display（Lc）;
printf（"\n"）;
inta=LocateElem_Sq（Lc,5）;
printf（"%d\n",a）;
}
第三次上机：
#include
#include
#defineTRUE1
#defineFALSE0
#defineOK1
#defineERROR0
#defineINFEASIBLE-1
#defineOVERFLOW-2
typedefintStatus;
typedefintElemType;
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{
//顺指针向后查找，直到p指向第i个元素或p为空
p=p->next;
++j;
}
if（!
p||j>i）
returnERROR;//第i个元素不存在
e=p->data;//取第i个元素
returnOK;
}//GetElem_L
StatusListInsert_L（LinkList&L,inti,ElemTypee）
{
//在带头结点的单链线性表L中第i个位置之前插入元素e
LinkListp,s;
p=L;
intj=0;
while（p&&j{
p=p->next;
++j;
}//寻找第i-1个结点
if（!
p||j>i-1）returnERROR;//i小于或者大于表长+1
s=（LinkList）malloc（sizeof（LNode））;//生成新结点
s->data=e;
s->next=p->next;//插入L中
p->next=s;
returnOK;
}//ListInsert_L
StatusListDelete_L（LinkList&L,inti,ElemType&e）
{
//在带头结点的单链线性表L中，删除第i个元素，并由e返回其值
LinkListp,q;
p=L;
intj=0;
while（p->next&&j{
//寻找第i个结点，并令p指向其前趋
p=p->next;++j;
}
if（!
（p->next）||j>i-1）returnERROR;//删除位置不合理
q=p->next;
p->next=q->next;//删除并释放结点
e=q->data;
free（q）;
returnOK;
}//ListDelete_L
voidCreateList_L（LinkList&L,intn）
{
//逆位序输入n个元素的值，建立带表头结点的单链线性表L
LinkListp;
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->next;
//定义for循环函数
while（p）
{
printf（"%d,",p->data）;
p=p->next;
}
printf（"\n"）;
}
voidmain（）
{
LinkListL;
CreateList_L（L,3）;
display（L）;
ListInsert_L（L,2,100）;
display（L）;
ElemTypee;
ListDelete_L（L,2,e）;
display（L）;
printf（"被删除的值=%d\n",e）;
GetElem_L（L,3,e）;
printf（"获取的值=%d\n",e）;
}
第四次上机
#include
#include
#include
#defineTRUE1
#defineFALSE0
#defineOK1
#defineERROR0
#defineINFEASIBLE-1
#defineOVERFLOW-2
typedefintSElemType;
typedefintStatus;
#defineSTACK_INIT_SIZE100//存储空间初始分配量
#defineSTRCKINCREMENT10//存储空间分配增量
typedefstruct{
SElemType*base;//在栈构造之前和销毁之后，base的值为NULL
SElemType*top;//栈顶指针
intstacksize;//当前已分配的存储空间，以元素为单位
}SqStack;
StatusInitStack（SqStack&S）{
//构造一个空栈S
S.base=（SElemType*）malloc（STACK_INIT_SIZE*sizeof（SElemType））;
if（!
S.base）exit（OVERFLOW）;//存储分配失败
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
returnOK;
}//InitStack
StatusGetTop（SqStackS,SElemType&e）{
//若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR
if（S.top==S.base）
returnERROR;
e=*（S.top-1）;
returnOK;
}//GetTop
StatusPush（SqStack&S,SElemTypee）{
//插入元素e为新的栈顶元素
if（S.top-S.base>=S.stacksize）{
//栈满，追加存储空间
S.base=（SElemType*）realloc（S.base,（S.stacksize+STRCKINCREMENT）*sizeof（SElemType））;
if（!
S.base）exit（OVERFLOW）;//存储分配失败
S.top=S.base+S.stacksize;
S.stacksize+=STRCKINCREMENT;
}
*S.top++=e;
returnOK;
}//Push
StatusPop（SqStack&S,SElemType&e）{
//若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR
if（S.top==S.base）returnERROR;
e=*--S.top;
returnOK;
}//Pop
StatusStackEmpty（SqStackS）{
if（S.top==S.base）
returnTRUE;
elsereturnERROR;
}
voidconversion（）{
//对于输入的任意一个非负十进制整数，打印输出与其等值的八进制数
SqStackS;
intN;
SElemTypee;
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（"\n"）;
}//conversion
voidmain（）
{
SqStackS;
SElemTypee,x;
InitStack（S）;
Push（S,5）;
Push（S,4）;
Push（S,3）;
Push（S,2）;
Push（S,1）;
GetTop（S,e）;
printf（"栈顶元素为%d\n",e）;
printf（"\n"）;
Pop（S,x）;
printf（"删除的栈顶元素为%d\n",x）;
printf（"\n"）;
printf（"输入一个十进制数：
"）;
conversion（）;
}
第五次上机
/*队列的链式存储*/
#include
#include
#include
#defineTRUE1
#defineFALSE0
#defineOK1
#defineERROR0
#defineINFEASIBLE-1
#defineOVERFLOW-2
typedefintQElemType;
typedefintStatus;
typedefstructQNode{
QElemTypedata;
structQNode*next;
}QNode,*QueuePtr;
typedefstruct{
QueuePtrfront;//队头指针
QueuePtrrear;//队尾指针
}LinkQueue;
StatusInitQueue（LinkQueue&Q）{
//构造一个空队列Q
Q.front=Q.rear=（QueuePtr）malloc（sizeof（QNode））;
if（!
Q.front）exit（OVERFLOW）;//存储分配失败
Q.front->next=NULL;
returnOK;
}
StatusDestroyQueue（LinkQueue&Q）{
//销毁队列Q
while（Q.front）{
Q.rear=Q.front->next;
free（Q.front）;
Q.front=Q.rear;
}
returnOK;
}
StatusEnQueue（LinkQueue&Q,QElemTypee）{
//插入元素e为Q的新的队尾元素
QueuePtrp;
p=（QueuePtr）malloc（sizeof（QNode））;
if（!
p）exit（OVERFLOW）;//存储分配失败
p->data=e;
p->next=NULL;
Q.rear->next=p;
Q.rear=p;
returnOK;
}
StatusDeQueue（LinkQueue&Q,QElemType&e）{
//若队列不为空，则删除Q的队头元素，用e返回其值，并返回OK；
//否则返回ERROR
QueuePtrp;
if（Q.front==Q.rear）returnERROR;
p=Q.front->next;
e=p->data;
Q.front->next=p->next;
if（Q.rear==p）
Q.rear=Q.front;
free（p）;
returnOK;
}
voiddisp（LinkQueueQ）
{
QueuePtrp;
p=Q.front->next;
//定义for循环函数
while（p）
{
printf（"%d",p->data）;
p=p->next;
}
printf（"\n"）;
}
voidmain（）
{
LinkQueueQ;
QElemTypee;
InitQueue（Q）;
printf（"插入的元素为：
\n"）;
EnQueue（Q,25）;
EnQueue（Q,5）;
EnQueue（Q,12）;
EnQueue（Q,60）;
EnQueue（Q,33）;
disp（Q）;
printf（"删除队头元素后：
\n"）;
DeQueue（Q,e）;
disp（Q）;
DestroyQueue（Q）;
if（DestroyQueue（Q）==1）
printf（"销毁队列成功！
\n"）;
else
printf（"销毁队列失败！
\n"）;
}
附加：
/*队列的顺序存储*/
#defineMAXQSIZE100//最大队列长度
typedefstruct{
QElemType*base//初始化的动态分配存储空间
intfront;//头指针，若队列不空，指向队列头元素
intrear;//尾指针，若队列不空，指向队列尾元素的下一个位置
}SqQueue;
StatusInitQueue（SqQueue&Q）{
//构造一个空队列
Q.base=（QElemType*）malloc（MAXQSIZE*sizeof（QElemType））;
if（!
Q.base）exit（OVERFLOW）;//存储分配失败
Q.front=Q.rear=0;
returnOK;
}
intQueueLenth（SqQueueQ）{
//返回Q的元素个数，即队列的长度
return（Q.rear-Q.front+MAXQSIZE）%MAXQSIZE;
}
StatusEnQueue（SqQueue&Q,QElemTypee）{
//插入元素e为Q的新的队尾元素
if（（Q.rear+1）%MAXQSIZE==Q.front）returnERROR;//队列满
Q.base
升级会员 