数据结构实验.docx

数据结构实验.docx

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

数据结构实验

《数据结构》

实验报告

学号

089074375

姓名

张涛

班级

网络工程083

指导教师

储岳中

安徽工业大学计算机学院

实验一　线性表基本操作的实现

#include"stdio.h"

#include"stdlib.h"

#defineMAXSIZE100

structSeqList

{

intdata[MAXSIZE];

intlength;

};

typedefstructSeqList*PSeqList;

PSeqListcreaeNullList_seq（）/*创建空线性表*/

{

PSeqListpalist=（PSeqList）malloc（sizeof（structSeqList））;

if（palist!

=NULL）

{

palist->length=0;

return（palist）;

}

printf（"Outofspace!

!

\n"）;

returnNULL;

}

intisNullList_seq（PSeqListpalist）/*判断是否空线性表*/

{

return（palist->length==0）;

}

intLocation_SeqList（SeqListpalist,intx）

{

inti=0;

while（i

=x）

i++;

if（i>=palist.length）return0;

elsereturn（i+1）;

printf（"%d",x）;

}

intinsertPre_seq（PSeqListpalist,intp,intx）

{

intq;

if（palist->length>=MAXSIZE）

{

printf（"overflow!

\n"）;

return（0）;

}

if（p<0||p>palist->length）

{

printf（"Notexist!

\n"）;

return（0）;

}

if（isNullList_seq（palist））

{

palist->data[0]=x;

palist->length=1;

return

（1）;

}

for（q=palist->length-1;q>=p;q--）

palist->data[q+1]=palist->data[q];

palist->data[p]=x;

palist->length=palist->length+1;

return

（1）;

}

intDelete_SeqList（PSeqListpalist,inti）

{

intj;

if（!

palist）

{

printf（"表不存在"）;

return（-1）;

}

if（i<1||i>palist->length）

{

printf（"删除位置不合法"）;

return（0）;

}

for（j=i;jlength;j++）

palist->data[j-1]=palist->data[j];

palist->length--;

return

（1）;

}

voidmain（）

{

inti;

PSeqListlist;

list=creaeNullList_seq（）;

printf（"插入前的顺序表为：

\n"）;

for（i=0;i<=9;i++）

{

insertPre_seq（list,i,i*i）;

printf（"%d",list->data[i]）;

}

insertPre_seq（list,5,55）;

printf（"\n\n插入后的顺序表为：

\n"）;

for（i=0;ilength;i++）

printf（"%d",list->data[i]）;

printf（"\n\n"）;

printf（"删除后的顺序表为\n\n"）;

Delete_SeqList（list,5）;

for（i=0;ilength;i++）

printf（"%d",list->data[i]）;

printf（"\n"）;

}

实验二栈的基本操作

#include

#include

#defineMAXSIZE100

typedefstructnode{

intdata[MAXSIZE];

inttop;

}SeqStack,*PSeqStack;

PSeqStackInit_SeqStack（void）

{

PSeqStackS;

S=（PSeqStack）malloc（sizeof（SeqStack））;

if（S）

S->top=-1;

returnS;

}

intPush_PSeqStack（PSeqStackS,intx）

{

if（S->top==MAXSIZE-1）

return0;

else

{

S->top++;

S->data[S->top]=x;

return1;

}

}

intPop_PSeqStack（PSeqStackS,int*x）

{

if（S->top==-1）

return0;

else

{

*x=S->data[S->top];

S->top--;

return1;

}

}

intEmpty_SeqStack（PSeqStackS）

{

if（S->top==-1）

return1;

else

return0;

}

intconversion（intn,intr）

{

PSeqStackS;

intx;

if（!

r）

{

printf（"基数不能为0"）;

return（0）;

}

S=Init_SeqStack（）;

if（!

S）

{

printf（"栈表初始化失败"）;

return（0）;

}

while（n）

{

Push_PSeqStack（S,n%r）;

n=n/r;

}

while（!

Empty_SeqStack（S））

{

Pop_PSeqStack（S,&x）;

printf（"%d",x）;

}

return1;

}

voidmain（）

{

PSeqStackInit_SeqStack（）;

intPush_PSeqStack（PSeqStackS,intx）;

intPop_PSeqStack（PSeqStackS,intx）;

intconversion（intn,intr）;

intn,r;

printf（"请输入数和进制:

\n"）;

scanf（"%d,%d",&n,&r）;

printf（"转换后的数为:

\n"）;

conversion（n,r）;

printf（"\n"）;

}

实验三串的模式匹配

#include"stdio.h"

voidGetNext1（char*t,intnext[]）/*求模式t的next值并寸入next数组中*/

{

inti=1,j=0;

next[1]=0;

while（i<=9）//t[0]

{

if（j==0||t[i]==t[j]）

{++i;++j;next[i]=j;}

else

j=next[j];

}

}

voidGetNext2（char*t,intnext[]）/*求模式t的next值并放入数组next中*/

{

inti=1,j=0;

next[1]=0;/*初始化*/

while（i<=9）/*计算next[i+1]t[0]*/

{

while（j>=1&&t[i]!

=t[j]）

j=next[j];

i++;j++;

if（t[i]==t[j]）next[i]=next[j];

elsenext[i]=j;

}

}

voidmain（）

{

char*p="abcaababc";

inti,str[10];

GetNext1（p,str）;

printf（"\n"）;

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

printf（"%d",str[i]）;

GetNext2（p,str）;

printf（"\n"）;

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

printf（"%d",str[i]）;

printf（"\n\n"）;

}

实验四二叉树操作

原参考代码：

#definemax30

#defineNULL0

#include

#include

typedefstructBNode

{

chardata;//数据域

structBNode*lchild,*rchild;;//指向左右子女

}BinTree;

voidpreorder（BinTree*t）;//声明先根遍历函数

voidinorder（BinTree*t）;//声明中根遍历函数

voidpostorder（BinTree*t）;//声明后根遍历函数

intleafs（BinTree*b）;//声明求叶子数函数

inttreedeep（BinTree*p）;//声明求树的深度函数

BinTree*swap（BinTree*p）;//声明交换二叉树的所有结点的左右子树的函数

//将字符串中的第i个字符开始的m个字符作为数据生成对应的二叉树

BinTree*cre_tree（char*str,inti,intm）

{

BinTree*p;

if（i>=m）//无效结点

returnNULL;

p=（BinTree*）malloc（sizeof（BinTree））;//生成新结点

p->data=str[i];

p->lchild=cre_tree（str,2*i+1,m）;//创建新结点的左子树

p->rchild=cre_tree（str,2*i+2,m）;//创建新结点的右子树

returnp;

}

voidmain（）

{

inti,n;

charstr[max];

BinTree*root;//根结点

printf（"请输入二叉树的结点数:

"）;

scanf（"%d",&n）;

getchar（）;//输入数字

printf（"请输入长度为%d的字符串:

",n）;

for（i=0;i

scanf（"%c",&str[i]）;

printf（"\n"）;

root=cre_tree（str,0,n）;

printf（"二叉树已成功创建!

结点序列为：

"）;

for（i=0;i

printf（"%c",str[i]）;

printf（"\n"）;

//先根遍历

printf（"\n先根遍历结果:

"）;

preorder（root）;

printf（"\n"）;

//中根遍历

printf（"\n中根遍历结果:

"）;

inorder（root）;

printf（"\n"）;

//后根遍历

printf（"\n后根遍历结果:

"）;

postorder（root）;

printf（"\n"）;

printf（"\n叶子数为：

%d\n",leafs（root））;

printf（"\n树的深度为：

%d\n",treedeep（root））;

printf（"\n交换左右子树后先序遍历序列为：

"）;

preorder（swap（root））;

printf（"\n\n"）;

}

voidpreorder（BinTree*t）

{

if（t!

=NULL）

{

printf（"%c",t->data）;

if（t->lchild）

{

printf（"->"）;

preorder（t->lchild）;

}

if（t->rchild）

{

printf（"->"）;

preorder（t->rchild）;

}

}

}

voidinorder（BinTree*t）

{

if（t!

=NULL）

{

inorder（t->lchild）;

printf（"%c",t->data）;

inorder（t->rchild）;

}

}

voidpostorder（BinTree*t）

{

if（t!

=NULL）

{

postorder（t->lchild）;

postorder（t->rchild）;

printf（"%c",t->data）;

}

}

intleafs（BinTree*b）//求叶子数

{

intnum1,num2;

if（b==NULL）return（0）;

elseif（b->lchild==NULL&&b->rchild==NULL）return

（1）;

else

{

num1=leafs（b->lchild）;

num2=leafs（b->rchild）;

return（num1+num2）;

}

}

inttreedeep（BinTree*p）//求树的深度

{

intldeep,rdeep,deep;

if（p==NULL）deep=0;

else

{

ldeep=treedeep（p->lchild）;

rdeep=treedeep（p->rchild）;

deep=（ldeep>rdeep?

ldeep:

rdeep）+1;

}

returndeep;

}

BinTree*swap（BinTree*p）//交换二叉树的所有结点的左右子树

{

BinTree*stack[max];

intk=0;

stack[k]=NULL;

if（p!

=NULL）

{

stack[++k]=p->lchild;

p->lchild=p->rchild;

p->rchild=stack[k];

p->lchild=swap（p->lchild）;

p->rchild=swap（p->rchild）;

}

returnp;

}

改后非完全二叉树代码：

#include

#include

#defineMAXSIZE100

typedefstructbnode{

chardata;

structbnode*lchild,*rchild;

}Bnode,*BTree;

typedefstruct{

BTreedata[MAXSIZE];

inttop;

}SeqStack,*PSeqStack;

voidVist（BTreet）

{

BTreep=t;

while（p!

=NULL）

{

printf（"%c",p->data）;

}

returnp;

}

PSeqStackInit_SeqStack（void）

{

PSeqStackS;

S=（PSeqStack）malloc（sizeof（SeqStack））;

if（S）

S->top=-1;

returnS;

}

PSeqStackPush_SeqStack（PSeqStackS,BTreex）

{

if（S->top==MAXSIZE-1）

return0;

else

{

S->top++;

S->data[S->top]=x;

returnS;

}

}

intPop_SeqStack（PSeqStackS,BTree*x）

{

*x=S->data[S->top];

S->top--;

return1;

}

BTreeCreateBinTree（）

{

BTreet;

charch;

ch=getchar（）;

if（ch=='#'）t=NULL;

else

{

t=（Bnode*）malloc（sizeof（Bnode））;

t->data=ch;

t->lchild=CreateBinTree（）;

t->rchild=CreateBinTree（）;

}

returnt;

}

voidPreOrder（BTreet）

{

PSeqStackS;

BTreep=t;

S=Init_SeqStack（）;

while（p||（S->top!

=-1））

{

if（p）

{

printf（"%c",p->data）;

printf（"->"）;

Push_SeqStack（S,p）;

p=p->lchild;

}

else

{

Pop_SeqStack（S,&p）;

p=p->rchild;

}

}

}

voidInOrder（BTreet）

{

PSeqStackS;

BTreep=t;

S=Init_SeqStack（）;

while（p||S->top!

=-1）

{

if（p）

{

Push_SeqStack（S,p）;

p=p->lchild;

}

else

{

Pop_SeqStack（S,&p）;

printf（"%c",p->data）;

//Vist（p）;

printf（"->"）;

p=p->rchild;

}

}

}

voidPostOrder（BTreet）

{

PSeqStackS;

BTreep=t;

S=Init_SeqStack（）;

while（p||S->top!

=-1）

{

if（p）

{

Push_SeqStack（S,p）;

p=p->lchild;

}

else

{

Pop_SeqStack（S,&p）;

p=p->rchild;

printf（"->"）;

printf（"%c",p->data）;

}

}

}

voidmain（）

{

BTreet;

BTreeCreateBinTree（）;

voidPreOrder（BTreet）;

voidInOrder（BTreet）;

voidPostOrder（BTreet）;

//voidVist（BTreet）;

printf（"初始化树:

\n"）;

t=CreateBinTree（）;

printf（"先序遍历结果\n"）;

PreOrder（t）;

printf（"\n"）;

printf（"中序遍历结果\n"）;

InOrder（t）;

printf（"\n"）;

printf（"后序遍历结果\n"）;

PostOrder（t）;

printf（"\n"）;

}

实验五图的创建与遍历.

#defineMaxVerNum100/*最大顶点数为*/

typedefenum{False,True}boolean;

#include"stdio.h"

#include"stdlib.h"

booleanvisited[MaxVerNum];

typedefstructnode/*表结点*/

{

intadjvex;/*邻接点域,一般是放顶点对应的序号或在表头向量中的下标*/

charInfo;/*与边（或弧）相关的信息*/

structnode*next;/*指向下一个邻接点的指针域*/

}EdgeNode;

typedefstructvnode/*顶点结点*/

{

charvertex;/*顶点域*/

EdgeNode*firstedge;/*边表头指针*/

}VertexNode;

typedefstruct

{

VertexNodeadjlist[MaxVerNum];/*邻接表*/

intn,e;/*顶点数和边数*/

}ALGraph;/*ALGraph是以邻接表方式存储的图类型*/

typedefstruct

{

intdata[MaxVerNum];

intfront,rear;

}SeqQueue,*PSeqQueue;/*顺序存储结构的队列*/

PSeqQueueInit_SeqQueue（）/*初始化队列*/

{

PSeqQueueQ;

Q=（PSeqQueue）malloc（sizeof（SeqQueue））;

if（Q）

{

Q->front=0;

Q->rear=0;

}

returnQ;

}

intEmpty_SeqQueue（PSeqQueueQ）

{

if（Q&&Q->front==Q->rear）

return

（1）;

else

return（0）;

}

intIn_SeqQueue（PSeqQueueQ,intx）

{

if（（Q->rear+1）%MaxVerNum==Q->front）

{

printf（"\n队满，不能入队!

"）;

return（-1）;

}

else

{

Q->rear=（Q->rear+1）%MaxVerNum;

Q->data[Q->rear]=x;

return

（1）;

}

}

intOut_SeqQueue（PSeqQueueQ,int*x）

{

if（Empty_SeqQueue（Q））

{

printf（"