线索二叉树

最新推荐文章于 2024-09-19 11:27:12 发布
最新推荐文章于 2024-09-19 11:27:12 发布
阅读量494 收藏
点赞数 2
分类专栏： 数据结构——二叉树 文章标签： 数据结构 二叉树 线索二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35008554/article/details/53312767
版权

一.线索二叉树

  我们在遍历二叉树时会得到一个线性序列，而在一些应用中我们需要频繁的得到某个元素的前驱或后继，而每次均遍历一遍时间消耗过大，因此提出了线索二叉树的概念，用于在树中储存一条链用以记录这条线性序列，使得我们可以高效的调用某些元素的前驱或后继。

二.实现方法

线索二叉树建立：

  一般想法是在二叉树结构中加入两个指针域分别指向前驱后继，但是这样会使结构体的存储密度大大降低，因此在二叉链表的结点中增加两个标志域Ltag, Rtag进而把空指针变成线索：

              0 表示 lchild(p) 为指向左孩子的指针
ltag(p)=
              1 表示 lchild(p) 为指向直接前驱的线索

              0 表示 rchild(p) 为指向右孩子的指针
rtag(p)=
              1 表示 rchild(p) 为指向直接后继的线索

  同时再设立一个pre指针指向当前结点的前驱，辅助操作使得当前节点的前驱线索指向前驱，前驱的后继线索指向当前结点，由此只需完成一遍遍历就可以建立一个XX线索。当然我们看到建立的过程就是一遍遍历因此不要对仅需一遍遍历的题目建立线索，因为没有必要。

线索二叉树的输出：

  为方便起见，一般会在线索二叉树前设立一个头节点，并令其lc指向二叉树根节点，其rc指向最后一次访问的节点，这样建立成的线索二叉树就像一个双向链表，既可以根据后继由前向后遍历，也可以根据前驱有后向前遍历。

三.三种线索二叉树

  给出代码之前先说以下建立函数吧，其实三种建立函数都和相应的遍历函数差不太多，就是把遍历操作函数中的输出操作改为判断空指针、空指针设立线索、判断pre（前驱）位置三种操作。下面是具体代码，代码中对三种遍历建立函数部分写明了注释。

1.中序二叉树

/*
中序线索二叉树 
*/
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
using namespace std;

const int link = 0;//指针 
const int thread  = 1;//线索 

typedef struct Bintree 
{
	char data;
	struct Bintree *lc, *rc;
	int LTag, RTag; 
}BinNode, *Bin;

void CreateTree(Bin &T)
{
	char ch;
	scanf("%c", &ch);
	if(ch=='#')
	T = NULL;
	else
	{
		T = (Bin)malloc(sizeof(BinNode));
		T->data = ch;
		T->LTag = T->RTag = link;
		CreateTree(T->lc);
		CreateTree(T->rc);
	}
}

void InThreading(Bin p, Bin &pre)//中序建线索 
{
	if(p)
	{
		InThreading(p->lc, pre);
		if(!p->lc)//左为空证明无左子连，左为前驱线索 
		{
			p->LTag = thread;
			p->lc = pre; //左线索指向前驱pre 
		}
		if(!pre->rc)
		{
			pre->RTag = thread;
			pre->rc = p;//前驱的后继为当前结点 
		} 
		pre = p;//保持pre指向p前驱，判断前驱位置 
		InThreading(p->rc, pre);
	}
}

void InorderThreading(Bin &Thrt, Bin T)
{
	if(!(Thrt = (Bin)malloc(sizeof(BinNode))))
	exit(0);
	Thrt->LTag = link;//初始化建立根 
	Thrt->RTag = thread;
  	if(!T)//空的话 
	Thrt->lc = Thrt; 
	else
	{
		Thrt->lc = T;
		Bin pre = Thrt;
		InThreading(T, pre);
		pre->rc = Thrt;
		pre->RTag = thread;
		Thrt->rc = pre;
	} 
}

void Inthread_out(Bin Thrt)
{
	Bin p = Thrt->lc;
	while(p != Thrt)//没绕回来 
	{
		while(p->LTag == link)
		{
			p = p->lc;
		}
		printf("%c", p->data);
		while(p->RTag == thread&&p->rc!=Thrt)
		{
			p = p->rc;
			printf("%c", p->data);
		}
		p = p->rc;
	}
}

void In_out(Bin T)
{
	if(T)
	{
		In_out(T->lc);
		printf("%c", T->data);
		In_out(T->rc);
	}
}

void Destory(Bin &T)
{
	T->lc = NULL;
	T->rc = NULL;
	free(T);
}

int main()
{
	Bin T;
	Bin Thrt;
	CreateTree(T); 
	In_out(T);
	printf("\n");
	InorderThreading(Thrt, T);
	Inthread_out(Thrt);
	Destory(T);
	Destory(Thrt);
} 
/*
-+a##*b##-c##d##/e##f##
*/
2.先序线索二叉树 

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
using namespace std;

const int link = 0;//链 
const int thread = 1;//线索 

typedef struct Bintree
{
    char data;
    struct Bintree *lc, *rc;
    int LTag, RTag;
}BinNode, *Bin;

void CreateTree(Bin &T)
{
    char ch;
    scanf("%c", &ch);
    if(ch == '#')
    T = NULL;
    else
    {
        T = (Bin)malloc(sizeof(BinNode));
        T->data = ch;
        T->LTag = T->RTag = 0;
        CreateTree(T->lc);
        CreateTree(T->rc);
    }
}

void Pre_out(Bin T)
{
    if(T)
    {
        printf("%c", T->data);
        Pre_out(T->lc);
        Pre_out(T->rc);
    }
} 

void PreThreading(Bin T, Bin &pre)//先序建立 
{
    if(T)
    {
        int flag = 0;
        if(!T->lc)
        {
            flag = 1;
            T->lc = pre;
            T->LTag = thread;
        }
        if(!pre->rc)
        {
            pre->RTag = thread;
            pre->rc = T;
        }
        pre = T;
        if(!flag)//如果对左子进行了操作，证明左子原来为空指针，则不需要再操作 
        PreThreading(T->lc, pre);
        PreThreading(T->rc, pre);
    }
}

void PreorderThreading(Bin &Thrt, Bin T)
{
    if(!(Thrt = (Bin)malloc(sizeof(BinNode))))
    exit(0);
    Thrt->LTag = link;
    Thrt->RTag =  thread;
    if(!T)
    Thrt->lc = Thrt;
    else
    {
        Thrt->lc = T;
        Bin pre = Thrt;
        PreThreading(T, pre);
        pre->RTag = thread;
        pre->rc = Thrt;
        Thrt->rc = pre;
    }
}

void Prethread_out(Bin Thrt)
{
    Bin p = Thrt->lc;
    while(p!=Thrt)
    {
        while(p->LTag == link)
        {
            printf("%c", p->data);
            p = p->lc;
        }
        printf("%c", p->data);
        while(p->RTag == thread&&p->rc!=Thrt)
        {
            p = p->rc;
            printf("%c", p->data);
        }
        if(p->rc!=Thrt)
        p = p->lc;
        else
        p = p->rc;
    }
}

void Destory(Bin &T)
{
    T->lc = NULL;
    T->rc = NULL;
    free(T);
}

int main()
{
    Bin T;
    Bin Thrt;
    CreateTree(T);
    Pre_out(T);
    printf("\n");
    PreorderThreading(Thrt, T);
    Prethread_out(Thrt);
    Destory(T);
    Destory(Thrt); 
}

3.后序线索二叉树 

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
using namespace std;

const int link = 0;
const int thread = 1;

typedef struct BinTree
{
	char data;
	struct BinTree *lc, *rc;
	int LTag, RTag;
}BinNode, *Bin;

void CreateTree(Bin &T)
{
	char ch;
	scanf("%c", &ch);
	if(ch == '#')
	T = NULL;
	else
	{
		T = (Bin)malloc(sizeof(BinNode));
		T->data = ch;
		T->LTag = T->RTag = link;
		CreateTree(T->lc);
		CreateTree(T->rc);
	}
}

void Post_out(Bin T)
{
	if(T)
	{
		Post_out(T->lc);
		Post_out(T->rc);
		printf("%c", T->data);
	}
}

void Postthreading(Bin T, Bin &pre)//T回溯之后pre是更改以后的值 
{//后序建立 
	if(T)
	{
		Postthreading(T->lc, pre);
		Postthreading(T->rc, pre);
		if(!T->lc)
		{
			T->LTag = thread;
			T->lc = pre;
		}
		if(!pre->rc||pre->RTag == link)//涉及后继为父节点的情况 
		{//父节点左右指针并不为空，需要另行操作，将原来指针变为线索 
			pre->RTag = thread;
			pre->rc = T;
		}
		pre = T;
	}
}

void Postorderthreading(Bin &Thrt, Bin T)
{
	if(!(Thrt = (Bin)malloc(sizeof(BinNode))))
	exit(0);
	Thrt->LTag = link;
	Thrt->RTag = thread;
	if(!T)
	Thrt->lc = Thrt;
	else
	{
		Thrt->lc = T;
		Bin pre = Thrt;
		Postthreading(T, pre);
		pre->rc = Thrt;
		pre->RTag = thread;
		Thrt->rc = pre;  
	} 
}

void Postthread_out(Bin Thrt)
{
	Bin p = Thrt->lc;
	while(p->lc&&p->LTag == link)
	{
		p = p->lc;
	}
	printf("%c", p->data);
	while(p!=Thrt->lc)
	{
		while(p->RTag == thread&&p!=Thrt->lc)
		{
			p = p->rc; 
			printf("%c", p->data);
		}
	}
}

void Destory(Bin &T)
{
	T->lc = NULL;
	T->rc = NULL;
	free(T);
}

int main()
{
	Bin T;
	Bin Thrt;
	CreateTree(T);
	Post_out(T);
	printf("\n");
	Postorderthreading(Thrt, T);
	Postthread_out(Thrt);
	Destory(T);
	Destory(Thrt);
 }


蜗牛or
关注
专栏目录
PHP实现的线索二叉树及二叉树遍历方法详解
10-22
线索二叉树是一种通过增加标志位来解决二叉树遍历时进行空指针判断的复杂度问题的数据结构。在传统二叉树的节点中，每个节点的左指针和右指针只能指向左孩子或右孩子，或者是NULL（表示没有孩子）。而在线索二叉树中...
详解线索二叉树
kusunoki的博客
07-29 1176
对线索二叉树的概念进行说明，并分别介绍了中序线索二叉树、先序线索二叉树和后序线索二叉树找其前驱和后继的方法。
线索二叉树（详解）
热门推荐
~
01-09 6万+
线索二叉树原理 遍历二叉树的其实就是以一定规则将二叉树中的结点排列成一个线性序列，得到二叉树中结点的先序序列、中序序列或后序序列。这些线性序列中的每一个元素都有且仅有一个前驱结点和后继结点。 但是当我们希望得到二叉树中某一个结点的前驱或者后继结点时，普通的二叉树是无法直接得到的，只能通过遍历一次二叉树得到。每当涉及到求解前驱或者后继就需要将二叉树遍历一次，非常不方便。 于是是否能够改变原有的...
线索二叉树简述
刘伟佳的博客
03-12 2764
线索二叉树 首先我们回忆一下二叉树的前中后序遍历方式： 先序遍历序列：1 2 4 5 3 6 中序遍历序列：4 2 5 1 6 3 后序遍历序列：4 5 2 6 3 1 我们通过这样的遍历，由一个树形结构得到了一个线性的结构（遍历序列）。在这个线性序列中，除了第一个结点和最后一个结点，每个结点都拥有一个前驱和后继。 那么在二叉树中，我们能不能不只体现结点的父子关系，也引入结点的前驱后继关系呢？ 由此，我们引入了线索二叉树。 我们之前说过二叉链表，我们知道在一个二叉链表中，n个结点会有n+1个空指针。 接
图解线索二叉树
weixin_44067399的博客
07-07 2万+
今天我们来聊聊线索二叉树 线索二叉树的诞生背景 对于n个结点的二叉树，则在二叉链存储结构中就会有n+1个空链域 当我在查找某个结点的时候，想要知道这个节点的前驱结点或者后继结点，我该怎么做？ 1.我是不是可以先序遍历或者后序遍历得到他们的前驱或者后继 2.我是不是可以开辟内存空间，对于每个结点增加一个指向它的前驱，增加一个指向它的后继 利用这些空链域存放在某种遍历次序下该结点的前驱结点和后继结点的指针，这些指针称为线索，加上线索的二叉树称为线索二叉树。 关于线索二叉树你所需要知道的 重要 如果一个结点的
线索二叉树实验报告.docx
12-11
线索二叉树是一种特殊形式的二叉树，它在二叉树的基础上增加了线索，以便于在不使用递归的情况下进行二叉树的遍历。在本实验中，我们使用C语言实现了线索二叉树，主要涉及到以下几个核心知识点： 1. **线索二叉树的...
C语言实现线索二叉树的定义与遍历示例
08-30
"C语言实现线索二叉树的定义与遍历示例" 本文主要介绍了C语言实现线索二叉树的定义与遍历，结合具体实例形式分析了基于C语言的线索二叉树定义及遍历操作相关实现技巧与注意事项。 一、线索二叉树的定义 线索...
数据结构之存储位置
qq_53841892的博客
09-18 368
内存泄漏：如果没有适时释放被动态分配的内存，会导致内存泄露问题。未释放的内存一直占用系统资源，使得系统变慢并最终导致崩溃。内存释放，合理设计算法，避免算法问题导致的内存无线增长，合理设置作用域。这个数组在函数返回后会失效，因此返回的指针指向的是一个未定义的值。//static变量。频繁的使用堆会产生大量的碎片，而栈则不会。int a = 0;Test 函数会有什么样的结果？函数会有什么样的结果？函数会有什么样的结果？函数会有什么样的结果？
【数据结构】排序算法---计数排序
2301_80191662的博客
09-19 1007
计数排序算法详细讲解，还含有动图演示
Python中的数据结构
MagicFromMe的博客
09-18 299
可以将列表理解为一个购物清单，这个清单里面的的每个元素可以是，并且（这里区别了列表与数组）。列表用“[]”表示。
数据结构——二叉树堆的专题
最新发布
imaima666的博客
09-19 766
如果有一个关键码的集合K = {K0 ，K1 ，K2 ，K3…) i = 0，1， 2…，则称为(或将。
数据结构-栈
m0_69032433的博客
09-15 1707
/指针实现 : data = (ElemType *)malloc( sizeof(ElemType) * MAX_LEN );//数组实现 : ElemType data[MAX_LEN];//data指向一块地址连续的空间,来存储栈的每一个元素。//指针域 --> 保存逻辑上的下一个。//top == -1 表示栈中没有元素, 空栈。就是我们平时所用的标准四则运算表达式, 比如 9+3-2*(1+4)-4/2。#define MAX_LEN 20 //栈的最大的容量。
MATLAB系列03：分支语句和编程设计
lbm666666的博客
09-16 924
所谓的自顶向下的编程方法，本质上就是编写程序的视角从整体的宏观性逐层进入具体的微观性的一种编程思想。我们编写程序时一开始不用思考得事无巨细，把所有细节都想清楚；也不要面条式的想到哪里写到哪里。而应该是自顶向下的，从一个大的粗的核心的任务开始，逐级细分，最后再完成最底层的具体实现。清晰地陈述出你要解决的问题。确定程序所需地输入量和程序所产生的输出量。为你的程序设计算法将算法转化为 MATLAB 语句调试MATLAB语句。
数据结构字节对齐
m0_71556251的博客
09-16 735
则sizeof(cs)的值是( ) (苏州特点电子科技)③计算学生的成绩总分、平均分。④按照学生的分数进行排序。
数据结构 | 栈和队列
TTKunn的博客
09-15 1580
本文详细介绍了栈和队列的数据结构及其实现
数据结构-3.链表
2302_81886858的博客
09-18 1334
由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。说明:1. LinkedList实现了List接口2. LinkedList的底层使用了双向链表3. LinkedList没有实现RandomAccess接口, 因此LinkedList不支持随机访问4. LinkedList的任意位置插入和删除元素时的效率比较高,时间复杂度为O(1)5. LinkedList比较适合任意位置插入的场景。
线索二叉树概念与C++实现解析
"这篇文档是关于数据结构课程中线索二叉树的概念及其C++实现的上课笔记，包含2020年5月12日的课程内容。文档提供了三种二叉树序列化的问题示例，并详细解释了线索二叉树的动机、存储结构以及C++实现线索二叉树的基本...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值