数据结构课程设计之树与二叉树的转换大学毕业设计论文Word下载.docx

数据结构课程设计之树与二叉树的转换大学毕业设计论文Word下载.docx

《数据结构课程设计之树与二叉树的转换大学毕业设计论文Word下载.docx》由会员分享，可在线阅读，更多相关《数据结构课程设计之树与二叉树的转换大学毕业设计论文Word下载.docx（23页珍藏版）》请在冰豆网上搜索。

层次序遍历算法

1树的建立

用链表实现创建一个树结点的结构体，从键盘输入数据，存入数组。

把下标为2*i+1的值存入左孩子，为2*i+2的存入右孩子。

BiNodecreat（），BiNodestree_creat（char*a,intk）。

2一般树转化成二叉树

转换时结点的第一个孩子变为它的左孩子，兄弟节点变为他的右孩子。

voidexchange（），classTree

3先序遍历树的递归算法

若二叉树为空，则空操作；

否则

（1）访问根结点；

（2）先序遍历左子树；

（3）先序遍历右子树。

voidPreOrder（BiNoderoot）。

4后序遍历树的递归算法

否则

（1）后序遍历左子树；

（2）后序遍历右子树。

（3）访问根结点；

voidPostOrder（BiNoderoot）。

5先序遍历树的非递归算法

否则

（1）先将根节点进栈，在栈不为空时循环；

（2）出栈p，访问*p若其右孩子节点不空将右孩子节点进栈若其左孩子节点不空时再将其左孩子节点进栈。

6后序遍历树的非递归算法

采用一个栈保存需要返回的指针，先扫描根节点所有的左孩子节点并一一进栈，出栈一个节点*b作为当前节点，然后扫描该节点的右子树。

当一个节点的左右孩子节点均访问后再访问该节点，如此重复操作，直到栈空为止。

7层次序的非递归遍历

按照树的层次从左到右访问树的结点，层序遍历用于保存结点的容器是队列。

voidLevelOrder（BiNoderoot）。

3．详细设计

1树的建立：

PTreeCreatTree（PTreeT）

{

inti=1;

intfa,ch;

PTNodep;

for（i=1;

ch!

=-1;

i++）

{

printf（"

输入第%d结点:

\n"

i）;

scanf（"

%d,%d"

&

fa,&

ch）;

）;

p.data=ch;

p.parent=fa;

T.count++;

T.node[T.count].data=p.data;

T.node[T.count].parent=p.parent;

}

printf（"

创建的树具体情况如下:

print_ptree（T）;

returnT;

2一般树转换成二叉树

BTNode*change（PTreeT）

inti,j=0;

BTNodep[MAX_TREE_SIZE];

BTNode*ip,*is,*ir,*Tree;

ip=（BTNode*）malloc（sizeof（BTNode））;

is=（BTNode*）malloc（sizeof（BTNode））;

ir=（BTNode*）malloc（sizeof（BTNode））;

Tree=（BTNode*）malloc（sizeof（BTNode））;

for（i=0;

i<

T.count;

p[i]=GetTreeNode（T.node[i].data）;

ip=&

p[i];

is=&

p[j];

while（T.node[i].parent!

=is->

data）

{

j++;

is=&

}

if（!

（is->

firstchild））

is->

firstchild=ip;

ir=ip;

else

ir->

rightsib=ip;

Tree=&

p[0];

returnTree;

}

3先序遍历树的递归算法：

voidpreorder（BTNode*T）

if（T!

=NULL）

%d"

T->

data）;

preorder（T->

firstchild）;

rightsib）;

4.先序遍历树的非递归算法

voidpreOrder2（BinTree*root）//非递归先序遍历

stack<

BinTree*>

s;

BinTree*p=root;

while（p!

=NULL||!

s.empty（））

cout<

<

p->

data<

"

"

;

s.push（p）;

p=p->

lchild;

if（!

p=s.top（）;

s.pop（）;

rchild;

5.后序遍历树的递归算法

voidinoeder（BTNode*T）

inoeder（T->

voidpostOrder2（BinTree*root）//非递归后序遍历

BTNode*>

BTNode*temp;

=NULL）//沿左子树一直往下搜索，直至出现没有左子树的结点

BTNode*btn=（BTNode*）malloc（sizeof（BTNode））;

btn->

btnode=p;

isFirst=true;

s.push（btn）;

temp=s.top（）;

if（temp->

isFirst==true）//表示是第一次出现在栈顶

temp->

isFirst=false;

s.push（temp）;

p=temp->

btnode->

else//第二次出现在栈顶

temp->

p=NULL;

}

}

7层次序树的非递归算法

voidinitqueue（linkqueue&

q）//初始化一个带头结点的队列

q.front=q.rear=（queueptr）malloc（sizeof（queuenode））;

q.front->

next=NULL;

voidenqueue（linkqueue&

q,bitreesp）//入队列

queueptrs;

intfirst=1;

s=（queueptr）malloc（sizeof（queuenode））;

s->

ch=p;

q.rear->

next=s;

q.rear=s;

voiddequeue（linkqueue&

q,bitrees&

p）//出队列

intdata;

s=q.front->

next;

p=s->

ch;

data=p->

data;

next=s->

if（q.rear==s）

q.rear=q.front;

free（s）;

%d\t"

data）;

intqueueempty（linkqueueq）//判断队列是否为空

if（q.front->

next==NULL）

return1;

return0;

voidtraverse（bitreesbt）//按层次遍历树中结点

linkqueueq;

bitreesp;

initqueue（q）;

p=bt;

enqueue（q,p）;

while（queueempty（q）!

=1）

dequeue（q,p）;

if（p->

lchild!

enqueue（q,p->

lchild）;

rchild!

rchild）;

4．}设计与调试分析

1.二叉树遍历中用到的最重要的一个思想就是递归调用，这次作业使我们对递归有了深入的理解，程序调试比较顺利。

2.用栈同样可以实现二叉树的遍历，这是我们认识到解决问题可以由多种不同的途径，应随时将以前学过的只是灵活应用起来，解决新问题。

3.因为遍历二叉树的基本操作是访问结点，所以无论哪一种遍历方式，对含有n个结点的二叉树，其时间复杂度为O（n），所需辅助空间最大容量为树的深度，最坏为n，所以空间复杂度为O（n）。

4.因该程序对应不同的遍历定义了不同的结构，使每种结构的通用性降低，可以往在递归和非递归中使用同一种结构这一方面做进一步的思考。

五．用户手册

运行程序，首先出现主界面。

主界面有七个选项。

选项一、以双亲法创建一棵树。

选项二、此选项可以对所创建的树采用递归算法进行前序遍历。

选项三、此选项可以对所创建的树采用递归算法进行后序遍历。

选项四、此选项可以对所创建的树采用非递归算法进行先序遍历。

选项五、此选项可以对所创建的树采用非递归算法进行后序遍历。

选项六、此选项可以退出程序。

六．测试结果

程序开始

一般树转换成二叉树的情况

副菜单选择：

选择9继续操作

运用各种遍历形式遍历树

副菜单选择0结束程序

七．附录（源程序）

#include<

stdio.h>

malloc.h>

stdlib.h>

//设置常量：

#defineMAX_TREE_SIZE100

//一般树的存储结构有以下几种：

双亲结点，孩子结点，孩子兄弟结点。

本实验运用到的是双亲结点和孩子兄弟结点。

具体存储结构如下：

/*树的双亲表示结点结构定义*/

typedefstruct

intparent;

//双亲位置域

}PTNode;

/*双亲表示法树结构*/

PTNodenode[MAX_TREE_SIZE];

intcount;

//根的位置和节点个数

}PTree;

/*树的孩子兄弟表示结点结构定义*/

typedefstructnode{

structnode*firstchild;

structnode*rightsib;

}BTNode,*BTree;

//初始化树（双亲表示法）

voidinit_ptree（PTree*tree）

tree->

count=-1;

//初始化树结点（孩子兄弟表示法）

BTNodeGetTreeNode（intx）

BTNodet;

t.data=x;

t.firstchild=t.rightsib=NULL;

returnt;

//树的先序遍历（递归）

//树的先序遍历（非递归）

voidpreorder2（PTreeT）

inti;

T.node[i]）;

//树后序遍历（递归）

//树后序遍历（非递归）

voidinoeder2（PTreeT）

for（i=T.count-1;

i>

=0;

i--）

//层次遍历

voidlevel（PTreeT）

//水平输出二叉树

voidPrintBTree（BTNode*root,intlevel）

{

if（root!

=NULL）

{

PrintBTree（root->

rightsib,level+1）;

=8*level;

i++）

-------%d\n"

root->

firstchild,level+1）;

//输出树

voidprint_ptree（PTreetree）

序号结点双亲\n"

=tree.count;

%8d%8d%8d"

i,tree.node[i].data,tree.node[i].parent）;

/*用双亲表示法创建树*/

/*一般树转换成二叉树*/

/*主菜单*/

voidMenu（）

=================主菜单=======================\n"

***输入1-------------以双亲法创建一棵一般树***\n"

***输入2-------------树的先序遍历（递归）*******\n"

***输入3-------------树的后序遍历（递归）*******\n"

***输入4-------------树的先序遍历（非递归）*****\n"

***输入5-------------树的后序遍历（非递归）*****\n"

***输入6-------------层次序的非递归遍历*******\n"

***输入0-------------退出程序*****************\n"

==============================================\n"

请输入执行的指令:

/*副菜单*/

voidMenu2（）

*****************副菜单*******************\n"

***9-------------返回主菜单继续操作*******\n"

***0-------------退出程序*****************\n"

/*主函数*/

intmain（）

inti=0,c1,c2;

PTreeT;

BTNode*Tree;

init_ptree（&

T）;

loop:

Menu（）;

scanf（"

%d"

c1）;

switch（c1）

case1:

建立一般树,依次输入各个结点情况:

printf（"

输入结点方式:

双亲数据,整型数据（第一个结点双亲数据为-1,最后以-1,-1结束）\n例子:

-1,11,3\n"

T=CreatTree（T）;

Tree=change（T）;

一般树转换成二叉树后的情况:

PrintBTree（Tree,i）;

getchar（）;

break;

case2:

树的前序遍历（递归）:

preorder（Tree）;

case3:

树的后序遍历（递归）:

inoeder（Tree）;

case4:

树的前序遍历（非递归）:

preorder2（T）;

case5:

树的后序遍历（非递归）:

inoeder2（T）;

case6:

树的层次遍历:

level（T）;

case0:

exit

（1）;

Menu2（）;

c2）;

if（c2==9）

gotoloop;

elseif（c2==0）

八．课程设计心得

通过本次程序设计，让我更深层次地了解到了树各种函数的运用，如何运用各种存储结构创建树，以及在实验中还涉及到递归的运用，递归的思想省去了复杂的算法设计。

在实验中不可避免的出现了大大小小的问题，在调试中领悟各种算法的真谛，同样的错误在下次遇到时就可以避免了,也让我懂得了自己动手比去做去看书要好的多，还有编程运行的时候都是不能够粗心大意的。