数据结构实验报告树形数据结构实验Word格式.docx
《数据结构实验报告树形数据结构实验Word格式.docx》由会员分享,可在线阅读,更多相关《数据结构实验报告树形数据结构实验Word格式.docx(37页珍藏版)》请在冰豆网上搜索。
/******************************二叉数的结点类定义******************************/
classBTreeNode
private:
intltag,rtag;
//线索标记
BTreeNode*left;
//左子树指针
BTreeNode*right;
//右子树指针
public:
ElemTypedata;
//数据域
//构造函数
BTreeNode()
ltag=0;
rtag=0;
left=NULL;
right=NULL;
//带参数初始化的构造函数
BTreeNode(ElemTypeitem,intltag1,intrtag1,BTreeNode*left1,BTreeNode*right1)
data=item;
ltag=ltag1;
rtag=rtag1;
left=left1;
right=right1;
BTreeNode*&
Left()//返回结点的左孩子
returnleft;
//返回结点的右孩子
Right()
returnright;
friendclassBinaryTree;
//二叉树类为二叉树结点类的友元类
/**********************************二叉数的类定义*******************************/
classBinaryTree
private:
BTreeNode*root;
public:
//构造函数.初始化二叉树为空
BinaryTree(){root=NULL;
}
//判断二叉树是否为空
boolBTreeEmpty(){returnroot==NULL;
/****************************创建二叉数的相关成员函数***********************/
//按照二叉树的广义表表示创建二叉树
voidCreateBTree1();
//递归创建二叉树,被函数CreateBTree1调用
voidCreate1(BTreeNode*&
BT);
//按一定次序输入二叉树中结点的值(一个字符),空格表示空树
voidCreateBTree2(intmake);
//递归先序创建二叉树,被函数CreateBTree2调用
voidGreate2(BTreeNode*&
BT,intmark);
//复制二叉树
voidBTreeCopy(BTreeNode*&
root,BTreeNode*&
/****************************遍历二叉数的相关成员函数***********************/
//按任一种遍历次序输出二叉树中的所有结点
voidTraverseBTree(intmark);
//用于遍历的递归函数,被函数TraverseBTree调用
voidTraverse(BTreeNode*&
//先序遍历的递归函数
voidPreOrder(BTreeNode*&
//先序遍历的非递归函数一
voidPreOrder_N1(BTreeNode*&
//先序遍历的非递归函数二
voidPreOrder_N2(BTreeNode*&
//中序遍历的递归函数
voidInOrder(BTreeNode*&
//中序遍历的非递归函数一
voidInOrder_N1(BTreeNode*&
//中序遍历的非递归函数二
voidInOrder_N2(BTreeNode*&
//后序遍历的递归函数
voidPostOrder(BTreeNode*&
//后序遍历的非递归函数一
voidPostOrder_N1(BTreeNode*&
voidPostOrder_N2(BTreeNode*&
//层序遍历的非递归函数
voidLayerOrder(BTreeNode*&
//按照二叉树的广义表表示输出整个二叉树
voidGPrintBTree();
//广义表形式输出整个二叉树的递归函数,被函数Print调用
voidGPrint(BTreeNode*&
//以凹凸表示法输出二叉树
voidOPrintTree();
/**********************************二叉树的属性*****************************/
/****************计算二叉数深度,宽度,叶子,结点的相关成员函数****************/
//求二叉树的深度
intBTreeDepth();
//用于求二叉树深度的递归函数,被BTreeDepth调用
intDepth(BTreeNode*&
//求二叉树的宽度
intBTreeWidth();
//求二叉树中所有结点数
intBTreeCount();
//用于求二叉树所有结点数的递归函数,被函数BTreeCount调用
intCount(BTreeNode*&
//求二叉树中所有叶子结点数
intBTreeLeafCount();
//用于求二叉树中所有叶子结点数的递归函数,被函数BTreeLeafCount调用
intLeafCount(BTreeNode*&
//输出二叉树的所有叶子结点
voidBTreeLeafPrint();
//用于输出二叉树的所有叶子结点的递归函数,被函数BTreeLeafPrint调用
voidLeafPrint(BTreeNode*&
/***********************二叉树中从根结点到叶子结点的路径相关函数****************/
//输出从根结点到叶子结点的路径,以及最长路径
voidBTreePath();
//输出从根结点到叶子结点的路径的递归函数,被函数BTreePath调用
voidPathLeaf(BTreeNode*&
BT,ElemTypepath[],intpathlen);
//求最长路径的递归函数,被函数BTreePaht调用
voidBTreeLongpath(BTreeNode*&
BT,ElemTypepath[],intpathlen,ElemTypelongpath[],int&
longpathlen);
//非递归方法输出从根结点到叶子结点的路径
voidBTreePath_N1();
//返回data域为x的结点指针
voidBTreeFind(ElemTypex);
//返回data域为x的结点指针的递归函数,被函数BTreeFind调用
BTreeNode*FindNode(BTreeNode*&
BT,ElemTypex);
/*************************************线索二叉树****************************/
//线索化二叉树
voidCreateThread();
//中序线索化二叉树的递归函数,被函数CreateThread调用
voidInOrderThread(BTreeNode*&
BT,BTreeNode*&
pre);
//中序线索化二叉树中实现中序遍历,被函数CreateThread调用
voidThInOrder(BTreeNode*&
/****************************销毁二叉数的相关成员函数***********************/
//置空二叉树
voidBTreeClear();
//用于清除二叉树的递归函数,被函数BTreeClear与~BinaryTree调用
voidClear(BTreeNode*&
//析构函数,清除二叉树
~BinaryTree();
/******************************创建二叉数的相关成员函数*************************/
//按照二叉树的广义表表示创建二叉树
voidBinaryTree:
:
CreateBTree1()
cout<
<
"
输入广义表形式的二叉树:
endl;
root=NULL;
//给树根指针置空
Create1(root);
//递归创建二叉树,被函数CreateBTree1调用
Create1(BTreeNode*&
BT)
BTreeNode*stack[MAXSIZE],*p=NULL;
intk,top=-1;
charch;
while((ch=getchar())!
='
#'
)
switch(ch)
case'
('
top++;
stack[top]=p;
k=1;
//即将建立左结点
break;
)'
top--;
'
k=2;
//即将建立右结点
default:
if(!
(p=newBTreeNode))
cout<
\n堆内存分配失败\n"
;
exit
(1);
p->
data=ch;
left=p->
right=NULL;
if(BT==NULL)//p指向二叉树的根结点,建立根结点
BT=p;
else//已经建立根结点
if(k==1)//建立左结点
stack[top]->
left=p;
else//建立右结点
right=p;
}//switch(ch)
}//while
//按一定次序输入二叉树中结点的值(一个字符),空格表示空树
CreateBTree2(intmark)
switch(mark)
case1:
puts("
按先序输入二叉树:
);
break;
case2:
按中序输入二叉树:
case3:
按后序输入二叉树:
//给树根指针置空
p=root;
//定义p为指向二叉树结点的指针
Greate2(p,mark);
//递归创建二叉树,被函数CreateBTree2调用
Greate2(BTreeNode*&
BT,intmark)
ch=getchar();
//先序创建
if(ch=='
'
BT=NULL;
else
(BT=newBTreeNode))
BT->
Greate2(BT->
left,mark);
right,mark);
//复制二叉树
BTreeCopy(BTreeNode*&
if(root)
if(!
exit
(1);
BT->
data=root->
data;
BTreeCopy(root->
left,BT->
left);
right,BT->
right);
else
BT=NULL;
/*******************************遍历二叉数的相关成员函数************************/
//按任一种遍历次序输出二叉树中的所有结点
TraverseBTree(intmark)
srand(time(NULL));
//产生随机种子数,用来选择相同顺序遍历的不同算法
Traverse(root,mark);
//用于遍历的递归函数,被函数TraverseBTree调用
Traverse(BTreeNode*&
intoption;
//先序遍历
option=rand()%3+1;
switch(option)//随机选择一种先序算法
case1:
PreOrder(BT);
break;
case2:
PreOrder_N1(BT);
case3:
PreOrder_N2(BT);
//中序遍历
option=rand()%3+1;
switch(option)//随机选择一种中序算法
InOrder(BT);
InOrder_N1(BT);
InOrder_N2(BT);
//后序遍历
PostOrder(BT);
PostOrder_N1(BT);
PostOrder_N2(BT);
case4:
//层序遍历
LayerOrder(BT);
default:
cout<
mark的值无效!
遍历失败!
//先序遍历的递归函数
PreOrder(BTreeNode*&
if(BT!
=NULL)
BT->
data<
'
PreOrder(BT->
//先序遍历的非递归函数一
PreOrder_N1(BTreeNode*&
BTreeNode*p;
struct
BTreeNode*pt;
inttag;
}stack[MAXSIZE];
inttop=-1;
top++;
stack[top].pt=BT;
stack[top].tag=1;
while(top>
-1)//栈不空时循环
if(stack[top].tag==1)//不能直接访问
p=stack[top].pt;
if(p!
=NULL)//按右,左,结点顺序进栈,后进先出,即先序遍历
top++;
stack[top].pt=p->
right;
//右孩子入栈
stack[top].tag=1;
left;
//左孩子入栈
stack[top].pt=p;
//根结点入栈
stack[top].tag=0;
//可以直接访问
if(stack[top].tag==0)//可以直接访问
cout<
stack[top].pt->
//先序遍历的非递归函数二
PreOrder_N2(BTreeNode*&
BTreeNode*stack[MAXSIZE],*p;
inttop=-1;
top++;
stack[top]=BT;
while(top>
p=stack[top];
p->
"
if(p->
right!
=NULL)//右孩子入栈
stack[top]=p->
left!
=NULL)//左孩子入栈
}//while
}//if(root!
//中序遍历的递归函数
InOrder(BTreeNode*&
InOrder(BT->
//中序遍历的非递归函数一
InOrder_N1(BTreeNode*&
stack[top].pt=BT;
stack[top].tag=1;
if(stack[top].tag==1)//不能直接访问
p=stack[top].pt;
stack[top].tag=1;
stack[top].pt=p;
stack[top].tag=0;
stack[top].pt=p->
if(stack[top].tag==0)//可以直接访问
//中序遍历的非递归函数二
InOrder_N2(BTreeNode*&
if(BT!
=NULL)
p=BT;
while(top>
-1||p!
while(p!
=NULL)//所有左结点入栈
stack[top]=p;
p=p->
if(top>
-1)
p=stack[top];
top--;
}//if
//后序遍历的递归函数
PostOrder(BTreeNode*&
PostOrder(BT->
//后序遍历的非递归函数一
PostOrder_N1(BTreeNode*&
if(stack[top].tag==1)//不能