数据结构实验报告代码.docx

数据结构实验报告代码.docx

《数据结构实验报告代码.docx》由会员分享，可在线阅读，更多相关《数据结构实验报告代码.docx（34页珍藏版）》请在冰豆网上搜索。

数据结构实验报告代码

线性表

代码一

#include"stdio.h"

#include"malloc.h"

#defineOK1

#defineERROR0

#defineOVERFLOW-2

#defineLIST_INIT_SIZE100

#defineLISTINCREMENT10

typedefstruct{

int*elem;

intlength;

intlistsize;

}SqList;

intInitList_Sq（SqList*L）{

L->elem=（int*）malloc（LIST_INIT_SIZE*sizeof（int））;

if（!

L->elem）returnERROR;

L->length=0;

L->listsize=LIST_INIT_SIZE;

returnOK;

}

intListInsert_Sq（SqList*L,inti,inte）{

int*p,*newbase,*q;

if（i<1||i>L->length+1）returnERROR;

if（L->length>=L->listsize）{

newbase=（int*）realloc（L->elem,（L->listsize+LISTINCREMENT）*sizeof（int））;

if（!

newbase）returnERROR;

L->elem=newbase;

L->listsize+=LISTINCREMENT;

}

q=&（L->elem[i-1]）;//插入后元素后移

for（p=&（L->elem[L->length-1]）;p>=q;p--）

*（p+1）=*p;

*q=e;

L->length++;

returnOK;

}

intListDelete_Sq（SqList*L,inti,int*e）{

int*p,*q;

if（i<1||i>L->length）returnERROR;

p=&（L->elem[i-1]）;

*e=*p;

q=L->elem+L->length-1;

for（p=&L->elem[i-1];p

*p=*（p+1）;

--L->length;

returnOK;

}

intListLength_Sq（SqListL）//求顺序表的长度

{//实现此函数

printf（"链表长度为%d\n",L.length）;

return1;

}

intPrintList_Sq（SqListL）//输出顺序表中的元素

{//实现此函数

int*p,c=0;

for（p=&L.elem[c];c

{

printf（"第%d元素:

%d\n",c+1,L.elem[c]）;

}

return1;

}

//顺序表应用

voidReverse_SeqList（SqList*PL）//顺序表逆置

{

inti;

intx;

for（i=1;i<=PL->length/2;i++）

{

x=PL->elem[i-1];

PL->elem[i-1]=PL->elem[PL->length-i];

PL->elem[PL->length-i]=x;

}

}

intmain（）

{

SqListL;

inte,m,i,a,n=0;

InitList_Sq（&L）;

printf（"链表输入多少个元素n：

"）;

scanf（"%d",&m）;

for（a=0;a

{

i=a+1;

printf（"输入插入链表元素大小e：

"）;

scanf（"%d",&e）;ListInsert_Sq（&L,i,e）;

}

while（n!

=10）

{

printf（"

（1）出顺序表中的元素:

1

（2）删除指定的第i个元素:

2\n"）;

printf（"（3）输出顺序表的长度:

3（4）将顺序表逆置:

4\n"）;

printf（"（5）顺序链表插入元素:

5（6）退出:

6\n"）;

printf（"请输入你的选择:

"）;

scanf（"%d",&n）;

switch（n）

{

case1:

PrintList_Sq（L）;;break;

case2:

printf（"删除指定的第i个元素:

"）;

scanf（"%d",&i）;

ListDelete_Sq（&L,i,&e）;

printf（"删除元素大小为：

%d\n",e）;;break;

case3:

ListLength_Sq（L）;break;

case4:

Reverse_SeqList（&L）;break;

case5:

printf（"插入指定的第i个元素之前:

"）;

scanf（"%d",&i）;

printf（"插入元素大小为:

"）;

scanf（"%d",&e）;

ListInsert_Sq（&L,i,e）;break;

case6:

printf（"即将退出"）;n=10;break;

default:

printf（"输入错误\n"）;n=10;break;

}

}

return0;

}

代码二

#include"stdio.h"

#include"malloc.h"

#defineOK1

#defineERROR0

#defineOVERFLOW-2

//#defineNULL0

typedefstructLNode{

intdata;

structLNode*next;

}LNode,*LinkList;

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

LinkListCreateList_L（LinkListL,intn）//头插入法插入n个元素的值，建立带表头结点的单链线性表L

{

inti;

LinkListp,r;

L=（LinkList）malloc（sizeof（LNode））;//先建立一个带头结点的单链表

L->next=NULL;

r=L;

for（i=1;i<=n;i++）

{

p=（LinkList）malloc（sizeof（LNode））;

printf（"输入元素大小:

"）;

scanf（"%d",&p->data）;

p->next=r->next;

r->next=p;

}

returnL;

}//CreateList_L

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

intListInsert_L（LinkListL,inti,inte）//在带头结点的单链线性表L的第i个元素之前插入元素e

{

intj=0;

LinkListp,s;

s=（LinkList）malloc（sizeof（LNode））;

p=L;

while（p&&jnext;++j;}//寻找第i-1个结点

if（!

p||j>i-1）{printf（"%s\n","InsertERROR"）;returnERROR;}//i小于1或者大于表长

else{s->data=e;s->next=p->next;p->next=s;}

returnOK;

}//LinstInsert_L

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

intListDelete_L（LinkListL,inti,int*e）//在带头结点的单链线性表L中，删除第i个元素，并由e返回其值

{

LinkListp,q;

intj=0;

p=L;

while（p->next&&jnext;++j;}//寻找第i个结点，并令p指向其前趋

if（!

（p->next）||j>i-1）{printf（"%s\n","DeleteERROR"）;returnERROR;}//删除位置不合理

else{q=p->next;p->next=q->next;*e=q->data;free（q）;}

returnOK;

}//ListDelete_L

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

intListLength_L（LinkListL）

{//求单链表的长度

LinkListp;

intj=0;

p=L;

while（p）{p=p->next;++j;}//寻找第i-1个结点

printf（"结点个数为:

%d\n",j-1）;

returnOK;

}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

intListPrint_L（LinkListL）//对单链表输出

{

intj=0;

LinkListp;

p=（LinkList）malloc（sizeof（LNode））;

p=L;

while（p->next）

{

j++;

p=p->next;

printf（"第%d元素大小为:

%d\n",j,p->data）;

}

returnOK;

}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

voidInvertList（LinkListL）//单链表逆置

{

LinkListp,q;

p=L->next;

L->next=NULL;

while（p）{

q=p->next;

p->next=L->next;

L->next=p;

p=q;

}

printf（"单链表逆置完成！

！

！

\n"）;

}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

intmain（）

{

inte,m,n,i;

LinkListhead;

printf（"输入所要输入元素的个数n="）;

scanf（"%d",&m）;

head=CreateList_L（head,m）;//单链表中插入n个元素，其中n由程序输入。

while（n!

=10）

{

printf（"\n"）;

printf（"

（1）输出单链表中的元素:

1

（2）删除指定的第i个元素:

2\n"）;

printf（"（3）指定位置前加入元素:

3（4）输出单链表的长度:

4\n"）;

printf（"（5）单链表逆置:

5（6）退出:

6\n"）;

printf（"输入你的选择:

"）;

scanf（"%d",&n）;

switch（n）

{

case1:

ListPrint_L（head）;break;

case2:

printf（"输入删除第几个元素:

"）;

scanf（"%d",&i）;

ListDelete_L（head,i,&e）;

printf（"删除的元素大小为:

%d\n",e）;break;

case3:

printf（"输入要插入的位置:

"）;

scanf（"%d",&i）;

printf（"输入插入元素大小:

"）;

scanf（"%d",&e）;

ListInsert_L（head,i,e）;break;

case4:

ListLength_L（head）;break;

case5:

InvertList（head）;break;

case6:

printf（"即将退出"）;n=10;break;

default:

printf（"输入错误\n"）;n=10;break;

}

}

returnERROR;

}

//输出单链表中的元素。

//删除指定的第i个元素，并且用e返回删除元素的值，输出e的值，其中i由程序输入。

//输出单链表中的元素\

//输出单链表的长度

//单链表逆置

栈

#include"stdio.h"

#include"malloc.h"

#defineOK1

#defineERROR0

#defineINIT_SIZE100

#defineINCREMENT10

typedefintSElemType;

typedefstruct{

SElemType*base;

SElemType*top;

intstacksize;//栈的可用最大容量

}SqStack;

intInitStack（SqStack*S）{//创建一个空栈S

（*S）.base=（SElemType*）malloc（INIT_SIZE*sizeof（SElemType））;

if（!

（*S）.base）

returnERROR;

（*S）.top=（*S）.base;

（*S）.stacksize=INIT_SIZE;

returnOK;

}

intStackEmpty（SqStack*S）//判断栈是否为空，为空则返回1，否则返回0

{

if（（*S）.top==（*S）.base）

return1;

else

return0;

}

intGetTop（SqStackS,SElemType*e）//取出栈顶元素

{

if（S.top>S.base）

{

*e=*（S.top-1）;

printf（"栈顶元素是:

%d",*e）;

printf（"\n"）;

returnOK;

}

else

returnERROR;

}

intPush（SqStack*S,SElemTypee）

{//将数据元素e入栈

if（（*S）.top-（*S）.base>=（*S）.stacksize）

{

（*S）.base=（SElemType*）realloc（（*S）.base,（（*S）.stacksize+INCREMENT）*sizeof（SElemType））;

if（!

（*S）.base）

return0;

（*S）.top=（*S）.base+（*S）.stacksize;

（*S）.stacksize+=INCREMENT;

}

*（（*S）.top）=e;

（*S）.top++;

returnOK;

}

intPop（SqStack*S,SElemType*e）//如栈不为空，将栈顶元素出栈

{

if（（*S）.top==（*S）.base）

returnERROR;

（*S）.top--;

e=（*S）.top;

printf（"%d",*e）;

returnOK;

}

intPrint_SqStackTraverse（SqStack*S）//输出栈中元素

{//实现此函数

if（（*S）.top==（*S）.base）returnERROR;

printf（"栈中元素是"）;

while（（*S）.top!

=（*S）.base）

{

（*S）.top--;

printf（"%d",*（*S）.top）;

}

printf（"\n"）;

returnOK;

}

voidconversion（SqStack*S,intN,intr）//把十进制数N转换为r进制

{//实现此函数

（*S）.top=（*S）.base;

while（N!

=0）

{

*（（*S）.top）=N%r;

（*S）.top++;

N=N/r;

}

printf（"\n该数的%d进制数为:

",r）;

while（（*S）.top!

=（*S）.base）

{

（*S）.top--;

printf（"%d",*（*S）.top）;

}

printf（"\n"）;

}

main（）

{

inti,N,r;

SqStackS;

SElemTypee;

InitStack（&S）;//创建栈点

StackEmpty（&S）;//栈是否为空

for（i=1;i<=4;i++）//将1,2,3,4入栈

{

Push（&S,i）;

}

GetTop（S,&e）;//输出栈顶元素

Print_SqStackTraverse（&S）;//输出栈中所有元素

/////////////////////////////////////////////

printf（"按照1,2,3,4的顺序依次入栈，输出三种不同的出栈序列：

\n"）;//按照1,2,3,4的顺序依次入栈，输出三种不同的出栈序列

printf（"

（1）"）;

Push（&S,1）;Pop（&S,&e）;Push（&S,2）;Pop（&S,&e）;Push（&S,3）;Pop（&S,&e）;Push（&S,4）;Pop（&S,&e）;printf（"\n"）;

printf（"

（2）"）;

Push（&S,1）;Pop（&S,&e）;Push（&S,2）;Push（&S,3）;Pop（&S,&e）;Pop（&S,&e）;Push（&S,4）;Pop（&S,&e）;printf（"\n"）;

printf（"（3）"）;

Push（&S,1）;Push（&S,2）;Push（&S,3）;Pop（&S,&e）;Pop（&S,&e）;Pop（&S,&e）;Push（&S,4）;Pop（&S,&e）;printf（"\n"）;

//////////////////////////////////////////////////////////////////

printf（"输入十进制数：

"）;

scanf（"%d",&N）;

printf（"\n输入转换的进制数:

"）;

scanf（"%d",&r）;

conversion（&S,N,r）;//将十进制数20转化为8进制数

return0;

}

队列

#include"stdio.h"

#include"malloc.h"

#defineOK1

#defineERROR0

#defineMAXQSIZE10/*最大队列长度+1*/

typedefintQElemType;

typedefstruct{

QElemType*base;

intfront;

intrear;

}SqQueue;

/////////////////////////////////////////////////////////////////////////////////////////////////////////

intInitQueue（SqQueue*Q）{//初始化循环队列

Q->base=（QElemType*）malloc（MAXQSIZE*sizeof（QElemType））;

if（!

Q->base）returnERROR;

Q->front=Q->rear=0;

returnOK;

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////

intEnQueue（SqQueue*Q,QElemTypee）

{

if（（Q->rear+1）%MAXQSIZE==Q->front）//队列满

returnERROR;

elseQ->base[Q->rear]=e;

Q->rear=（Q->rear+1）%MAXQSIZE;//⑴

returnOK;

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////

intDeQueue（SqQueue*Q,QElemType*e）

{

if（Q->front==Q->rear）//队列空

returnERROR;

*e=Q->base[Q->front];

Q->front=（Q->front+1）%MAXQSIZE;//⑵

returnOK;

}

/////////////////////////////////////////////////////////////////////////////////////////////////////////

intQueueLength（SqQueueQ）

{

return（Q.rear-Q.front+MAXQSI