【数据结构】五、树：3.线索二叉树（线索化）

最新推荐文章于 2024-08-09 20:13:32 发布
最新推荐文章于 2024-08-09 20:13:32 发布
阅读量594 收藏 25
点赞数 14
分类专栏： 数据结构 文章标签： 数据结构 c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51350847/article/details/140992822
版权

三、线索二叉树

文章目录

1.原理&作用

遍历二叉树是以一定的规则将二叉树（树型）中的结点排列成一个线型序列，从而得到几种遍历序列，使得该序列中的每个结点（第一个和最后一个结点除外）都有一个直接前驱和直接后继。

普通二叉链表（二叉树）的一个结点，仅能体现一种父子关系，不能直接得到结点在遍历中的前驱或后继。它只有向下的两个孩子结点的指针，没有向上的父结点的指针。

所以每次想要确定前驱时，只能再进行一次遍历：

(动图过大)

为了解决这个问题。

在这里插入图片描述
请添加图片描述

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

所以利用这些空指针来存放指向其前驱或后继的指针，这样就可以像遍历单链表那样方便地遍历二叉树。引入线索二叉树正是为了加快查找结点前驱和后继的速度。

我们把这种指向前驱和后继的指针称为线索，加上线索的二叉链表称为线索链表，相应的二叉树就称为线索二叉树（Threaded Binary Tree）。

2.存储结构

其结点结构如下所示：

lchildltagdatartagrchild

其中，ltag, rtag初始化时，都为0。

  • ltag==0时指向该结点的左孩子，为1时指向该结点的前驱。
  • rtag==0时指向该结点的右孩子，为1时指向该结点的后继。
//二叉树的结点（线索链表）
typedef struct ThreadNode{
	ElemType data;	//数据元素
	struct ThreadNode *lchild, *rchild;	//左、右孩子指针
	int ltag, rtag;	//左、右线索标志
}ThreadNode, *ThreadTree;

因此对于上图的二叉链表图可以修改为下图的样子。

在这里插入图片描述

在这里插入图片描述

创建线索二叉树

从代码层面来看，创建线索二叉树的过程可以分为两步：

  1. 建立二叉树：根据遍历序列创建一颗普通的二叉树。

    根据遍历序列，将节点按照遍历次序连接起来的过程。在这个过程中，只关心节点之间的父子关系，而不关心前驱和后继关系。

  2. 线索化：遍历二叉树，根据遍历次序判断每个节点的左右孩子是否为空，并设置相应的线索标志。

    在建立二叉树的基础上，为每个节点添加前驱和后继信息的过程。这个过程需要遍历二叉树两次，第一次遍历是为了确定每个节点的前驱和后继，第二次遍历是为了设置线索标志。

线索二叉树可以直接由遍历序列创建，而无需先构造一棵普通的二叉树。例如，可以使用先序遍历序列、中序遍历序列或后序遍历序列来创建线索二叉树。

线索二叉树的存储结构与普通二叉树不同。在普通二叉树中，每个节点只有左右孩子指针，而在线索二叉树中，每个节点还增加了左标志和右标志，用于表示前驱和后继信息。

线索二叉树的遍历算法与普通二叉树不同。由于线索二叉树中包含了前驱和后继信息，因此可以使用线索遍历算法来遍历线索二叉树，而无需像普通二叉树那样使用递归或迭代算法。

3.二叉树线索化

二叉树的线索化是将二叉链表中的空指针改为指向前驱或后继的线索。而前驱或后继的信息只有在遍历时才能得到，因此线索化的实质就是遍历一次二叉树，线索化的过程就是在遍历的过程中修改空指针的过程。

在这里插入图片描述

在这里插入图片描述

3.1中序线索化

设指针pre指向刚刚访问过的结点，指针p指向正在访问的结点，即pre指向p的前驱。在中序遍历的过程中，

  1. 检查p的**左指针lchild**是否为空，若为空就将它指向pre；
  2. 检查pre的**右指针rchild**是否为空，若为空就将它指向p。

在这里插入图片描述

上图中序：BDAEC

通过中序遍历对二叉树线索化的递归算法如下：

//二叉树的结点（线索链表）
typedef struct ThreadNode{
	ElemType data;	//数据元素
	struct ThreadNode *lchild, *rchild;	//左、右孩子指针
	int ltag, rtag;	//左、右线索标志
}ThreadNode, *ThreadTree;

//线索化：一边遍历，一边线索化
void InThread(ThreadTree p, ThreadTree &pre){
	if(p != NULL){
		InThread(p->lchild, pre);	//递归，线索化左子树
        //---
		if(p->lchild == NULL){	//左子树为空，建立前驱线索
			p->lchild = pre;
			p->ltag = 1;
		}
		if(pre != NULL && pre->rchild == NULL){
			pre->rchild = p;	//建立前驱结点的后继线索
			pre->rtag = 1;
		}
		pre = p;	//标记当前结点成为刚刚访问过的结点
        //---
		InThread(p->rchild, pre);	//递归，线索化右子树
	}
}

会发现，除了中间的代码，和二叉树中序遍历的递归代码几乎完全一样。只不过将本是访问结点的功能改成了线索化的功能，相当于：

void InThread(ThreadTree T){
	if(T!=NULL){
		InThread(T->lchild);//递归线索化左子树
		visit(T)
		InThread(T->rchild);//递归线索化右子树
	}
}

void visit(ThreadTree p){
    if(p->lchild == NULL){	//左子树为空，建立前驱线索
        p->lchild = pre;
        p->ltag = 1;
    }
    if(pre != NULL && pre->rchild == NULL){
        pre->rchild = p;	//建立前驱结点的后继线索
        pre->rtag = 1;
    }
    pre = p;	//标记当前结点成为刚刚访问过的结点
}
❗中序线索化代码
//二叉树的结点（线索链表）
typedef struct ThreadNode{
	ElemType data;	//数据元素
	struct ThreadNode *lchild, *rchild;	//左、右孩子指针
	int ltag, rtag;	//左、右线索标志
}ThreadNode, *ThreadTree;

// 中序线索化。一边遍历，一边线索化
// 后序线索化的代码和中序完全相同
void InThread(ThreadNode* p, ThreadNode* &pre)
{
	if(p != NULL){
		InThread(p->lchild, pre);	//递归，线索化左子树

        //---
		//左子树为空，建立前驱线索
		if(p->lchild == NULL){
			p->lchild = pre;
			p->ltag = 1;
		}
		//右子树为空，建立前驱结点的后继线索
		if(pre != NULL && pre->rchild == NULL){ // pre != NULL 排除第一个结点前驱为空的情况
			pre->rchild = p;
			pre->rtag = 1;
		}
		pre = p;	//标记当前结点成为刚刚访问过的结点
        //---

		InThread(p->rchild, pre);	//递归，线索化右子树
	}
}
// 中序线索化
void CreateInThread(ThreadTree T){
	ThreadNode *pre = NULL;	//第一个结点没有前驱，这里的NULL会赋给第一个结点的前驱
	if(T != NULL){
		InThread(T, pre);	//线索化二叉树
		pre->rchild = NULL;	//遍历结束后的最后一个结点没有后继
		pre->rtag = 1;
	}
}
头结点

为了方便，可以在二叉树的线索链表上也添加一个头结点，令其lchild域的指针指向二叉树的根结点，其rchild域的指针指向中序遍历时访问的最后一个结点。

令二叉树中序序列中的第一个结点的lchild域指针和最后一个结点的rchild域指针均指向头结点。这好比为二叉树建立了一个双向线索链表，方便从前往后或从后往前对线索二叉树进行遍历，如下图所示：

在这里插入图片描述

遍历的代码如下：

/*T指向头结点，头结点左链lchild指向根结点，头结点右链rchild指向中序遍
的最后一个结点。中序遍历二叉线索链表表示的二叉树T
*/
void InOrderTraverse_Thr(BiThrTree T){
	BiThrTree p;
	p = T->lchild;	//p指向根结点
	//空树或遍历结束时，p==T（最后一个结点指向根结点）
	while(p != T){	
		//当ltag==0时循环到中序序列第一个结点
		while(p->ltag == 0){	
			p = p->lchild;	//p指向p的左子树
		}
		visit(p);	//访问该结点
		//后继线索为1且不是指向头指针
		while(p->rtag == 1 && p->rchild != T){	
			p = p->rchild;	//p指向p的后继
			visit(p);	//访问该节点
		}
		//p进至其右子树根，开始对右子树根进行遍历
		p = p->rchild;	
	}
}

从这段代码也可以看出，它等于是一个链表的扫描，所以时间复杂度为0(n)。

由于它充分利用了空指针域的空间（这等于节省了空间），又保证了创建时的一次遍历就可以终生受用前驱后继的信息（这意味着节省了时间）。所以在实际问题中，如果所用的二叉树需经常遍历或查找结点时需要某种遍历序列中的前驱和后继，那么采用线索二叉链表的存储结构就是非常不错的选择。

3.2先序、后序线索化

上面给出了建立中序线索二叉树的代码，建立先序线索二叉树和后序线索二叉树的代码类似，只需变动线索化改造的代码段与调用线索化左右子树递归函数的位置。

以图(a)的二叉树为例，其先序序列为ABCDF，后序序列为CDBFA，可得出其先序和后序线索二叉树分别如图(b)和©所示：

先序、后序线索树

【注意】先序线索化的代码和中序基本相同，但是有一点不同，当一个结点没有左孩子时候，它的左指针lchild会指向前驱，这时候，lchild所指的并不是左子树，而是左线索，所以会出现遍历错误。

//先序遍历
void Pre0rder(BiTree T){
    if(T!=NULL){
        visit(T)//访问根结点，比如打印
            
		PreOrder(T->lchild);//递归遍历左子树
        
        Pre0rder(T->rchild);//递归遍历右子树
	}
}

所以需要改为：

void PreThread(ThreadTree T){
    if(T!=NULL){
        visit(T)	//处理
            
        if(T->ltag == 0){	//0表示孩子（子树）
            PreOrder(T->lchild);//递归遍历左子树
        }
        
        Pre0rder(T->rchild);	//递归遍历右子树
	}
}
❗前序线索化代码
// 前序线索化
// 先序线索化的代码和中序基本相同，但是有一点不同，当一个结点没有左孩子时候，它的左指针lchild会指向前驱，这时候，lchild所指的并不是左子树，而是左线索，所以会出现遍历错误。
void PreThread(ThreadNode* p, ThreadNode* &pre) // 前序线索化二叉树子函数
{
    if(p != NULL){
		//左子树为空，建立前驱线索
        if(p->lchild == NULL){
            p->lchild = pre;
            p->ltag = 1;
        }
		//右子树为空，建立前驱结点的后继线索
        if(pre != NULL && pre->rchild == NULL){ // pre != NULL 排除第一个结点前驱为空的情况
            pre->rchild = p;
            pre->rtag = 1;
        }
        pre = p;

        // 【注意】这里在递归入口处有条件限制，左、右指针不是线索才能继续递归
        if(p->ltag == 0)
            PreThread(p->lchild, pre); // 递归，左子树线索化
        if(p->rtag == 0)
            PreThread(p->rchild, pre); // 递归，右子树线索化
    }
}
void CreatePreThread(ThreadTree T){ // 前序线索化二叉树
    ThreadNode *pre = NULL;
    if(T != NULL){
        PreThread(T, pre);
        pre->rchild = NULL; // 非空二叉树，线索化
        pre->rtag = 1; // 后处理中序最后一个结点
    }
}

后序线索化的代码和中序完全相同。

❗后序线索化代码
// 后序线索化
// 后序线索化的代码和中序完全相同，只有顺序不同
void PostThread(ThreadNode* p, ThreadNode* &pre){ // 后序线索化二叉树子函数
    if(p != NULL){
        PostThread(p->lchild, pre); // 递归，左子树线索化
        PostThread(p->rchild, pre); // 递归，右子树线索化

        if(p->lchild == NULL){
            // 建立当前节点的前驱线索
            p->lchild = pre;
            p->ltag = 1;
        }
        if(pre != NULL && pre->rchild == NULL){ // pre != NULL 排除第一个结点前驱为空的情况
            // 建立当前节点的后继线索
            pre->rchild = p;
            pre->rtag = 1;
        }
        pre = p;
    }
}
// 后序线索化
void CreatePostThread(ThreadTree T){ // 前序线索化二叉树
    ThreadNode *pre = NULL;
    if(T != NULL){
        PostThread(T, pre);
        pre->rchild = NULL; // 非空二叉树，线索化
        pre->rtag = 1; // 后处理中序最后一个结点
    }
}

4.根据线索二叉树找前驱后继

4.1中序

因为二叉树已经被中序线索化，所以我们遍历链表，并按照中序（左->根->右）的方式访问结点即可。

在中序线索二叉树中找结点的前驱、后继：

  1. 如果二叉树指针被线索化（叶子节点，ltag和rtag是1），那么前驱和后继就是结点的lchild和rchild。

  2. 如果ltag和rtag是0，

    1. 后继就是结点右子树最左下角的结点；

      img

    2. 前驱就是结点左子树最右下角的结点。

      img

//找到以P为根的子树中，第一个被中序遍历的结点
ThreadNode *FirstNode(ThreadNode *p){
	//循环找到右子树最左下结点(不一定是叶结点)
    while(p->ltag == 0)
        p=p->lchild;
    return p;
}
//在中序线索二叉树中找到结点p的后继结点
ThreadNode *Next(ThreadNode *p){
	//右子树中最左下结点
    if(p->rtag == 0)
        return FirstNode(p->rchild);
    else
        return p->rchild;	//rtag==1直接返回后继线索
}


//找到以P为根的子树中，最后一个被中序遍历的结点
ThreadNode *LastNode(ThreadNode *p){
    //循环找到最右下结点（不一定是叶子结点）
    while(p->rtag == 0)
        p = p->rchild;
    return p;
}
//在中序线索二叉树中找到结点p的前驱结点
ThreadNode *Pre(ThreadNode *p){
    //左子树中最右下结点
    if(p->ltag == 0)
        return LastNode(p->lchild);
    else
        return p->lchild;
}

既然可以求出每个结点的前驱后继，那么就能写出非递归中序遍历和非递归中序逆向遍历。

//对中序线索二叉树进行中序遍历（顺序）
// （利用线索实现的非递归算法）空间复杂度O(1)
void InOrder(ThreadNode *T){
    for(ThreadNode *p=FirstNode(T); p!=NULL; p=Next(p))
        visit(p);
}

//对中序线索二叉树进行中序遍历（倒叙）
// （利用线索实现的非递归算法）空间复杂度O(1)
void RevInOrder(ThreadNode *T){
    for(ThreadNode *p=LastNode(T); p!=NULL; p=Pre(p))
        visit(p);
}

4.2先序

4.2.1先序后继

img

  1. 如果为叶结点（ltag和rtag是1），则右链域直接指示了结点的后继；
  2. 如果有左孩子，则左孩子根就是其后继；
  3. 如果无左孩子但有右孩子，则右孩子根就是其后继。
4.2.2先序前驱

因为先序遍历的特点是 根-左-右，也就是左右子树都是根的后继，因为二叉链表只有两个孩子结点指针，所以找不到结点的前驱，只能用老办法再遍历一遍。

但是如果是三叉链表，增加了父结点指针：

  1. 如果当前结点p是左孩子，则父结点就是其前驱；

    img

  2. 如果当前结点p是右孩子，并且父结点没有左孩子，则父结点就是其前驱；

    img

  3. 如果当前结点p是右孩子，父结点有左孩子。则左兄弟子树最后一个被先序遍历的结点是其前驱；

    img

  4. 如果当前结点p是根节点，那么前驱为空。

4.3后序

4.3.1先序前驱

  1. 若二叉树指针被线索化（叶子节点，ltag==1），那么前驱就是结点的lchild。

  2. 若ltag==0，

    1. 若结点有右孩子，那么右孩子的根结点就是前驱；

    2. 若结点没有右孩子，有左孩子，那么左孩子的根结点就是前驱。

      img

4.3.2后序后继

和先序前驱同理。因为后序遍历的特点是 左-右-根，也就是左右子树都是根的前驱，因为二叉链表只有两个孩子结点指针，所以找不到结点的后继，只能用老办法再遍历一遍。

但是如果是三叉链表，增加了父结点指针：

  1. 若结点p是其双亲的右孩子，则父结点就是后继；

    img

  2. 若结点p是其双亲的左孩子，且没有右兄弟，则父结点就是后继；

    img

  3. 若结点p是其双亲的左孩子，有右兄弟，则右兄弟子树最后一个被后序遍历的结点是其前驱；

    img

  4. 如果当前结点p是根节点，那么后继为空。

先序、后序线索树

图©中找结点B的后继无法通过链域找到，可见在后序线索二叉树上找后继时需知道结点双亲，即需采用带标志域的三叉链表作为存储结构。

❗线索二叉树代码C

/* 二叉树
	线索二叉树
C 实现（但是没有双指针，需要在c++中运行）

参考：https://blog.csdn.net/BBBling/article/details/117444965
*/

#include<stdio.h>
#include<stdlib.h>


typedef char ElemType;

typedef struct ThreadNode {
	ElemType data;
	struct ThreadNode *lchild, *rchild;//左右孩子指针
	
	//默认0代表左右孩子, 1代表前驱或者后继
	int ltag, rtag;		//左、右线索标志
}ThreadNode, *ThreadTree;



ThreadTree CreatBiTree();  //前序遍历递归法建立二叉树算法
ThreadTree CreatBiTreeByArray(ElemType data[], int &j, int length);  //使用数组直接创建二叉树(前序)

// 中序线索化
void InThread(ThreadNode* p, ThreadNode* &pre);
void CreateInThread(ThreadTree T);
// 前序线索化
void PreThread(ThreadNode* p, ThreadNode* &pre);
void CreatePreThread(ThreadTree T);
// 后序线索化
void PostThread(ThreadNode* p, ThreadNode* &pre);
void CreatePostThread(ThreadTree T);

void DestroyThreadTree(ThreadTree T);	//销毁二叉树

// 中序线索遍历
ThreadNode* FirstNode(ThreadNode* p);
ThreadNode* Next(ThreadNode* p);
void InOrder(ThreadNode *T);    //中序遍历
ThreadNode* LastNode(ThreadNode* p);
ThreadNode* Pre(ThreadNode* p);
void RevInOrder(ThreadNode *T);     //中序倒叙遍历
void PreOrder(ThreadNode *T);   // 前序线索遍历
// 后序线索遍历考试几乎会不考到，故省略。

void visit(ThreadTree T);	//获取元素







/*
//示例二叉树的结构
        A
      /   \
     B     C
      \   / 
       D E

*/
int main()
{
    ThreadTree root;
	// printf("请输入根结点(输入#表示该结点为空)：");
    // root=CreatBiTree();      //创建树

// 数组创建二叉树
	ElemType data[] = "ab#d##ce###";
	int i=0;
    int length = sizeof(data) / sizeof(ElemType);
	root = CreatBiTreeByArray(data, i, length);  //创建树

	

    // 中序线索化
    CreateInThread(root);
	printf("前序遍历二叉树: \n");
	InOrder(root);
	printf("\n");
	printf("后序遍历二叉树: \n");
	RevInOrder(root);

    // // 前序线索化
    // CreatePreThread(root);
	// printf("前序遍历二叉树: \n");
	// PreOrder(root);
	// printf("\n");



	// 销毁二叉树
	printf("\n销毁二叉树\n");
	DestroyThreadTree(root);

    return 0;
}






//-------------------------------------------------------------
// 前序遍历递归法建立二叉树算法
ThreadTree CreatBiTree(){
    ThreadTree T;
    ElemType data;
    fflush(stdin);
    // scanf("%c",&data);
	data = getchar();
 
 	if(data == '#')
		T = NULL;
    else{
        T = (ThreadTree)malloc(sizeof(ThreadNode));
        T->data = data;
        T->ltag = 0;
        T->rtag = 0;
		printf("%c的左子树：",data);
        T->lchild = CreatBiTree();
		printf("%c的右子树：",data);
        T->rchild = CreatBiTree();
    }
    return T;
}


// 使用数组直接创建二叉树(前序)
// j指针指示当前到达的数组位置, 从数组0开始
ThreadTree CreatBiTreeByArray(ElemType data[], int &j, int length){
    ThreadTree T;
	if(j >= length || data[j] == '#'){
		T = NULL;
		j++;
	}
	else{
		T = (ThreadTree)malloc(sizeof(ThreadNode));
		T->data = data[j];
		T->ltag = 0;
		T->rtag = 0;

		j++;
		T->lchild = CreatBiTreeByArray(data, j, length);
		T->rchild = CreatBiTreeByArray(data, j, length);
	}
    return T;
}

// 销毁二叉树
void DestroyThreadTree(ThreadTree T){
    if(T != NULL){
        if(T->ltag == 0)
            DestroyThreadTree(T->lchild);
        if(T->rtag == 0)
            DestroyThreadTree(T->rchild);
        free(T);
    }
}


// 获取元素
void visit(ThreadTree T){
	if(T==NULL){
		printf("# ");;
	}
	printf("%c ",T->data);
}

// --------------------------- Thread 线索化 ----------------------------
/*
设指针pre指向刚刚访问过的结点，指针p指向正在访问的结点，即pre指向p的前驱（p先走，然后再pre）。在中序遍历的过程中，
1. 检查p的左指针`lchild`是否为空，若为空就将它指向pre；
2. 检查pre的右指针`rchild`是否为空，若为空就将它指向p。
*/
// 中序线索化。一边遍历，一边线索化
// 后序线索化的代码和中序完全相同
void InThread(ThreadNode* p, ThreadNode* &pre)
{
	if(p != NULL){
		InThread(p->lchild, pre);	//递归，线索化左子树

        //---
		//左子树为空，建立前驱线索
		if(p->lchild == NULL){
			p->lchild = pre;
			p->ltag = 1;
		}
		//右子树为空，建立前驱结点的后继线索
		if(pre != NULL && pre->rchild == NULL) {
			pre->rchild = p;
			pre->rtag = 1;
		}
		pre = p;	//标记当前结点成为刚刚访问过的结点
        //---

		InThread(p->rchild, pre);	//递归，线索化右子树
	}
}
// 中序线索化
void CreateInThread(ThreadTree T){
	ThreadNode *pre = NULL;	//第一个结点没有前驱，这里的NULL会赋给第一个结点的前驱
	if(T != NULL){
		InThread(T, pre);	//线索化二叉树
		pre->rchild = NULL;	//遍历结束后的最后一个结点没有后继
		pre->rtag = 1;
	}
}

// 前序线索化
// 先序线索化的代码和中序基本相同，但是有一点不同，当一个结点没有左孩子时候，它的左指针lchild会指向前驱，这时候，lchild所指的并不是左子树，而是左线索，所以会出现遍历错误。
void PreThread(ThreadNode* p, ThreadNode* &pre) // 前序线索化二叉树子函数
{
    if(p != NULL){
		//左子树为空，建立前驱线索
        if(p->lchild == NULL){
            p->lchild = pre;
            p->ltag = 1;
        }
		//右子树为空，建立前驱结点的后继线索
        if(pre != NULL && pre->rchild == NULL){ // pre != NULL 排除第一个结点前驱为空的情况
            pre->rchild = p;
            pre->rtag = 1;
        }
        pre = p;

        // 【注意】这里在递归入口处有条件限制，左、右指针不是线索才能继续递归
        if(p->ltag == 0)
            PreThread(p->lchild, pre); // 递归，左子树线索化
        if(p->rtag == 0)
            PreThread(p->rchild, pre); // 递归，右子树线索化
    }
}
// 前序线索化
void CreatePreThread(ThreadTree T){ // 前序线索化二叉树
    ThreadNode *pre = NULL;
    if(T != NULL){
        PreThread(T, pre);
        pre->rchild = NULL; // 非空二叉树，线索化
        pre->rtag = 1; // 后处理中序最后一个结点
    }
}

// 后序线索化
// 后序线索化的代码和中序完全相同，只有顺序不同
void PostThread(ThreadNode* p, ThreadNode* &pre){ // 后序线索化二叉树子函数
    if(p != NULL){
        PostThread(p->lchild, pre); // 递归，左子树线索化
        PostThread(p->rchild, pre); // 递归，右子树线索化

        if(p->lchild == NULL){
            // 建立当前节点的前驱线索
            p->lchild = pre;
            p->ltag = 1;
        }
        if(pre != NULL && pre->rchild == NULL){ // pre != NULL 排除第一个结点前驱为空的情况
            // 建立当前节点的后继线索
            pre->rchild = p;
            pre->rtag = 1;
        }
        pre = p;
    }
}
// 后序线索化
void CreatePostThread(ThreadTree T){ // 前序线索化二叉树
    ThreadNode *pre = NULL;
    if(T != NULL){
        PostThread(T, pre);
        pre->rchild = NULL; // 非空二叉树，线索化
        pre->rtag = 1; // 后处理中序最后一个结点
    }
}




// ----------------------- Traverse 遍历方法 ----------------------------
// 中序顺序遍历
//找到以P为根的子树中，第一个被中序遍历的结点
ThreadNode* FirstNode(ThreadNode* p){
	//循环找到右子树最左下结点(不一定是叶结点)
    while(p->ltag == 0)
        p=p->lchild;
    return p;
}
//在中序线索二叉树中找到结点p的后继结点
ThreadNode* Next(ThreadNode* p){
	//右子树中最左下结点
    if(p->rtag == 0)
        return FirstNode(p->rchild);
    else
        return p->rchild;	//rtag==1直接返回后继线索
}
//对中序线索二叉树进行中序遍历（顺序）
// （利用线索实现的非递归算法）空间复杂度O(1)
void InOrder(ThreadNode *T){
    for(ThreadNode *p=FirstNode(T); p!=NULL; p=Next(p))
        visit(p);
}


// 中序倒叙遍历
//找到以P为根的子树中，最后一个被中序遍历的结点
ThreadNode* LastNode(ThreadNode* p){
    //循环找到最右下结点（不一定是叶子结点）
    while(p->rtag == 0)
        p = p->rchild;
    return p;
}
//在中序线索二叉树中找到结点p的前驱结点
ThreadNode* Pre(ThreadNode* p){
    //左子树中最右下结点
    if(p->ltag == 0)
        return LastNode(p->lchild);
    else
        return p->lchild;
}
//对中序线索二叉树进行中序遍历（倒叙）
// （利用线索实现的非递归算法）空间复杂度O(1)
void RevInOrder(ThreadNode *T){
    for(ThreadNode *p=LastNode(T); p!=NULL; p=Pre(p))
        visit(p);
}

// 前序遍历
// 因为二叉链表只能找前序后继，所以是顺序遍历（三叉链表才能找前驱）
void PreOrder(ThreadNode *T){
    if(T != NULL){
        ThreadNode *p = T;
        while (p != NULL){
            while (p->ltag == 0){ // 左指针不是线索，则边访问边左移
                visit(p); // 访问结点
                p = p->lchild; // 左移，访问左子树
            }
            visit(p); // 此时p左必为线索，但还没有被访问，则访问
            p = p->rchild; // 此时p左孩子不存在，则右指针若非空，则不论是否为线索都指向其后继
        }
    }
}
Suhan42
关注
  • 14
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】线索化二叉树
lz201788的博客
03-05 289
二叉树虽然是非线性结构，但二叉树的遍历却为二叉树的结点集导出了一个线性序列。对于前、中、后序遍历，出了相应序列的第一个节点和最后一个节点，二叉树的遍历序列中每个结点都有一个前驱和后继结点，但在二叉树中，无法很快的找出按照某种遍历序列该结点的前驱和后继。 普通的二叉树可能存在以下问题： 递归遍历有可能导致栈溢出 非递归版本有可能降低程序效率 想要找到在某种遍历形势下某个结点的前驱或后继比较...
【数据结构】 线索化二叉树
愿万事胜意
08-28 407
引入 将序列{1,3,6,8,10,14}构建成一个二叉树： 如果按照链表进行存放该二叉树，我们可以看一下其空间存储： 我们现在体长节约型社会，对待程序也不例外，能不浪费的时间或者空间，都应该考虑节省。我们从上图可以看出，有许多的空指针域没有使用，造成了资源的浪费，应该要想办法利用起来。 那么看看这样的空指针域有多少个呢，对于一个有n个结点的二叉链表，每个结点有左孩子和右孩子两...
【数据结构】：二叉树，线索二叉树，排序二叉树，AVL树
呋喃吖的博客
06-15 1223
文章目录前言一 二叉树0）二叉树较为重要的种类1. 满二叉树2.完全二叉树1） 二叉树的存储结构2） 初始化二叉树3）创建二叉树1.创建二叉树的方式 12.创建二叉树 23.创建二叉树 34）遍历二叉树1.前序递归遍历2.中序递归遍历3.后序递归遍历4.层次遍历5）前序非递归遍历 前言 二叉树分好多种: 我在这里分享四种二叉树的基本操作集合。 普通的二叉树(二叉树) 线索二叉树 搜索二叉树 平衡（AVL）二叉树 一 二叉树 0）二叉树较为重要的种类 满二叉树和完全二叉树。 1. 满二叉树 一棵二叉树，除
【数据结构-树】2.二叉树遍历与线索二叉树（图解+代码）
为了远大的理想，冲锋！
01-22 1160
一、二叉树的定义及其主要特征 1.1 二叉树的概念 二叉树是另一种树形结构，其特点是每个结点最多含两棵子树（也就是说，二叉树的度≤2）。 二叉树是一种有序树，若将其左、右子树颠倒，则成为另一颗不同的二叉树。 二叉树可以为空 1.2 二叉树和度为2的有序树 在这里要区分一个概念，也就是二叉树和度为2的有序树之间的区别。 度为2的树至少有3个结点，而二叉树则可以是一颗空树 度为2的有序树的孩子结点，左右次序是相对于另一孩子结点而言的，若某个结点只有一个孩子结点，则这个结点就无须区分其左右次序。但，二叉树无论
C语言数据结构之线索二叉树及其遍历
08-29
接着，`InitThreadBinaryTree`函数用于初始化线索二叉树，将其设置为空树。`ThreadBinaryTree_PreOrderInput`函数则是利用先序遍历的方式创建一个线索二叉树，从输入中读取字符构建树结构。 中序遍历通常用于构造...
数据结构教学课件：第11-2讲 线索二叉树.pdf
06-01
【线索二叉树】是数据结构中的一个重要概念，它是一种特殊的二叉树，主要用于高效地查找树中的前驱和后继节点。在二叉树的先序、中序或后序遍历序列中，相邻的节点互称为前驱与后继。线索二叉树通过在每个节点中增加...
数据结构课件：第6章 树和二叉树2遍历二叉树和线索二叉树.pptx
05-31
本节内容主要介绍了数据结构中的树和二叉树，特别是关于遍历二叉树和线索二叉树的概念及算法。首先，树是一种非线性的数据结构，由根节点、左子树和右子树组成。二叉树是特殊的树，每个节点最多有两个子节点，分为左...
数据结构之线索二叉树-C语言实现.pdf
01-15
总的来说，线索二叉树是一种优化二叉树遍历的数据结构，通过在二叉链表中添加线索，可以避免在遍历时反复查找前驱和后继结点，提高了遍历效率。在C语言中实现线索二叉树需要理解二叉树的结构，并正确处理各种插入和...
线索二叉树的实现.doc
04-29
### 知识点生成 #### 1. 课题描述 本课题主要研究线索二叉树的概念及其实现方法。...通过以上步骤的设计与实现，可以有效地完成线索二叉树的构建和遍历，从而更好地理解和应用二叉树这一重要的数据结构。
单链表-数据结构
qq_31804097的博客
08-07 212
【代码】单链表、双向带头循环链表-数据结构。
24.8.9.11数据结构|链栈和队列
最新发布
weixin_47011416的博客
08-09 455
节点含有数据域和指针域。
常见8种数据结构
qq_43575301的博客
08-08 2017
应用于需要后进先出访问元素的场景，如函数调用栈、表达式求值等。应用于需要先进先出访问元素的场景，如任务调度、消息队列等。适用于优先队列，堆排序和实现高效的合并K个有序链表问题。应用于需要表示层次结构的场景，比如文件系统、组织结构等。应用于需要表示网络结构的场景，如社交网络、交通网络等。应用于需要快速查找和插入操作的场景，如字典、缓存等。一般应用于需要快速随机访问元素的场景。适用于需要频繁插入和删除元素的场景。
【数据结构-前缀哈希】力扣525. 连续数组
sjsjs11的博客
08-07 258
将nums中的0全部替换成-1，然后定义一个哈希表group，键用来储存sum，值用来储存对应的前缀和的下标。当前计算前缀和sum的时候，如果前面有相同的前缀和，说明中间这个子段和为0，也就说明0和1的数量相等，所以这个时候。给定一个二进制数组 nums , 找到含有相同数量的 0 和 1 的最长连续子数组，并返回该子数组的长度。说明: [0, 1] (或 [1, 0]) 是具有相同数量0和1的最长连续子数组。说明: [0, 1] 是具有相同数量 0 和 1 的最长连续子数组。来求这个子段的长度。
【数据结构】五、树：5.二叉排序树BST
来csdn只办三件事：开源！开源！还是***开源！
08-07 639
1.二叉排序树BST 1.1定义 1.2存储结构 1.3查找 1.3.1查找最大和最小元素 1.4插入 1.4.1插入构造二叉排序树 1.5删除 1.6性能分析
数据结构（学习）2024.8.9（双向链表）
何物爱惜雨的博客
08-09 563
双向链表的创建，插入，遍历，删除
数据结构--第六天
xujiashuo1的博客
08-08 1310
树是由。
数据结构 - 相邻节点迭代器
菜鸟小码的博客
08-07 655
在图论中，迭代器是一种常用的工具，用于遍历图中的节点或边。特别是当需要访问一个节点的所有相邻节点时，相邻节点迭代器提供了一种方便且灵活的方式。本文将深入探讨相邻节点迭代器的基本原理，并通过具体的Java代码详细说明如何实现高效的相邻节点迭代器。
【算法模板】数据结构：三分查找
2303_80346267的博客
08-07 686
算法竞赛中的三分（ternary search）是一种用于在单峰函数（unimodal function）上找到最大值或最小值的搜索算法。与二分搜索（binary search）类似，三分搜索在每次迭代中将搜索空间分成三个部分，但三分搜索用于连续区间而不是离散区间。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值