//二叉树的创建,递归遍历,非递归遍历,拷贝,深度
#include<iostream>
#include<stack>
using namespace std;
二叉树的结构
//typedef struct BiTNode
//{
// char data;//数据域
// int LTag = 0;//左标签
// int RTag = 0;//右标签
// struct BiTNode* lchild = nullptr;//指针必须初始化,c11标准
// struct BiTNode* rchild = nullptr;//左右孩子
// struct BiTNode* parent = nullptr;//双亲
//}BiTNode, * BiTree;
二叉树的结构
//二叉树的结构
typedef struct BiTNode
{
char data;//数据域
int LTag = 0;//左标签
int RTag = 0;//右标签
struct BiTNode* lchild = nullptr;//指针必须初始化,c11标准
struct BiTNode* rchild = nullptr;//左右孩子
struct BiTNode* parent = nullptr;//双亲
}BiTNode, * BiTree;
//二叉树的结构
BiTree pre;//= new BiTNode;//全局变量
BiTree parent = NULL;
//二叉树的创建
void CreateBiTree(BiTree& T,BiTree P)//先序输入
{
char ch;
cin >> ch;
if (ch == '#') T = NULL;
else
{
T = new BiTNode;//分配空间
T->data = ch;//根节点赋值
T->parent = P;
CreateBiTree(T->lchild,T);//建立左子树
CreateBiTree(T->rchild,T);//建立右子树
}
}
//二叉树的创建
//复制树
void Copy(BiTree T, BiTree& NewT)
{
if (T == NULL)
{
NewT = NULL;
return;
}
else
{
NewT = new BiTNode;
NewT->data = T->data;
Copy(NewT->lchild, T->lchild);
Copy(NewT->rchild, T->rchild);
}
}
//复制树
//计算树的深度
int Depth(BiTree T)
{
if (T == NULL) return 0;
else
{
int m = Depth(T->lchild);
int n = Depth(T->rchild);
if (m > n) return (m + 1);
else return (n + 1);
}
return 0;
}
//计算树的深度
//节点数量
int NodeCount(BiTree T)
{
if (T == NULL) return 0;
else return (NodeCount(T->lchild) + NodeCount(T->rchild) + 1);
}
//节点数量
//以结点T为根的子树先序线索化
void PreThreading(BiTree& T)
{
if (T)//T非空
{
if (!T->lchild)//左子树为空
{
T->LTag = 1;
T->lchild = pre;
}
else
{
T->LTag = 0;
}
if (!pre->rchild)
{
pre->RTag = 1;
pre->rchild = T;
}
else
{
T->RTag = 0;
}
pre = T;
if (T->LTag == 0)
{
PreThreading(T->lchild);//遍历左子树
}
if (T->RTag == 0)
{
PreThreading(T->rchild);//遍历右子树
}
}
}
//以结点T为根的字树先序线索化
//带头节点的二叉树先序线索化
void PreOrderThreading(BiTree& Thrt, BiTree T)
{
Thrt = new BiTNode;
Thrt->LTag = 0;
Thrt->RTag = 1;
Thrt->rchild = Thrt;
if (!T)
{
Thrt->lchild = Thrt;
}
else
{
Thrt->lchild = T;
pre = Thrt;
PreThreading(T);
pre->rchild = Thrt;
pre->RTag = 1;
Thrt->rchild = pre;
}
}
//带头节点的二叉树先序线索化
//遍历先序线索二叉树
void PreTraverse_Thr(BiTree T)
{
BiTree p = T->lchild;
while (p != T)
{
cout << p->data;
if (p->LTag == 0)
{
p = p->lchild;
}
else
{
p = p->rchild;
}
}
}
//遍历先序线索二叉树
//以结点T为根的子树中序线索化
void InThreading(BiTree &T)
{
if (T)//T非空
{
InThreading(T->lchild);//遍历左子树
if (!T->lchild)//左子树为空
{
T->LTag = 1;
T->lchild = pre;
}
else
{
T->LTag = 0;
}
if (!pre->rchild)
{
pre->RTag = 1;
pre->rchild = T;
}
else
{
T->RTag = 0;
}
pre = T;
InThreading(T->rchild);
}
}
//以结点T为根的字树中序线索化
//带头节点的二叉树中序线索化
void InOrderThreading(BiTree& Thrt, BiTree T)
{
Thrt = new BiTNode;
Thrt->LTag = 0;
Thrt->RTag = 1;
Thrt->rchild = Thrt;
if (!T)
{
Thrt->lchild = Thrt;
}
else
{
Thrt->lchild = T;
pre = Thrt;
InThreading(T);
pre->rchild = Thrt;
pre->RTag = 1;
Thrt->rchild = pre;
}
}
//带头节点的二叉树中序线索化
//遍历中序线索二叉树
void InTraverse_Thr(BiTree T)
{
BiTree p = T->lchild;//
while (p != T)
{
while (p->LTag == 0)
{
p = p->lchild;
}
cout << p->data;
while (p->RTag == 1 && p->rchild != T)
{
p = p->rchild;
cout << p->data;
}
p = p->rchild;
}
}
//遍历中序线索二叉树
//以结点T为根的子树后序线索化
void PosThreading(BiTree& T)
{
if (T)//T非空
{
PosThreading(T->lchild);//遍历左子树
PosThreading(T->rchild);//遍历右子树
if (!T->lchild)//左子树为空
{
T->LTag = 1;
T->lchild = pre;
}
else
{
T->LTag = 0;
}
if (!pre->rchild)
{
pre->RTag = 1;
pre->rchild = T;
}
else
{
T->RTag = 0;
}
pre = T;
}
}
//以结点T为根的字树后序线索化
//带头节点的二叉树后序线索化
void PosOrderThreading(BiTree& Thrt, BiTree T)
{
Thrt = new BiTNode;
Thrt->LTag = 0;
Thrt->RTag = 1;
Thrt->rchild = T;
if (!T)
{
Thrt->lchild = Thrt;
}
else
{
Thrt->lchild = T;
pre = Thrt;
PosThreading(T);
}
}
//带头节点的二叉树后序线索化
//遍历后序线索二叉树
//后序遍历需要双亲节点
void PosTraverse_Thr(BiTree T)
{
BiTree root = T->lchild;//初始节点
BiTree prev = nullptr;//记录上一个节点
while (root)
{
if (root->lchild == root->rchild)//如果双亲没有左子树或者右子树
{
root = root->rchild;
}
while (root->LTag == 0 && root->lchild != prev)//找到最左边的节点
{
root = root->lchild;
}
while (root->RTag == 1)//输出并遍历节点的后继
{
cout << root->data;
prev = root;//记录上一个节点
root = root->rchild;
}
if (root == T->lchild)//判断是不是根节点
{
cout << root->data;
return;
}
while (root->rchild == prev)//不是根节点,访问当前节点的双亲节点
{
cout << root->data;
prev = root;
root = root->parent;
if (root == nullptr)//遍历到根节点,退出
{
return;
}
}
if (root->RTag == 0)//遍历右子树
{
root = root->rchild;
}
}
}
//遍历后序线索二叉树
int main()
{
BiTree T;
BiTree P = nullptr;
BiTree Thrt;
cout << "树的先序遍历为:";
CreateBiTree(T,P);
InOrderThreading(Thrt, T);
InTraverse_Thr(Thrt);
/*cout << endl;
cout << "前序遍历:";
PreTraverse(T);
cout << endl;
cout << "中序遍历:";
InTraverse(T);
cout << endl;
cout << "后序遍历:";
PosTraverse(T);
cout << endl;
cout << "先序遍历的非递归算法为:";
NoPreTraverse(T);
cout << endl;
cout << "中序遍历的非递归算法为:";
NoInTraverse(T);
cout << endl;
cout << "后序遍历的非递归算法为:";
NoPosTraverse(T);
cout << endl;
cout << "树的深度为:" << Depth(T) << endl;
cout << "树的节点个数为:" << NodeCount(T) << endl;
cout << "树的叶结点个数为:" << NodeCount(T) << endl;*/
return 0;
}
二叉线索树的线索化以及遍历
猜你喜欢
转载自blog.csdn.net/m0_43456002/article/details/104326389
今日推荐
周排行