数据结构学习笔记 --- 线索二叉树

1. 引言

为了更方便、快捷地遍历二叉树，最好在二叉树的结点上增加2个指针，它们分别指向遍历二叉树时该结点的前驱和后继。这

样，从二叉树的任一结点都可以方便的找到其他结点。但这样做大大降低了结构的存储密度。

另外，根据二叉树的性质，有：n0 = n2 + 1。空链域=2n0 + n1(叶子结点有两个空链域，度为1的结点有一个空链域)=n0+n2+1+n1

=n+1。也就是说，在由n个结点组成的二叉树中，有n+1个指针是空指针。如果能利用这n+1个空指针，使它们指向结点的前驱（当左孩子指针空）或后继（当有孩子指针空），则即可以不降低结点的存储密度，又可以方便的遍历二叉树。不过，这样就无法区别左右孩子指针所指的到底是结点的左右孩子，还是结点的前驱后继了。为了有所区别，另增两个域（LTag和RTag）。

2. 线索二叉树

#include "ds.h"

#define CHAR 1 // 字符型
// #define CHAR 0 // 整型(二者选一)
#if CHAR
typedef char TElemType;
TElemType Nil=' '; // 字符型以空格符为空
#define form "%c" // 输入输出的格式为%c
#else
typedef int TElemType;
TElemType Nil=0; // 整型以0为空
#define form "%d" // 输入输出的格式为%d
#endif
#define DEBUG
#ifdef DEBUG
int 	count = 1;
#endif

enum PointerTag	// 枚举
{
Link,		// 指针
Thread		// 线索
};

struct BiThrNode
{
TElemType 	data;
BiThrNode	*lchild, *rchild;	// 左右孩子指针
PointerTag	LTag, RTag;			// 左右标志
};

typedef 	BiThrNode*		BiThrTree;

BiThrTree pre; // 全局变量，始终指向刚刚访问过的结点

void CreateBiThrTree(BiThrTree &T);
void InThreading(BiThrTree p);
void InOrderThreading(BiThrTree &Thrt,BiThrTree T);
void InOrderTraverse_Thr(BiThrTree T,void(*Visit)(TElemType));

void PreThreading(BiThrTree p);
void PreOrderThreading(BiThrTree &Thrt,BiThrTree T);
void PreOrderTraverse_Thr(BiThrTree T,void(*Visit)(TElemType));

void PostThreading(BiThrTree p);
void PostOrderThreading(BiThrTree &Thrt,BiThrTree T);
void PostOrderTraverse_Thr(BiThrTree T,void(*Visit)(TElemType));

void DestroyBiTree(BiThrTree &T);
void DestroyBiThrTree(BiThrTree &Thrt);

// 二叉树的二叉线索存储的基本操作，包括算法

// 按先序输入线索二叉树中结点的值，构造线索二叉树T。0(整型)/空格(字符型)表
void CreateBiThrTree(BiThrTree &T)
{
TElemType ch;
scanf(form, &ch);

if (ch == Nil)
{
T = NULL;
}
else
{
T = (BiThrTree)malloc(sizeof(BiThrNode));	// 生成根结点(先序)
if (!T) exit(OVERFLOW);
T->data = ch;
#ifdef DEBUG
printf(form, ch);
printf("------ %d ------\n", count++);
#endif
CreateBiThrTree(T->lchild);	// 递归构造左子树
if (T->lchild)				// 有左孩子
T->LTag = Link;			// 给左标志赋值(指针)
CreateBiThrTree(T->rchild);	// 递归构造右子树
if (T->rchild)				// 有右孩子
T->RTag = Link;			// 给右标志赋值(指针)
}
}

// 通过中序遍历进行中序线索化，线索化之后pre指向最后一个结点。算法6.7
void InThreading(BiThrTree p)
{
if (p)	// 线索二叉树不空
{
InThreading(p->lchild);	// 递归左子树线索化
if (!p->lchild)			// 没有左孩子
{
p->LTag = Thread;	// 左标志为线索(前驱)
p->lchild = pre;	// 左孩子指针指向前驱
}
if (!pre->rchild)		// 前驱没有右孩子
{
pre->RTag = Thread;	// 前驱的右标志为线索(后继)
pre->rchild = p;	// 前驱右孩子指针指向其后继(当前结点p)
}
pre = p;				// 保持pre指向p的前驱
InThreading(p->rchild); // 递归右子树线索化
}
}

// 中序遍历二叉树T，并将其中序线索化，Thrt指向头结点。
void InOrderThreading(BiThrTree &Thrt,BiThrTree T)
{
if(!(Thrt=(BiThrTree)malloc(sizeof(BiThrNode)))) // 生成头结点不成功
exit(OVERFLOW);

Thrt->LTag = Link;		// 建头结点，左标志为指针
Thrt->RTag = Thread;	// 右标志为线索

Thrt->rchild = Thrt;	// 右指针回指
if (!T)					// 若二叉树空，则左指针回指
{
Thrt->lchild=Thrt;
}
else
{
Thrt->lchild = T;	// 头结点的左指针指向根结点
pre = Thrt;			// pre(前驱)的初值指向头结点
InThreading(T);		// 中序遍历进行中序线索化，pre指向中序遍历的最后一个结点
pre->rchild = Thrt;	// 最后一个结点的右指针指向头结点
pre->RTag = Thread;	// 最后一个结点的右标志为线索
Thrt->rchild = pre;	// 头结点的右指针指向中序遍历的最后一个结点
}
}

// 中序遍历线索二叉树T(头结点)的非递归算法。算法6.5
void InOrderTraverse_Thr(BiThrTree T,void(*Visit)(TElemType))
{
BiThrTree	p;
p = T->lchild; 		//

// 空树或遍历结束时，p==T
while (p != T)
{
while(p->LTag==Link) 	// 由根结点一直找到二叉树的最左结点
p=p->lchild;
Visit(p->data);			// 访问此结点

while(p->RTag==Thread&&p->rchild!=T) // p->rchild是线索(后继)，且不是遍历的最后一个结点
{
p = p->rchild;
Visit(p->data);		// 访问后继结点
}
p = p->rchild; 			// 若p->rchild不是线索(是右孩子)，p指向右孩子，返回循环，
}   // 找这棵子树中序遍历的第1个结点
}

// PreOrderThreading()调用的递归函数
void PreThreading(BiThrTree p)
{
if (p)	// 非空树
{
if (!pre->rchild)		// p的前驱没有右孩子
{
pre->rchild = p;	// p前驱的后继指向p
pre->RTag = Thread;	// pre的右孩子为线索
}
if (!p->lchild)			// p没有左孩子
{
p->LTag = Thread;	// p的左孩子为线索
p->lchild = pre;	// p的左孩子指向前驱
}

pre = p;				// 移动前驱
if (p->LTag == Link)	// p有左孩子
PreThreading(p->lchild);	// 对p的左孩子递归调用preThreading()
if (p->RTag == Link)	// p有右孩子
PreThreading(p->rchild);	// 对p的右孩子递归调用preThreading()
}
}

// 先序线索化二叉树T，头结点的右指针指向先序遍历的最后1个结点
void PreOrderThreading(BiThrTree &Thrt,BiThrTree T)
{
if (!(Thrt = (BiThrTree)malloc(sizeof(BiThrNode))))	// 生成头结点
exit(OVERFLOW);

Thrt->LTag = Link;		// 头结点的左指针为孩子
Thrt->RTag = Thread;	// 头结点的右指针为线索
Thrt->rchild = Thrt;	// 头结点的右指针指向自身

if (!T)	// 空树
Thrt->lchild = Thrt;// 头结点的左指针也指向自身
else	// 非空树
{
Thrt->lchild = T;	// 头结点的左指针指向根结点
pre = Thrt;			// 前驱为头结点
PreThreading(T);	// 从头结点开始先序递归线索化
pre->rchild = Thrt;	// 最后一个结点的后继指向头结点
pre->RTag = Thread;
Thrt->rchild = pre;	// 头结点的后继指向最后一个结点
}
}

// 先序遍历线索二叉树T(头结点)的非递归算法
void PreOrderTraverse_Thr(BiThrTree T,void(*Visit)(TElemType))
{
BiThrTree 	p = T->lchild;	// p指向根结点
while (p != T)	// p没指向头结点(遍历的最后1个结点的后继指向头结点)
{
Visit(p->data);			// 访问根结点
if (p->LTag == Link)	// p有左孩子
p = p->lchild;		// p指向左孩子(后继)
else	// p无左孩子
p = p->rchild;		// p指向右孩子或后继
}
}

// PostOrderThreading()调用的递归函数
void PostThreading(BiThrTree p)
{
if (p)
{
PostThreading(p->lchild);// 对p的左孩子递归调用PostThreading()
PostThreading(p->rchild);// 对p的右孩子递归调用PostThreading()

if (!p->lchild)			// p没有左孩子
{
p->LTag = Thread;	// p的左孩子为线索
p->lchild = pre;	// p的左孩子指向前驱
}

if (!pre->rchild)		// p的前驱没有右孩子
{
pre->rchild = p;	// p前驱的后继指向p
pre->RTag = Thread;	// pre的右孩子为线索
}
pre = p;				// 移动前驱
}
}

// 后序递归线索化二叉树
void PostOrderThreading(BiThrTree &Thrt,BiThrTree T)
{
if (!(Thrt = (BiThrTree)malloc(sizeof(BiThrNode))))	// 生成头结点
exit(OVERFLOW);

Thrt->LTag = Link;		// 头结点的左指针为孩子
Thrt->RTag = Thread;	// 头结点的右指针为线索

if (!T)	// 空树
Thrt->lchild = Thrt->rchild = Thrt;// 头结点的左右指针指向自身
else	// 非空树
{
Thrt->lchild = Thrt->rchild = Thrt;// 头结点的左右指针指向根结点(最后一个结点)
pre = Thrt;			// 前驱为头结点
PostThreading(T);	// 从头结点开始后序递归线索化

if (pre->RTag != Link);	// 最后一个结点没有右孩子
{
pre->rchild = Thrt;	// 最后一个结点的后继指向头结点
pre->RTag = Thread;
}
}
}

// DestroyBiThrTree调用的递归函数，T指向根结点
void PostOrderTraverse_Thr(BiThrTree T,void(*Visit)(TElemType))
{
// 对于后续线索化二叉树的后序遍历算法比较复杂，因为根结点是在最后访问，所以要采用带有双亲的三叉链表结构才行。本文没有给出其算法
}

// DestroyBiThrTree调用的递归函数，T指向根结点
void DestroyBiTree(BiThrTree &T)
{
if (T)	// 非空树
{
if (T->LTag == 0)				// 有左孩子
DestroyBiTree(T->lchild);	// 销毁左孩子子树
if (T->RTag == 0)				// 有右孩子
DestroyBiTree(T->rchild);	// 销毁右孩子子树
free(T);	// 释放根结点
T = NULL;	// 空指针赋0
}
}

// 初始条件：线索二叉树Thrt存在。操作结果：销毁线索二叉树Thrt
void DestroyBiThrTree(BiThrTree &Thrt)
{
if (Thrt)	// 头结点存在
{
if (Thrt->lchild)	// 根结点存在
{
DestroyBiTree(Thrt->lchild);	// 递归销毁头结点lchild所指二叉树
}
free(Thrt);		// 释放头结点
Thrt = NULL;	// 线索二叉树Thrt指针赋0
}
}

void vi(TElemType c)
{
printf(form" ",c);
}

int main()
{
BiThrTree H,T;
#if CHAR
printf("请按先序输入二叉树(如:ab三个空格表示a为根结点,b为左子树的二叉树)\n");
#else
printf("请按先序输入二叉树(如:1 2 0 0 0表示1为根结点,2为左子树的二叉树)\n");
#endif

CreateBiThrTree(T);		// 按先序产生二叉树

#if 0
PreOrderThreading(H,T); // 在先序遍历的过程中，先序线索化二叉树
printf("先序遍历(输出)线索二叉树:\n");
PreOrderTraverse_Thr(H,vi);
#endif

#if 0
InOrderThreading(H, T);
printf("中序遍历(输出)线索二叉树:\n");
InOrderTraverse_Thr(H,vi); // 中序遍历(输出)线索二叉树
#endif

PostOrderThreading(H,T); // 在后序遍历的过程中，后序线索化二叉树

printf("program over\n");
DestroyBiThrTree(H); // 销毁线索二叉树

return 0;
}