二叉树的遍历
👉数据结构-树和二叉树(二)二叉树的遍历
本文详细介绍了二叉树的中序,先序和后序的线索化、遍历和代码实现;
Let’s go!🏃♂️
数据结构-树和二叉树(三)二叉树线索化
思维导图
1、基本概念
普通二叉树只能找到结点的左右孩子信息,而该结点的直接前驱和直接后继只能在遍历过程中获得,
若将遍历后对应的有关前驱和后继预存起来,则从第一个结点开始就能很快“顺藤摸瓜”而遍历整个树。
思路:
若结点有左子树,则lchild指向其左孩子;否则,lchild指向其直接前驱(即线索);
若结点有右子树,则rchild指向其右孩子;否则,rchild指向其直接后继(即线索) 。
LTag: 若 LTag=0, lchild域指向左孩子;
若 LTag=1, lchild域指向其前驱。
RTag: 若 RTag=0, rchild域指向右孩子;
若 RTag=1, rchild域指向其后继。
线索二叉树的遍历
2、中序线索二叉树
#include <iostream>
#include <string>
using namespace std;
typedef struct ThreadNode {
int value;
struct ThreadNode *lChild, *rChild;
int lTag, rTag; //左右线索标志
//tag == 0 表示孩子
//tag == 1 表示线索
}ThreadNode, *ThreadTree;
ThreadNode *pre = nullptr; //全局变量pre,指当前访问结点的前驱
/**
* 创建二叉树
* @param root
*/
void CreateBinaryTree(ThreadTree &root) {
auto *node1 = (ThreadNode *)malloc(sizeof(ThreadNode));
auto *node2 = (ThreadNode *)malloc(sizeof(ThreadNode));
auto *node3 = (ThreadNode *)malloc(sizeof(ThreadNode));
auto *node4 = (ThreadNode *)malloc(sizeof(ThreadNode));
auto *node5 = (ThreadNode *)malloc(sizeof(ThreadNode));
auto *node6 = (ThreadNode *)malloc(sizeof(ThreadNode));
root->rTag = 0; root->lTag = 0;
node1->rTag = 0; node1->lTag = 0;
node2->rTag = 0; node2->lTag = 0;
node3->rTag = 0; node3->lTag = 0;
node4->rTag = 0; node4->lTag = 0;
node5->rTag = 0; node5->lTag = 0;
node6->rTag = 0; node6->lTag = 0;
root->value = 15;
node1->value = 10;
node2->value = 23;
node3->value = 8;
node4->value = 12;
node5->value = 21;
node6->value = 9;
//
root->lChild = node1;
root->rChild = node2;
//
node1->lChild = node3;
node1->rChild = node4;
node2->lChild = node5;
node2->rChild = nullptr;
//
node3->lChild = nullptr;
node3->rChild = node6;
node4->lChild = nullptr;
node4->rChild = nullptr;
node5->rChild = nullptr;
node5->lChild = nullptr;
//
node6->lChild = nullptr;
node6->rChild = nullptr;
}
/**
* 访问根结点
* @param p
*/
void visit(ThreadNode *p) {
if (p->lChild == nullptr) { //如果左子树为空,建立前驱线索
p->lChild = pre; //左孩子设为前驱结点
p->lTag = 1; //左标志设为1,代表有线索
}
if (pre != nullptr && pre->rChild == nullptr) { //如果右子树为空,建立前驱结点的后继线索
pre->rChild = p; //前驱节点的后继线索
pre->rTag = 1; //右标志设为1,代表有线索
}
pre = p; //前驱结点更换
}
/**
* 中序遍历二叉树,一边遍历一遍线索化; 左根右遍历
* @param p 根结点
*/
void InThread(ThreadTree &p) {
if (p == nullptr) { //结点为空返回
return;
}
InThread(p->lChild); //中序遍历左子树
visit(p); //根节点线索化
InThread(p->rChild); //中序遍历右子树
}
/**
* 中序线索化二叉树
* @param root
* @return
*/
bool CreatInThread(ThreadTree &root) {
//根节点不为空
if (root != nullptr) {
InThread(root); //中序线索化二叉树
if (pre->rChild == nullptr) //处理遍历的最后一个结点
pre->rTag = 1;
}
}
/**
* 中序获得首一个结点
* @param p
* @return
*/
ThreadNode *FirstInNode(ThreadNode *p) {
while (p->lTag == 0) { //最左下结点
p = p->lChild;
}
return p;
}
/**
* 中序获得下一个一个结点
* @param p
* @return
*/
ThreadNode *NextInNode(ThreadNode *p) {
if (p->rTag == 0) {
return FirstInNode(p->rChild);
}else { //rTag == 1,直接返回后继线索
return p->rChild;
}
}
/**
* 中序线索二叉树的遍历
* @param root
*/
void InOrder(ThreadNode *root) {
for (ThreadNode *p = FirstInNode(root); p != nullptr ; p = NextInNode(p)) {
cout << p->value << "->";
}
}
int main() {
ThreadTree root;
root = (ThreadNode *)malloc(sizeof(ThreadNode));
cout << "初始化创建二叉树" << endl;
CreateBinaryTree(root);
//
cout << "中序遍历线索化" << endl;
CreatInThread(root);
cout << "中序线索化二叉树的中序遍历" << endl;
InOrder(root);
return 0;
}
初始化创建二叉树
中序遍历线索化
中序线索化二叉树的中序遍历
8->9->10->12->15->21->23->
3、先序线索二叉树
思路: 找后继遍历先序线索二叉树
若p->rTag == 1,则next = p->rChild
若p->rTag == 0
① 若有左孩子,则先序后继为左孩子
② 若没有左孩子,则先序后继为右孩子
//数据结构定义看上面中序线索二叉树代码
/**
* 访问根结点
* @param p
*/
void visit(ThreadNode *p) {
if (p->lChild == nullptr) { //如果左子树为空,建立前驱线索
p->lChild = pre; //左孩子设为前驱结点
p->lTag = 1; //左标志设为1,代表有线索
}
if (pre != nullptr && pre->rChild == nullptr) { //如果右子树为空,建立前驱结点的后继线索
pre->rChild = p; //前驱节点的后继线索
pre->rTag = 1; //右标志设为1,代表有线索
}
pre = p; //前驱结点更换
}
/**
* 先序遍历二叉树,一边遍历一遍线索化;根左右遍历
* @param p
*/
void PreThread(ThreadTree &p) {
if (p != nullptr) { //结点非空
visit(p); //根节点线索化
if (p->lTag == 0) //左子树不是前驱线索
PreThread(p->lChild); //先序遍历左子树
if (p->rTag == 0) //右子树不是前驱线索
PreThread(p->rChild); //先序遍历右子树
}
}
/**
* 先序线索化二叉树
* @param root
* @return
*/
bool CreatPreThread(ThreadTree &root) {
//
if (root != nullptr) {
PreThread(root); //先序线索化二叉树
if (pre->rChild == nullptr) //处理遍历的最后一个结点
pre->rTag = 1;
}
}
/**
* 先序获得下一个结点
* @param p
* @return
*/
ThreadNode *NextPreNode(ThreadNode *p) { //
if (p->rTag == 1) { //如果rTag == 1,有直接后继,返回直接后继
return p->rChild;
}else { //没有
if (p->lTag == 0) { //无左标志线索,有孩子
return p->lChild; //返回左孩子
}else { //有左标志线索
return p->rChild; //返回右孩子
}
}
}
/**
* 先序线索二叉树的遍历
* @param root
*/
void PreOrder(ThreadNode *root) {
for (ThreadNode *p = root; p != nullptr; p = NextPreNode(p)) {
cout << p->value << "->";
}
}
初始化创建二叉树
先序遍历线索化
先序线索化二叉树的先序遍历
15->10->8->9->12->23->21->
4、后序线索二叉树
思路: 找前驱遍历后序线索二叉树
若p->rLag == 1,则pre = p->lChild
若p->lTag == 0
① 若有右孩子,则后序前驱为右孩子
② 若有左孩子,则后序前驱为左孩子
//数据结构定义看上面中序线索二叉树代码
/**
* 访问根结点
* @param p
*/
void visit(ThreadNode *p) {
if (p->lChild == nullptr) { //如果左子树为空,建立前驱线索
p->lChild = pre; //左孩子设为前驱结点
p->lTag = 1; //左标志设为1,代表有线索
}
if (pre != nullptr && pre->rChild == nullptr) { //如果右子树为空,建立前驱结点的后继线索
pre->rChild = p; //前驱节点的后继线索
pre->rTag = 1; //右标志设为1,代表有线索
}
pre = p; //前驱结点更换
}
/**
* 后序遍历二叉树,一边遍历一遍线索化;左右根遍历
* @param p
*/
void PostThread(ThreadTree &p) {
if (p == nullptr) { //结点为空返回
return;
}
PostThread(p->lChild); //后序遍历左子树
PostThread(p->rChild); //后序遍历右子树
visit(p); //根节点线索化
}
/**
* 后序线索化二叉树
* @param root
* @return
*/
bool CreatPostThread(ThreadTree &root) {
//
if (root != nullptr) {
PostThread(root); //后序线索化二叉树
if (pre->rChild == nullptr) //处理遍历的最后一个结点
pre->rTag = 1;
}
}
/**
* 后序获得最后一个结点
* @param p
* @return
*/
ThreadNode *LastPostNode(ThreadNode *p) {
return p;
}
/**
* 后序获得上一个一个结点
* @param p
* @return
*/
ThreadNode *PrePostNode(ThreadNode *p) {
if (p->lTag == 1) { //有直接前驱
return p->lChild;
}else { //lTag == 0 无直接前驱
if (p->rChild != nullptr && p->rTag == 0) { //如果右孩子存在,且rTag==0,则右孩子为直接前驱
return LastPostNode(p->rChild);
}else if (p->lChild != nullptr && p->lTag == 0) { //如果左孩子存在,且rTag==0,则左孩子为直接前驱
return LastPostNode(p->lChild);
}
}
}
/**
* 后序线索二叉树的遍历
* @param root
*/
void PostOrder(ThreadNode *root) {
for (ThreadNode *p = LastPostNode(root); p != nullptr ; p = PrePostNode(p)) {
cout << p->value << "->";
}
}
int main() {
ThreadTree root;
root = (ThreadNode *)malloc(sizeof(ThreadNode));
cout << "初始化创建二叉树" << endl;
CreateBinaryTree(root);
cout << "后序遍历线索化" << endl;
CreatPostThread(root);
cout << "后序线索化二叉树的先序遍历" << endl;
PostOrder(root);
return 0;
}
初始化创建二叉树
后序遍历线索化
后序线索化二叉树的先序遍历
15->23->21->10->12->8->9->