数据结构实验报告全集.docx

数据结构实验报告全集.docx

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

数据结构实验报告全集

数据结构实验报告全集

实验一线性表基本操作和简单程序

1．实验目的

（1）掌握使用VisualC++6.0上机调试程序的基本方法；

（2）掌握线性表的基本操作：

初始化、插入、删除、取数据元素等运算在顺序存储结构和链表存储结构上的程序设计方法。

2．实验要求

（1）认真阅读和掌握和本实验相关的教材容。

（2）认真阅读和掌握本章相关容的程序。

（3）上机运行程序。

（4）保存和打印出程序的运行结果，并结合程序进行分析。

（5）按照你对线性表的操作需要，重新改写主程序并运行，打印出文件清单和运行结果

实验代码：

1）头文件模块

#includeiostream.h>//头文件

#include//库头文件-----动态分配存空间

typedefintelemtype;//定义数据域的类型

typedefstructlinknode//定义结点类型

{

elemtypedata;//定义数据域

structlinknode*next;//定义结点指针

}nodetype;

2）创建单链表

nodetype*create（）//建立单链表，由用户输入各结点data域之值，

//以0表示输入结束

{

elemtyped;//定义数据元素d

nodetype*h=NULL,*s,*t;//定义结点指针

inti=1;

cout<<"建立一个单链表"<

while

（1）

{

cout<<"输入第"<

";

cin>>d;

if（d==0）break;//以0表示输入结束

if（i==1）//建立第一个结点

{

h=（nodetype*）malloc（sizeof（nodetype））;//表示指针h

h->data=d;h->next=NULL;t=h;//h是头指针

}

else//建立其余结点

{

s=（nodetype*）malloc（sizeof（nodetype））;

s->data=d;s->next=NULL;t->next=s;

t=s;//t始终指向生成的单链表的最后一个节点

}

i++;

}

returnh;

}

3）输出单链表中的元素

voiddisp（nodetype*h）//输出由h指向的单链表的所有data域之值

{

nodetype*p=h;

cout<<"输出一个单链表:

"<

if（p==NULL）cout<<"空表";

while（p!

=NULL）

{

cout<data<<"";p=p->next;

}

cout<

}

4）计算单链表的长度

intlen（nodetype*h）//返回单链表的长度

{

inti=0;

nodetype*p=h;

while（p!

=NULL）

{

p=p->next;i++;

}

returni;

}

5）寻找第i个节点

nodetype*find（nodetype*h,inti）//返回第i个节点的指针

{

nodetype*p=h;

intj=1;

if（i>len（h）||i<=0）

returnNULL;//i上溢或下溢c

else

{

while（p!

=NULL&&j<1）//查找第i个节点，并由p指向该节点

{

j++;p=p->next;

}

returnp;

}

}

6）单链表的插入操作

nodetype*ins（nodetype*h,inti,elemtypex）//在单链表head中第i个节点

//（i>=0）之后插入一个data域为x的节点

{

nodetype*p,*s;

s=（nodetype*）malloc（sizeof（nodetype））;//创建节点s

s->data=x;s->next=NULL;

if（i==0）//i=0:

s作为该单链表的第一个节点

{

s->next=h;h=s;

}

else

{p=find（h,i）;//查找第i个节点，并由p指向该节点

if（p!

=NULL）

{

s->next=p->next;

p->next=s;

}

returnh;

}

}

7）单链表的删除操作

nodetype*del（nodetype*h,inti）//删除第i个节点

{

nodetype*p=h,*s;

intj=1;

if（i==1）//删除第1个节点

{

h=h->next;free（p）;

}

else

{

p=find（h,i-1）;//查找第i-1个节点，并由p指向该节点

if（p!

=NULL&&p->next!

=NULL）

{

s=p->next;//s指向要删除的节点

p->next=s->next;

free（s）;

}

elsecout<<"输入i的值不正确"<

}

returnh;

}

8）释放节点空间

voiddispose（nodetype*h）//释放单链表的所有节点占用的空间

{

nodetype*pa=h,*pb;

if（pa!

=NULL）

{

pb=pa->next;

if（pb==NULL）//只有一个节点的情况

free（pa）;

else

{

while（pb!

=NULL）//有两个及以上节点的情况

{

free（pa）;pa=pb;pb=pb->next;

}

free（pa）;

}

}

}

9）主程序模块:

#include"slink.h"//包含头文件slink

voidmain（）

{

nodetype*head;//定义节点指针变量

head=create（）;//创建一个单链表

disp（head）;//输出单链表

cout<<"单链表长度:

"<

ins（head,2,0）;//在第二个节点之后插入以0为元素的节点

disp（head）;//输出新链表

del（head,2）;//删除第二个节点

disp（head）;//输出新链表

}

5．实验结果

建立一个单链表：

输入第1结点data域值：

1

输入第2结点data域值：

2

输入第3结点data域值：

3

输入第4结点data域值：

4

输入第5结点data域值：

5

输入第6结点data域值：

6

输入第7结点data域值：

7

输入第8结点data域值：

8

输入第9结点data域值：

9

输入第10结点data域值0：

输出一个单链表：

123456789

单链表长度：

9

输出一个单链表：

1023456789

输出一个单链表：

12345678

实验二顺序栈的实现

1.实验目的

掌握顺序栈的基本操作：

初始化栈、判栈空否、入栈、出栈、取栈顶数据元素等运算以及程序实现方法。

2.实验要求

（1）认真阅读和掌握和本实验相关的教材容。

（2）分析问题的要求，编写和调试完成程序。

（3）保存和打印出程序的运行结果，并分析程序的运行结果。

3.实验容

　　利用栈的基本操作实现一个判断算术表达式中包含圆括号、方括号是否正确配对的程序。

具体完成如下：

（1）定义栈的顺序存取结构。

（2）分别定义顺序栈的基本操作（初始化栈、判栈空否、入栈、出栈等）。

（3）定义一个函数用来判断算术表达式中包含圆括号、方括号是否正确配对。

其中，括号配对共有四种情况：

左右括号配对次序不正确；右括号多于左括号；左括号多于右括号；左右括号匹配正确。

（4）设计一个测试主函数进行测试。

（5）对程序的运行结果进行分析。

实验代码：

#include

#defineMaxSize100

typedefstruct

{

   intdata[MaxSize];

   inttop;

}SqStack;

voidInitStack（SqStack*st）//初始化栈

{

   st->top=-1;

}

intStackEmpty（SqStack*st）//判断栈为空

{

   return（st->top==-1）;

}

voidPush（SqStack*st,intx）//元素进栈

{

   if（st->top==MaxSize-1）

       printf（"栈上溢出!

\n"）;

   else

   {

       st->top++;

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

   }

}

voidPop（SqStack*st）//退栈

{

   if（st->top==-1）

       printf（"栈下溢出\n"）;

   else

   st->top--;

}

intGettop（SqStack*st）//获得栈顶元素

{

   if（st->top==-1）

   {

       printf（"栈空\n"）;

       return0;

   }

   else

       returnst->data[st->top];

}

voidDisplay（SqStack*st）//打印栈里元素

{

   inti;

   printf（"栈中元素：

"）;

   for（i=st->top;i>=0;--i）

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

   printf（"\n"）;

}

intmain（）//测试

{

   SqStackL;

   SqStack*st=&L;

   InitStack（st）;

   printf（"栈空：

%d\n",StackEmpty（st））;

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

       Push（st,i）;

   Display（st）;

   printf（"退一次栈\n"）;

   Pop（st）;

   printf（"栈顶元素:

%d\n",Gettop（st））;

   Pop（st）;

   Display（st）;

   return0;

}

实验结果：

实验三串的基本操作和简程序

1．实验目的

掌握串基本操作：

初始化、联接、替换、子串等运算在堆分配存储储结构上的程序设计方法。

2．实验要求

（1）认真阅读和掌握和本实验相关的教材容。

（2）认真阅读和掌握本章相关容的算法并设计程序序。

（3）上机运行程序。

（4）保存和打印出程序的运行结果，并结合程序进行分析。

实验代码：

#include

#defineMaxSize50

typedefstruct

{

chardata[MaxSize];//存放字符串

intlength;//字符串长度

}SqString;

//将一个字符串常量赋给串s

voidStrAssign（SqString&s,charcstr[]）

{

inti;

for（i=0;cstr[i]!

='\0';i++）//这个'\0'代表字符串结束标志,编译系统自动加上的

s.data[i]=cstr[i];

s.length=i;

}

//字符串的复制

voidStrCopy（SqString&s,SqStringt）

{

inti;

for（i=0;i

s.data[i]=t.data[i];

s.length=t.length;

printf（"字符串复制成功了\n"）;

}

//判断字符串是否相等

voidStrEqual（SqStrings,SqStringt）

{

inti,same=1;

if（s.length!

=t.length）

same=0;

else

{

for（i=0;i

if（s.data[i]!

=t.data[i]）

{

same=0;

break;

}

}

if（same==0）

printf（"这两个字符串不相等\n"）;

else

printf（"这两个字符串相等\n"）;

}

//字符串的长度

voidStrLength（SqStrings）

{

printf（"此字符串长度为：

%d\n",s.length）;

}

//合并字符串

SqStringConcat（SqStrings,SqStringt）

{

SqStringstr;

inti;

str.length=s.length+t.length;

for（i=0;i

str.data[i]=s.data[i];

for（i=0;i

str.data[s.length+i]=t.data[i];

returnstr;

}

//求子字符串

voidSubStr（SqStrings,inti,intj）

{

SqStringstr;

intk;

str.length=0;

if（i<=0||i>s.length||j<0||i+j-1>s.length）

printf（"子字符串复制失败\n"）;

for（k=i-1;k

str.data[k-i+1]=s.data[k];

str.length=j;

printf（"子字符串复制成功长度为：

%d\n",j）;

printf（"下面输出此子字符串：

\n"）;

for（i=0;i

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

printf（"\n"）;

}

//插入字符串

SqStringInserStr（SqStrings1,inti,SqStrings2）

{

intj;

SqStringstr;

str.length=0;

if（i<=0||i>s1.length+1）

{

printf（"字符串插入失败\n"）;

returnstr;

}

for（j=0;j

str.data[j]=s1.data[j];

for（j=0;j

str.data[i-1+j]=s2.data[j];

for（j=i-1;j

str.data[s2.length+j]=s1.data[j];

str.length=s1.length+s2.length;

printf（"插入字符串成功长度为：

%d\n",str.length）;

returnstr;

}

//删除字符串

SqStringDeleStr（SqStrings,inti,intj）

{

intk;

SqStringstr;

str.length=0;

if（i<=0||i>s.length||i+j>s.length+1）

{

printf（"字符串删除失败\n"）;returnstr;

}

for（k=0;k

str.data[k]=s.data[k];

for（k=i+j-1;k

str.data[k-j]=s.data[k];

str.length=s.length-j;

printf（"删除子字符串成功剩余长度为：

%d\n",str.length）;

returnstr;

}

//替换字符串

voidRepStr（SqStrings,inti,intj,SqStringt）

{

intk;

SqStringstr;

str.length=0;

if（i<=0||i>s.length||i+j-1>s.length）

printf（"字符串替换失败了\n"）;

for（k=0;k

str.data[k]=s.data[k];

for（k=0;k

str.data[i+k-1]=t.data[k];

for（k=i+j-1;k

str.data[t.length+k-j]=s.data[k];

str.length=s.length-j+t.length;

printf（"替换字符串成功新字符串长度为：

%d\n",str.length）;

}

//字符串的输出

voidDispStr（SqStrings）

{

inti;

if（s.length>0）

{

printf（"下面输出这个字符串\n"）;

for（i=0;i

printf（"%c",s.data[i]）;

printf（"\n"）;

}

else

printf（"目前空字符串无法输出\n"）;

}

voidmain（）

{

SqStrings;

chara[]={"wenxianliang"};//字符串常量a

StrAssign（s,a）;

DispStr（s）;

StrLength（s）;

SqStrings1,s2,t;//s1是待复制的字符串变量

printf（"请输入一个字符串t:

\n"）;

scanf（"%s",t.data）;

StrAssign（t,t.data）;

StrCopy（s1,t）;//复制字符串

StrLength（s1）;

DispStr（s1）;

printf（"下面判断字符串s1和字符串s是否相等\n"）;

StrEqual（s,s1）;

printf（"下面将字符串s1和字符串s合并一起\n"）;

SqStringstr;

str=Concat（s,s1）;//合并字符串

DispStr（str）;

StrLength（str）;

SubStr（str,22,7）;//求子字符串

str=DeleStr（str,15,4）;//删除字符串

DispStr（str）;

StrLength（str）;

printf（"请插入一个字符串s2\n"）;

scanf（"%s",s2.data）;

StrAssign（s2,s2.data）;

str=InserStr（str,15,s2）;//插入字符串

DispStr（str）;

StrLength（str）;

printf（"顺序字符串的基本运算到此结束了\n"）;

}

实验结果：

实验四 编程建立二叉树，对树进行插入删除及遍历的程序

1.实验目的

（1）进一步掌握指针变量的用途和程序设计方法。

（2）掌握二叉树的结构特征，以及链式存储结构的特点及程序设计方法。

（3）掌握构造二叉树的基本方法。

（4）掌握二叉树遍历算法的设计方法。

3．实验要求

（1）认真阅读和掌握和本实验相关的教材容。

（2）掌握一个实际二叉树的创建方法。

（3）掌握二叉链存储结构下二叉树操作的设计方法和遍历操作设计方法。

4．实验容

（1）定义二叉链存储结构。

（2）设计二叉树的基本操作（初始化一棵带头结点的二叉树、左结点插入、右结点插入、中序遍历二叉树等）。

（3）按照建立一棵实际二叉树的操作需要，编写建立二叉树、遍历二叉树的函数。

（4）编写测试主函数并上机运行。

打印出运行结果，并结合程序运行结果进行分析。

实验代码：

#include

typedefstructbitnode{

chardata;

structbitnode*lchild,*rchild;

}binode,*bitree;

voidcreatebitree（bitree*T）{

charch;

cin>>ch;

if（ch=='0'）

（*T）=NULL;

else{

（*T）=newbitnode;

（*T）->data=ch;

createbitree（&（*T）->lchild）;

createbitree（&（*T）->rchild）;

}

}

voidinorderout（bitreeT）{

if（T）{

inorderout（T->lchild）;

cout<data<

inorderout（T->rchild）;

}

}

voidpostorder（bitreeT）{

if（T）{

postorder（T->lchild）;

postorder（T->rchild）;

cout<data<

}

}

intcountleaf（bitreebt）{

if（!

bt）

return0;

if（bt->lchild==NULL&&bt->rchild==NULL）

return1;

return（countleaf（bt->lchild）+countleaf（bt->rchild））;

}

voidmain（）{

bitreebt;

createbitree（&bt）;

inorderout（bt）;

cout<<""<

postorder（bt）;

countleaf（bt）;

}

实验五建立有序表并进行折半查找

1.实验目的

掌握递归算法求解问题的基本思想和程序实现方法。

2．实验要求

（1）认真阅读和掌握本实验的算法思想。

（2）编写和调试完成程序。

（3）保存和打印程序的运行结果，并对运行结果进行分析。

3.实验容

（1）分析掌握折半查找算法思想，在此基础上，设计出递归算法和循环结构两种实现方法的折半查找函数。

（2）编写程序实现：

在保存于数组的1000个有序数据元素中查找数据元素x是否存在。

数据元素x要包含两种情况：

一种是数据元素x包含在数组中；另一种是数据元素x不包含在数组中

（3）数组中数据元素的有序化既可以初始赋值时实现，也可以设计一个排序函数实现。

（4）根据两种方法的实际运行时间，进行两种方法时间效率的分析对比。

实验代码：

#include

#include

#defineMAX_LENGTH10