数据结构严蔚敏上机代码完整版.docx

数据结构严蔚敏上机代码完整版.docx

《数据结构严蔚敏上机代码完整版.docx》由会员分享，可在线阅读，更多相关《数据结构严蔚敏上机代码完整版.docx（22页珍藏版）》请在冰豆网上搜索。

数据结构严蔚敏上机代码完整版

数据结构

第一、二次上机：

#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[Q.rear]=e;

Q.rear=（Q.rear+1）%MAXQSIZE;

returnOK;