c数据结构实验报告.docx
《c数据结构实验报告.docx》由会员分享，可在线阅读，更多相关《c数据结构实验报告.docx（16页珍藏版）》请在冰豆网上搜索。
c数据结构实验报告
c++数据结构实验报告
算法与数据结构;实验报告;实验一：
栈与队列;一、实验目的;1、掌握栈和队列特点、逻辑结构和存储结构;2、熟悉对栈和队列的一些基本操作和具体的函数定义;3、利用栈和队列的基本操作完成一定功能的程序;二、实验任务;1.出顺序栈的类定义和函数实现，利用栈的基本操作;的转换;2.给出顺序队列的类定义和函数实现，并利用队列计;容;3.给出链栈的类定义和函数实现，并设计
算法与数据结构
实验报告
实验一：
栈与队列
一、实验目的
1、掌握栈和队列特点、逻辑结构和存储结构
2、熟悉对栈和队列的一些基本操作和具体的函数定义。
3、利用栈和队列的基本操作完成一定功能的程序。
二、实验任务
1.出顺序栈的类定义和函数实现，利用栈的基本操作完成十进制数N与其它d进制数
的转换。
（如N=1357,d=8）
2.给出顺序队列的类定义和函数实现，并利用队列计算并打印杨辉三角的前n行的内
容。
（n=8）
3.给出链栈的类定义和函数实现，并设计程序完成如下功能：
读入一个有限大小的整
数n，并读入n个数，然后按照与输入次序相反的次序输出各元素的值。
三、实验原理
1、将十进制数N转化为d进制时，用除去余数法，用d除N所得余数作为d进制当前个位，将相除所得的商的整数部分作为新的N值重复上述计算，直到N为0为止。
将前所得到的各余数反过来连接便得到最终结果。
将每次求出的余数入栈，求解结束后，再依次出栈。
2、在杨辉三角中可用上一行的数来求出对应位置的下一行的内容。
用队列保存上行内容，每当由上行的两个数求出下行的一个数时，其中的前一个便需要删除，而求出的数就入队。
为便于求解，在每行的第一个位置添加一个0作为辅助。
3、输出操作应在读入所有输入的整数后才能进行，用栈来存储这些数据，调用入栈出栈函数实现相关功能。
四、程序清单
第一题
#include#ifndefSTACK_H#defineSTACK_Hconstintmaxlen=256;typedefintelementtype;enumerror_code{success,underflow,overflow};classstack{public:
stack（）;boolempty（）const;boolfull（）const;error_codeget_top（elementtype&x）const;error_codepush（constelementtypex）;error_codepop（）;private:
intcount;elementtypedata;};
stack:
:
stack（）{count=0;}
boolstack:
:
empty（）const{if（count==0）returntrue;returnfalse;}
error_codestack:
:
get_top（elementtype&x）const{if（empty（））returnunderflow;else{x=data;returnsuccess;}}
error_codestack:
:
push（constelementtypex）{if（full（））returnoverflow;data=x;count++;
returnsuccess;}
error_codestack:
:
pop（）{
if（empty（））returnunderflow;count--;returnsuccess;}
boolstack:
:
full（）const{if（count==maxlen）returntrue;returnfalse;}
#endif
voidDec_to_Ocx（intN,intd）{stackS;intMod,x;while（N!
=0）{Mod=N%d;
第二题
#includeconstintmaxlen=256;typedefintelementtype;enumerror_code{success,underflow,overflow};classqueue{public:
queue（）;boolempty（）const;boolfull（）const;error_codeget_front（elementtype&x）const;error_codeappend（constelementtypex）;error_codeserve（）;private:
intcount;intfront,rear;elementtypedata;};
queue:
:
queue（）{count=0;front=rear=0;}boolqueue:
:
empty（）const{if（count==0）returntrue;returnfalse;}
boolqueue:
:
full（）const{if（count==maxlen-1）returntrue;returnfalse;
（Mod）;N=N/d;}
while（!
（））{_top（x）;（）;coutN;cin>>d;
Dec_to_Ocx（N,d）;}
}
error_codequeue:
:
get_front（elementtype&x）const{if（empty（））returnunderflow;x=data;returnsuccess;}
error_codequeue:
:
append（constelementtypex）{if（full（））returnoverflow;rear=（rear+1）%maxlen;data=x;count++;returnsuccess;}
error_codequeue:
:
serve（）{if（empty（））returnunderflow;front=（front+1）%maxlen;count--;returnsuccess;}
voidOut_Number（intn）
{ints1,s2;queueQ;inti,j;
error_codeEc;cout for（i=2;in;
s1=s2;Out_Number（n）;}}
第三题
#include#ifndefSTACK_H#defineSTACK_Hconstintmaxlen=256;typedefstructlinklist{intdata;
structlinklist*next;}node;
typedefintelementtype;enumerror_code{success,underflow,overflow};classstack{
public:
stack（）;~stack（）;
boolempty（）const;boolfull（）const;error_code
get_top（elementtype&x）const;
error_codepush（constelementtypex）;
error_codepop（）;private:
intcount;node*top;};
stack:
:
stack（）
{count=0;top=NULL;}
boolstack:
:
empty（）const
{returncount==0;}
boolstack:
:
full（）const{returnfalse;}
error_codestack:
:
get_top（elementtype&x）const{
if（empty（））returnunderflow;x=top->data;returnsuccess;}
stack:
:
~stack（）{
while（!
empty（））pop（）;}
error_codestack:
:
push（constelementtypex）{node*s;
s=newnode;s->data=x;s->next=top;top=s;
count++;returnsuccess;}
error_codestack:
:
pop（）{
if（empty（））returnunderflow;node*u;u=top;top=top->next; u;count--;
returnsuccess;}
#endif
voidread_write（）{stackS;
intx,n,i;cout>n;
for（i=1;i>x;（x）;}while（（）!
=true）
{_top（x）;
（）;cout voidmain（）{read_write（）;}
五、运行结果
1、
2、
3、
实验二：
单链表
一、实验目的：
1、理解线性表的链式存储结构。
2、熟练掌握动态链表结构及有关算法的设计。
3、根据具体问题的需要，设计出合理的表示数据的链表结构，并设计相关算法。
二、实验任务：
1、在一个递增有序的链表L中插入一个值为x的元素，并保持其递增有序特性。
实验数据：
链表元素为（10,20,30,40,50,60,70,80,90,100）,x分别为25，85，110和8。
2、将单链表L中的奇数项和偶数项结点分解开，并分别连成一个带头结点的单链表，然后
再将这两个新链表同时输出在屏幕上，并保留原链表的显示结果，以便对照求解结果。
实验测试数据基本要求：
第一组数据：
链表元素为（1,2,3,4,5,6,;3.求两个递增有序链表L1和L2中的公共元素，并;第一个链表元素为（1，3，6，10，15，16，;第二个链表元素为（1，2，3，4，5，6，7，8;第一个链表元素为（1，3，6，10，15，16，;三、实验原理;1、给定了递增的插入条件，需要搜索满足条件的插入;2、从链表A第一项开始，第一项插入链表B，第二
第一组数据：
链表元素为（1,2,3,4,5,6,7,8,9,10,20,30,40,50,60）第二组数据：
链表元素为（10,20,30,40,50,60,70,80,90,100）
3.求两个递增有序链表L1和L2中的公共元素，并以同样方式连接成链表L3。
实验测试数据基本要求：
第一组数据：
第一个链表元素为（1，3，6，10，15，16，17，18，19，20）
第二个链表元素为（1，2，3，4，5，6，7，8，9，10，18，20，30）第二组数据：
第一个链表元素为（1，3，6，10，15，16，17，18，19，20）第二个链表元素为（2，4，5，7，8，9，12，22）
三、实验原理
1、给定了递增的插入条件，需要搜索满足条件的插入位置的前驱结点。
从原表的第一个元素开始，直到某一元素A的值大于要插入元素的值为止，A的前驱结点便是插入位置。
2、从链表A第一项开始，第一项插入链表B，第二项插入链表C，依次类推，奇数项插入链表B，偶数项插入链表C，直到无元素为止。
3、从AB表的第一项开始，若A第一项大于B第一项，B向后搜索，如果找到共同元就将其插入表C，如无共同元素，表A从第二项搜索，依次类推。
若A的第一项小于B的第一项，则该元素没有公共项，A从第二项搜索，依次类推。
若AB第一项相同，则该数就是公共元素，插入表C，AB都从第二项搜索，依次类推。
四、程序清单
第一、二题
#includestructnode{
intdata;node*next;};
classlist{public:
list（）;~list（）;
intlength（）;
voidinput_elem（constintn）;voidprint（）;
node*get_head（）;
voidset_（node*L,intdata）;
voidjiou_list（node*P,node*Q,node*R）;private:
intcount;node*head;};
list:
:
list（）{
head=newnode;head->next=NULL;count=0;}
list:
:
~list（）{
node*p,*q;p=head->next;while（p!
=NULL）{q=p;
p=p->next; q;}}
intlist:
:
length（）{
intn=0;
node*p=head->next;while（p!
=NULL）{n++;
p=p->next;}
returnn;}
voidlist:
:
input_elem（constintn）{
node*p,*pre;pre=head;
for（inti=0;i
p=newnode;cin>>p->data;pre->next=p;pre=p;count++;}
pre->next=NULL;}
voidlist:
:
print（）{
node*p;p=head;p=p->next;
while（p!
=NULL）{
cout
cout cout>m;cout case1:
{
cout cout>n;
_elem（n）;
cout>data;
_（_head（）,data）;（）;
cout 第三题
#include#include
typedefintelementtype;structNode{
elementtypedata;Node*next;};
classlist{
private:
Node*head;Node*real;public:
cout case2:
{
cout cout>n;
_elem（n）;_list
（_head（）,_head（）,_head（））;cout cout cout cout list（）;voidcommon（list&L1,list&L2）;voidcreate（）;friendostream&operator list:
:
list（）{head=newNode;real=head;};
voidlist:
:
create（）{Node*u;
elementtypex;cin>>x;while（x!
=-1）{u=newNode;u->data=x;real->next=u;real=u;cin>>x;}real->next=NULL;}
ostream&operatornext;while（p!
=NULL）{outnext;out voidlist:
:
common（list&L1,list&L2）{Node*pa,*pb,*u;pa=>next;pb=>next;
while（pa!
=NULL&&pb!
=NULL）{if（pa->datadata）pa=pa->next;else
if（pa->data>pb->data）pb=pb->next;else{u=newNode;u->data=pa->data;real->next=u;real=u;pa=pa->next;pb=pb->next;}real->next=NULL;}}
voidmain（）{listL1,L2,L3;inti;elementtypex;cout 五、运行结果
1、
2、
3、
实验三：
二叉树
一、实验目的：
1.掌握二叉树的动态链表存储结构及表示。
2.掌握二叉树的三种遍历算法（递归和非递归两类）。
3.运用二叉树三种遍历的方法求解有关问题。
二、实验任务：
1.建立一棵采用二叉链表结构存储的二叉树。
2.分别采用递归和非递归两种方式对该二叉树进行先序、中序和后序遍历。
3.求二叉树的高度以及二叉树中叶子结点的数目;三、实验原理;1、按先序遍历的方法建立二叉树，结点的空孩子用#;非递归中序遍历：
遇到一个结点，就把它推入栈中，并;非递归后序遍历：
遇到一个结点，把它推入栈中，遍历;3、求高度时，若T为空，则其高度为0，结束，否则;四、程序清单;递归并求叶子节点数和深度;#include
3.求二叉树的高度以及二叉树中叶子结点的数目。
三、实验原理
1、按先序遍历的方法建立二叉树，结点的空孩子用#代替输入，先建立根结点在建立左右子树，依次类推。
2、对二叉树的遍历是在对各子树分别遍历的基础上进行的，借助对整个二叉树的遍历算法实现对左右子树的遍历。
在先序遍历以T为根的二叉树时，访问根结点后，分别对根结点*T的左右孩子为根的子树进行遍历，中序后序递归遍历也采用此思想。
非递归前序遍历：
遇到一个结点，就访问该结点，并把此结点入栈，然后下降去遍历它的左子树。
遍历完它的左子树后，从栈顶托出这个结点，并按照它的右链接指示的地址再去遍历该结点的右子树结构。
非递归中序遍历：
遇到一个结点，就把它推入栈中，并去遍历它的左子树。
遍历完左子树后，从栈顶托出这个结点并访问之，然后按照它的右链接指示的地址再去遍历该结点的右子树。
非递归后序遍历：
遇到一个结点，把它推入栈中，遍历它的左子树。
遍历结束后，还不能马上访问处于栈顶的该结点，而是要再按照它的右链接结构指示的地址去遍历该结点的右子树。
遍历遍右子树后才能从栈顶托出该结点并访问之。
另外，需要给栈中的每个元素加上一个特征位，以便当从栈顶托出一个结点时区别是从栈顶元素左边回来的（则要继续遍历右子树），还是从右边回来的（该结点的左、右子树均已周游）。
特征为left表示已进入该结点的左子树，将从左边回来;特征为right表示已进入该结点的右子树，将从右边回来。
3、求高度时，若T为空，则其高度为0，结束，否则，T不为空时，可采用递归的方式，T的左右子树的高度分别能求出来，则二叉树的高度是其左右子树高度的最大值加1.
四、程序清单
递归并求叶子节点数和深度
#includetypedefstructBiTNode{
chardata;intbit;
structBiTNode*lchild,*rchild,*parent;}BiTNode;
voidInitBT（BiTNode*&t）{
t=NULL;}
intEmptyBT（BiTNode*t）{
if（t==0）
return1;else
return0;}
BiTNode*creatBT（BiTNode*t,intb）{
BiTNode*p;charch;cin>>ch;
if（ch=='#'）return0;else{
p=newBiTNode;p->data=ch;
p->parent=t;p->bit=b;t=p;
t->lchild=creatBT（t,0）;t->rchild=creatBT（t,1）;}
returnt;}
voidpreorder（BiTNode*t）{
if（!
EmptyBT（t））{
coutlchild）;preorder（t->rchild）;}}
voidinorder（BiTNode*t）//中序遍历{
if（!
EmptyBT（t））{
inorder（t->lchild）;coutrchild）;}}
voidpostorder（BiTNode*t）//后序遍历{
if（!
EmptyBT（t））{
postorder（t->lchild）;postorder（t->rchild）;cout
voidcoutBT（BiTNode*t,int&m）//计算二叉树中叶子结点{
if（!
EmptyBT（t））{
if（（t->lchild==0）&&（t->rchild==0））m++;//叶子结点
非递归遍历
#include
coutBT（t->lchild,m）;coutBT（t->rchild,m）;}}
intBTdepth（BiTNode*t）//求二叉树的深度{
inti,j;
if（EmptyBT（t））return0;else{
i=BTdepth（t->lchild）;j=BTdepth（t->rchild）;return（i>j?
i:
j）+1;}}
voidmain（）{
BiTNode*t;intm,n,i,d,q,k;charx;InitBT（t）;
cout cout cout cout coutBT（t,m）;
cout d=BTdepth（t）;
cout constintMaxSize=256;
templatestructBiNode{Tdata;BiNode*lchild,*rchild;BiNode*btr;int
升级会员 