【数据结构】线索二叉树的实现（C语言）

比眉伴天荒 2023-02-19 15:26 2阅读 0赞

### 文章目录 ###

*   *  线索二叉树原理
     *  线索二叉树结构实现
     *  测试代码

## 线索二叉树原理 ##

观察图1-1，发现指针域并没有被充分利用，有许许多多的 ^ 也就是空指针域的存在，应该想办法利用起来。  
![在这里插入图片描述][20200621143800887.png_pic_center]

图1-1  
首先我们要来看一下这空指针有多少个呢？对于一个有n个结点的二叉链表，每个结点指向左右孩子的两个指针域，所以一共是2n个指针域。而n个结点的二叉树一共有n-1条分支线，也就说说，其实是存在2n-（n-1）=n+1个空指针域。

比如图1-1有10个结点，而带有“^”空指针域为11，这些存储空间不存储任何事物，白白的浪费着内存的资源。

另一方面，我们在做遍历时，比如对图1-1做了中序遍历，得到了字符序列HDIBJEAFCG这样的字符序列，遍历过后，我们可以知道，结点I的前驱是D，后继是B，结点F的前驱是A，后继是C，也就是说，我们可以清楚的看到任意一个结点，它的前驱和后继是哪一个。

可是这是建立在已经遍历过的基础上的。在二叉链表上，我们只能知道每个结点指向其左右孩子结点的地址，而不知道某个结点的前驱是谁，后继是谁。要想知道，必须遍历一次。以后每次需要知道时，都必须先遍历一次。为什么不考虑在创建时就记住这些前驱和后继了?

我们可以利用这些空地址，存放指向结点在某种遍历次序下的前驱和后继结点的地址。**我们把这种指向前驱和后继的指针称为线索，加上线索的二叉链表称为线索链表，相应的二叉树就称为线索二叉树。**

图1-2，我们把整个二叉树中序遍历之后，将所有的空指针域中的rchild，改为指向它的后继结点， 也是我们就可以通过指针知道H的后继是D（图中的①）I的后继是B（图中的②）J的后继是E（图中③）E的后继是A（图中④），F的后继是C（图中⑤），G的后继因为不存在而执行NULL（图中⑥），此时共有6个空指针被利用。  
![在这里插入图片描述][20200621150929766.png_pic_center]

图1-2

再看图1-3，我们将这棵二叉树的所有空指针域中的lchild，改为指向当前结点的前驱，因此H的前驱是NULL（图中①），I的前驱是D（图中②）。J的前驱树B（图中③）F的前驱是A（图中④），G的前驱是C（图中⑤），一共5个空指针域被利用，正好和上面的后继加起来是11个。  
![在这里插入图片描述][20200622182042822.png_pic_center]

图1-3  
通过图1-4（空心箭头实线为前驱，虚线黑箭头为后继），就更容易看出，其实线索二叉树，等于是把一颗二叉树转变成了一个双向链表，这样我们的插入结点，查找某个结点都带来了方便，所有我们对 **二叉树以某种次序遍历使其变为线索二叉树的过程称为线索化。**  
![在这里插入图片描述][20200622182548675.png_pic_center] 图1-4  
我们如何知道某一结点的lchild是指向它的左孩子还是指向前驱？rchild是指向右孩子还是后继？比如E结点的lchild是指向它的左孩子J，而child是指向右孩子还是后继A。显然我们在决定lchild是指向左孩子还是前驱，rchild是指向右孩子还是后继上时需要一个分区标志的。因此，我们在每个结点在增设两个标识域ltag和rtag，注意ltag和rtag只是存放0或者1数字的布尔型变量，其占用的内存空间要小于像lchild和rchild的指针变量。结点结构如图1-5所示。  
![在这里插入图片描述][20200623205252363.png_pic_center] 图1-5

*  ltag为0时指向结点的左孩子，为1时指向该结点的前驱。
 *  rtag为0时指向该结点右孩子，为1时指向该结点的后继。
 *  因此对图1-1的二叉链表可以改为图1-6所示的结构图。  
    ![在这里插入图片描述][20200623205621515.png_pic_center] 图1-6

## 线索二叉树结构实现 ##

线索二叉树的存储结构定义

typedef enum {
        Link,Thread} PointerTag;	/* Link==0表示指向左右孩子指针, */
    										/* Thread==1表示指向前驱或后继的线索 */
    typedef  struct BiThrNode	/* 二叉线索存储结点结构 */
    {
        
    	TElemType data;	/* 结点数据 */
    	struct BiThrNode *lchild, *rchild;	/* 左右孩子指针 */
    	PointerTag LTag;
    	PointerTag RTag;		/* 左右标志 */
    } BiThrNode, *BiThrTree;

线索化的实质就是将二叉链表的空指针改为指向前驱或者后继的线索。由于前驱和后继的信息只有在遍历该二叉树时才能得到，所以**线索化的二叉树的过程就是在遍历的过程中修改空指针的过程。**

BiThrTree pre; /* 全局变量,始终指向刚刚访问过的结点 */
    /* 中序遍历进行中序线索化 */
    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); /* 递归右子树线索化 */
    	}
    }

观察发现其实和二叉树中序遍历的递归代码几乎一模一样。

有了线索二叉树之后，我们对它遍历时发现，其实就等于是操作一个双向链表结构。  
和双向链表结构一样，在二叉树线索链表上添加一个头结点，如图1-7所示，并令其lchild域的指针指向二叉树的根结点（图中①），其rchild域的指针指向中序遍历时访问的最后一个结点（图中的②），反正，令二叉树的中序序列中的第一个结点中，lchild域指针和最后一个结点的rchild域指针均指向头结点（图中的③和④），这样定义的好处就是我们既可以从第一个结点起顺后继进行遍历，也可以从最后一个结点起前驱进行遍历。 ![在这里插入图片描述][20200623211628622.png_pic_center]

图1-7  
遍历的代码如下：

Status InOrderTraverse_Thr(BiThrTree T)
    {
         
    	BiThrTree p;
    	p=T->lchild; /* p指向根结点 */
    	while(p!=T)
    	{
         /* 空树或遍历结束时,p==T */
    		while(p->LTag==Link)
    			p=p->lchild;
    		printf("%c",p->data); //显示结点数据，可以更改为对其他结点的操作
    		while(p->RTag==Thread&&p->rchild!=T)
    		{
        
    			p=p->rchild;
    			printf(p->data); /* 访问后继结点 */
    		}
    		p=p->rchild;
    	}
    	return OK;
    }

从这段代码可以看出， 他等于是一个链表的扫描，所以时间复杂度为O(n  
)。由于它充分利用了空指针的空间，又保证了创建时的一次遍历就可以终生受用的前驱后继信息。所以在实际问题中，**如果所用的二叉树需经常遍历或查找结点时需要某种遍历序列中的前驱和后继，那么采用线索二叉链表的存储结构就是非常存储结构就是非常不错的结构。**

## 测试代码 ##

#include "string.h"
    #include "stdio.h"    
    #include "stdlib.h"   
    #include "io.h"  
    #include "math.h"  
    #include "time.h"
    
    #define OK 1
    #define ERROR 0
    #define TRUE 1
    #define FALSE 0
    
    #define MAXSIZE 100 /* 存储空间初始分配量 */
    
    typedef int Status;	/* Status是函数的类型,其值是函数结果状态代码,如OK等 */
    typedef char TElemType;
    typedef enum {
        Link,Thread} PointerTag;	/* Link==0表示指向左右孩子指针, */
    										/* Thread==1表示指向前驱或后继的线索 */
    typedef  struct BiThrNode	/* 二叉线索存储结点结构 */
    {
        
    	TElemType data;	/* 结点数据 */
    	struct BiThrNode *lchild, *rchild;	/* 左右孩子指针 */
    	PointerTag LTag;
    	PointerTag RTag;		/* 左右标志 */
    } BiThrNode, *BiThrTree;
    
    TElemType Nil='#'; /* 字符型以空格符为空 */
    
    Status visit(TElemType e)
    {
        
    	printf("%c ",e);
    	return OK;
    }
    
    /* 按前序输入二叉线索树中结点的值,构造二叉线索树T */
    /* 0(整型)/空格(字符型)表示空结点 */
    Status CreateBiThrTree(BiThrTree *T)
    {
         
    	TElemType h;
    	scanf("%c",&h);
    
    	if(h==Nil)
    		*T=NULL;
    	else
    	{
        
    		*T=(BiThrTree)malloc(sizeof(BiThrNode));
    		if(!*T)
    			exit(OVERFLOW);
    		(*T)->data=h; /* 生成根结点(前序) */
    		CreateBiThrTree(&(*T)->lchild); /* 递归构造左子树 */
    		if((*T)->lchild) /* 有左孩子 */
    			(*T)->LTag=Link;
    		CreateBiThrTree(&(*T)->rchild); /* 递归构造右子树 */
    		if((*T)->rchild) /* 有右孩子 */
    			(*T)->RTag=Link;
    	}
    	return OK;
    }
    
    BiThrTree pre; /* 全局变量,始终指向刚刚访问过的结点 */
    /* 中序遍历进行中序线索化 */
    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指向头结点 */
    Status InOrderThreading(BiThrTree *Thrt,BiThrTree T)
    {
         
    	*Thrt=(BiThrTree)malloc(sizeof(BiThrNode));
    	if(!*Thrt)
    		exit(OVERFLOW);
    	(*Thrt)->LTag=Link; /* 建头结点 */
    	(*Thrt)->RTag=Thread;
    	(*Thrt)->rchild=(*Thrt); /* 右指针回指 */
    	if(!T) /* 若二叉树空,则左指针回指 */
    		(*Thrt)->lchild=*Thrt;
    	else
    	{
        
    		(*Thrt)->lchild=T;
    		pre=(*Thrt);
    		InThreading(T); /* 中序遍历进行中序线索化 */
    		pre->rchild=*Thrt;
    		pre->RTag=Thread; /* 最后一个结点线索化 */
    		(*Thrt)->rchild=pre;
    	}
    	return OK;
    }
    
    /* 中序遍历二叉线索树T(头结点)的非递归算法 */
    Status InOrderTraverse_Thr(BiThrTree T)
    {
         
    	BiThrTree p;
    	p=T->lchild; /* p指向根结点 */
    	while(p!=T)
    	{
         /* 空树或遍历结束时,p==T */
    		while(p->LTag==Link)
    			p=p->lchild;
    		if(!visit(p->data)) /* 访问其左子树为空的结点 */
    			return ERROR;
    		while(p->RTag==Thread&&p->rchild!=T)
    		{
        
    			p=p->rchild;
    			visit(p->data); /* 访问后继结点 */
    		}
    		p=p->rchild;
    	}
    	return OK;
    }
    
    int main()
    {
        
    	BiThrTree H,T;
    	printf("请按前序输入二叉树(如:'ABDH##I##EJ###CF##G##')\n");
     	CreateBiThrTree(&T); /* 按前序产生二叉树 */
    	InOrderThreading(&H,T); /* 中序遍历,并中序线索化二叉树 */
    	printf("中序遍历(输出)二叉线索树:\n");
    	InOrderTraverse_Thr(H); /* 中序遍历(输出)二叉线索树 */
    	printf("\n");
    	
    	return 0;
    }

[20200621143800887.png_pic_center]: https://img-blog.csdnimg.cn/20200621143800887.png#pic_center
[20200621150929766.png_pic_center]: https://img-blog.csdnimg.cn/20200621150929766.png#pic_center
[20200622182042822.png_pic_center]: https://img-blog.csdnimg.cn/20200622182042822.png#pic_center
[20200622182548675.png_pic_center]: https://img-blog.csdnimg.cn/20200622182548675.png#pic_center
[20200623205252363.png_pic_center]: https://img-blog.csdnimg.cn/20200623205252363.png#pic_center
[20200623205621515.png_pic_center]: https://img-blog.csdnimg.cn/20200623205621515.png#pic_center
[20200623211628622.png_pic_center]: https://img-blog.csdnimg.cn/20200623211628622.png#pic_center