数据结构-线索二叉树

数据结构笔记——线索二叉树找前驱/后继 目录 一、中序线索二叉树找中序后继 二、中序线索二叉树中找中序前驱 三、先序线索二叉树找先序后继 四、先序线索二叉树找先序前驱 五、后序线索二叉树找后序前驱 六、后序线索二叉树找后序后继 七、总结 一、中序线索二叉树找中序后继 在中序线索二叉树中找到指定结点*p的中序后继next ①若p->rtag == 1,则next = p->rchild ②若p->rtag == 0 //找到以P为跟的子树中,第一个被中序遍历的结点 ThreadNode *Fi 阅读详情

线索二叉树是利用空出来的指针域来存储 某个遍历序列 下的前驱和后继,左边的空节点指针指向前驱节点,右边的空节点指针指向后继节点。

由于线索二叉树是基于某种遍历序列的,所以就需要在对二分搜索树进行某种遍历的时候,构造线索,主要分为:

  • 前序序列线索树
  • 中序序列线索树
  • 后续序列线索树

用土办法找树中某节点的中序遍历前驱节点

//前向指针
Node<E> pre = null;
boolean findFlag = false;
Node<E> target = null;

private Node<E> findNode(E e) {
    return findNode(e, root);
}

private Node<E> findNode(E e, Node<E> node) {
    if (node == null) {
        return null;
    }
    if (e.compareTo(node.data) < 0) {
        return findNode(e, node.left);
    } else if (e.compareTo(node.data) > 0) {
        return findNode(e, node.right);
    }
    return node;
}

//中序遍历
public E findInOrderPre(E e) { 
    //找到目标节点
    target = findNode(e);
    
    return pre.data;
}

//按照前序的顺序遍历整棵树
private void inOrderForFindPre(Node<E> node) {
    if (node == null) {
        return;
    }
    inOrderForFindPre(node.left);
    //在这里调整pre指针
    visit(node);
    inOrderForFindPre(node.right);
}

private void visit(Node<E> node) {
    //如果还没有找到
    if (!findFlag) {
        //如果当前节点就是目标节点
        if (node.data.compareTo(q.data) == 0) {
            findFlag = true;
            //输出pre,即前序遍历中 目标节点的前驱节点
            System.out.println("目标节点的前驱节点为:" + pre);
        } else {
            //否则,将pre指向当前节点,继续向后遍历
            pre = node;
        }
    }
}

节点结构

private static class Node<E extends Comparable<E>> {
    E data;
    Node<E> left;
    Node<E> right;
    
    //用来记录当前节点的左右子节点指针是指向真实的子节点还是作为线索指针
    //0-指向真实的子节点 1-线索指针
    int ltag;
    int rtag; 
}

构造前序线索树

private Node<E> preOrderThreadPrev;
public void preThreadTree() {
    preThreadTree(root);
    if (preOrderThreadPrev != null) {
        preOrderThreadPrev.rtag = 1;
    }
}
private void preThreadTree(Node<E> node) {
    if (node == null) {
        return;
    }
    preThreadTreeVisit(node);
    if (node.ltag == 0) {
        preThreadTree(node.left);
    }
    if (node.rtag == 0) {
        preThreadTree(node.right);
    }
}

private void preThreadTreeVisit(Node<E> node) {
    if (node.left == null) {
        node.left = preOrderThreadPrev;
        node.ltag = 1;
    }

    //如果前驱的right是空,就让他指向node节点
    if (preOrderThreadPrev != null &&
            preOrderThreadPrev.right == null) {
        preOrderThreadPrev.right = node;
        preOrderThreadPrev.rtag = 1;
    }
    preOrderThreadPrev = node;
}

遍历前序线索树

/**
 * ③由于先序遍历线索树中的节点无法找到它的前驱节点(因为前驱是向前指,而节点的当前两个子节点都是向后只的)
 *   所以只能从前往后遍历
 * */
private Node<E> preOrderSequenceFirstNode(Node<E> node) {
    //以node为根节点的子树的先序遍历的第一个节点就是当前节点
    return node;
}
private Node<E> preOrderSequenceNextNode(Node<E> node) {
    //如果right被线索化了,就直接返回right
    if (node.rtag == 1) {
        return node.right;
    }
    //如果没有,先序遍历的后继节点 只可能是它的左 / 右子节点
    if (node.left != null) {
        return node.left;
    } else if (node.right != null) {
        return node.right;
    }
    return null;
}
public void preSequenceOrder() {
    for (Node<E> cur = preOrderSequenceFirstNode(root); cur != null; cur = preOrderSequenceNextNode(cur)) {
        System.out.print(cur.data + " ");
    }
    System.out.println();
}

构造中序线索树

private Node<E> inOrderThreadPrev;
//②中序序列线索化
public void inThreadTree() {
    inThreadTree(root);
    if (inOrderThreadPrev != null) {
        inOrderThreadPrev.rtag = 1;
    }
}
private void inThreadTree(Node<E> node) {
    if (node == null) {
        return;
    }
    inThreadTree(node.left);
    inThreadTreeVisit(node);
    if (node.rtag == 0) {
        inThreadTree(node.right);
    }
}

private void inThreadTreeVisit(Node<E> node) {
    if (node.left == null) {
        node.left = inOrderThreadPrev;
        node.ltag = 1;
    }

    if (inOrderThreadPrev != null &&
            inOrderThreadPrev.right == null) {
        inOrderThreadPrev.right = node;
        inOrderThreadPrev.rtag = 1;
    }
    inOrderThreadPrev = node;
}

遍历中序线索树

private Node<E> inOrderSequenceFirstNode(Node<E> node) {
    Node<E> cur = node;
    while (cur.ltag == 0) {
        cur = cur.left;
    }
    return cur;
}
//中序遍历序列中的下一个节点
private Node<E> inOrderSequenceNextNode(Node<E> node) {
    if (node.rtag == 1) {
        return node.right;
    }

    return inOrderSequenceFirstNode(node.right);
}

public void inSequenceOrder() {
    for (Node<E> cur = inOrderSequenceFirstNode(root); cur != null; cur = inOrderSequenceNextNode(cur)) {
        System.out.print(cur.data + " ");
    }
    System.out.println();
}


/**
 * 中序遍历序列的逆序遍历
 * */
private Node<E> inOrderSequenceLastNode(Node<E> node) {
    Node<E> cur = node;
    while (cur.rtag == 0) {
        cur = cur.right;
    }
    return cur;
}
private Node<E> inOrderSequencePrevNode(Node<E> node) {
    if (node.ltag == 1) {
        return node.left;
    }
    return inOrderSequenceLastNode(node.left);
}
public void inSequenceOrderReverse(){
    for (Node<E> cur = inOrderSequenceLastNode(root); cur != null; cur = inOrderSequencePrevNode(cur)) {
        System.out.print(cur.data + " ");
    }
    System.out.println();
}

构造后续线索树

private Node<E> postOrderThreadPrev;
public void postThreadTree() {
    postThreadTree(root);

    //注意,由于后续遍历的最后一个节点不是叶子节点,所以不能同先序遍历和
    //中序遍历那样,存在下面的逻辑
    /*if (postOrderThreadPrev != null) {
        postOrderThreadPrev.rtag = 1;
    }*/
}
private void postThreadTree(Node<E> node) {
    if (node == null) {
        return;
    }
    //if (node.ltag == 0) {
        postThreadTree(node.left);
    //}
    //if (node.rtag == 0) {
        postThreadTree(node.right);
    //}
    postThreadTreeVisit(node);

}
private void postThreadTreeVisit(Node<E> node) {
    if (node.left == null) {
        node.left = postOrderThreadPrev;
        node.ltag = 1;
    }

    if (postOrderThreadPrev != null
            && postOrderThreadPrev.right == null) {
        postOrderThreadPrev.right = node;
        postOrderThreadPrev.rtag = 1;
    }
    postOrderThreadPrev = node;
}

遍历后续线索树

/**
 * ③遍历
 * 由于后序线索二叉树找不到后继节点,所以只能从后往前遍历
 * */
private Node<E> postOrderSequenceLastNode(Node<E> node) {
    return node;
}

private Node<E> postOrderSequencePreNode(Node<E> node) {
    if (node.ltag == 1) {
        return node.left;
    }

    if (node.right != null && node.rtag != 1) {
        return node.right;
    }
    return node.left;
}

public void postSequenceOrderReverse() {
    for (Node<E> cur = postOrderSequenceLastNode(root); cur != null; cur = postOrderSequencePreNode(cur)) {
        System.out.print(cur.data + " ");
    }
    System.out.println();
}

《数据结构》—— 遍历线索二叉树 中、先、后序线索二叉树的遍历查找,代码实现遍历中序线索二叉树 阅读详情

相关推荐

数据结构——线索二叉树

线索二叉树  线索二叉树的概念        一棵二叉树,最下面一层全是叶子节点,这些叶子节点的左右孩子指针全为NULL,其实是浪费了这些内存。详细计算一下,节点二数为n的二叉树有n+1个空指针。这是怎么算来的呢?其实有个非常简单的算法:有n个节点的二叉树很明显有2n个指针,而这n个节点除了主根节点,其他节点都有一条连线指向这个节点的父节点,反过来来看,这个连线就是父节点指向这个节点的指针,因

Benson的博客 828

数据结构-第五章-树与二叉树

数据结构,408考研,树与二叉树与森林,先序、中序、后序、层序遍历,红黑树,二叉平衡树,完全二叉树,满二叉树,哈夫曼树,树的存储,

qq_38738735的博客 2184

PyTorch复现EEG-TCNet踩坑记:从BCI IV2a数据到TCN块缺失的完整解决方案

本文详细解析了使用PyTorch复现EEG-TCNet模型的全过程,重点解决了BCI IV2a数据集预处理和TCN模块缺失的技术难题。通过标准化数据流程、跨受试者验证策略以及三种因果卷积实现方案,为运动想象分类任务提供完整解决方案,帮助研究者高效实现模型复现与优化。

weixin_30699955的博客 319

线索二叉树根据任意结点P找前驱和后继

二叉树结构 typedef struct threadNode { /* data */ ElemType data; threadNode *lchild, *rchild; /* tag = 0 指针指向孩子 tag = 1 线索指针 */ int ltag, rtag; } threadNode, *threadTree; 一,先序线索二叉树 1.前驱 先序遍历是 (根左右), 我们是通过子节点的线索来找根

qq_44744457的博客 3630

Windows 11 IoT企业版LTSC 24H2/25H2中文版安装指南(含OEM激活教程)

本文详细介绍了Windows 11 IoT企业版LTSC 24H2/25H2中文版的安装与OEM激活全流程。从系统镜像准备、硬件兼容性检查到自动化安装配置,再到OEM激活方案(包括SLIC注入和数字许可证激活),为工业自动化、数字标牌等物联网设备提供稳定可靠的系统部署指南。

weixin_29198045的博客 8929

Dify DSL文件分享 Dify讨论群 大模型token资源等(持续收集更新)

基于LLMOps平台-Dify的一站式学习平台。包含不限于:Dify案例、DSL文件分享、模型接入、Dify交流讨论等各类资源分享。

同名公众号:dify实验室 3718

【数据结构·考研】先序线索二叉树

先序线索二叉树c++实现

Jiawen9的博客 1884

农业AI避坑指南:用YOLO11做叶片病害检测时遇到的5个典型问题

本文分享了使用YOLO11模型进行农业叶片病害检测时常见的五个典型问题及解决方案。针对田间多变光照、病害样本不均衡、标注歧义、背景干扰和边缘部署等挑战,提供了包括场景自适应数据增强、解耦训练、软标签与鲁棒损失函数、困难负样本构建以及模型轻量化部署在内的实战经验,旨在帮助开发者提升农业AI项目的落地效果。

ujm56789012的博客 206

【线索化】线索二叉树,二叉树的线索化,以及找线索化后指定节点的前驱及节点和后继节点

文章目录一、线索化的目的是什么?二、须知的规定三、线索化过程四、对于先、中、后序遍历的线索化时的对比五、总结 一、线索化的目的是什么? 传统的二叉链表的存储仅体现了一种父子关系,不能得到节点在遍历中的直接前驱和直接后继。 将二叉树线索化的目的是利用二叉树中的饿空指针,使其指向它的节点的直接前驱或直接后继。 二、须知的规定 在线索化过程中: 若该node节点无左子树,那么就让node.lchild指向node节点的直接前驱。 若该node节点无右子树,那么就让node.rchild指向node节点的直接后继。

✈ 正在努力 の 寒江(StudiousTiger) ✌ 呐 ✈ 2243

14、多标签分类与卷积神经网络在医学图像处理中的应用

本文探讨了多标签分类与卷积神经网络(CNN)在医学图像处理中的应用。文章详细介绍了多标签分类的概念和挑战,以及如何通过CNN进行高效、准确的分类任务。内容涵盖模型设计、损失函数选择、数据增强技术、类别权重调整等关键技术点,并结合实际案例,如白内障手术工具检测、视网膜血管分割等,展示了CNN在医学图像分析中的强大潜力。此外,还讨论了模型优化策略及面临的挑战与解决方案。

t8u9v0的博客 193

【Frida Android】实战篇4:SSL Pinning 证书绑定绕过 Hook 教程(一)

在前两章中,我们学习了中间人抓包与 Hook 抓包的基础方法,这些方法在理想环境下能够有效获取网络请求数据。但在实际的企业级应用中,出于安全防护需求,很多 APP 会启用证书绑定(SSL Pinning)机制。这种机制会让客户端对服务器证书的校验更为严格,导致常规的抓包方法(即使将 BurpSuite/Charles 证书安装到系统信任区)也无法生效。因此,从本章开始,我们将系统学习 SSL Pinning 机制的绕过技术。SSL Pinning(证书绑定)是客户端校验服务器身份的进阶安全机制。

水滴石穿 1612

数据结构之线索二叉树

二叉树的遍历实质上是对一个非线性结构进行线性化的过程,它使得每个结点(除第一个和最后一个)在这些线性序列中有且仅有一个直接前驱和直接后继。但在二叉链表存储结构中,只能找到一个结点的左、右孩子,不能直接得到结点在任一遍历序列中的前驱和后继,这些信息只有在遍历的动态过程中才能得到,因此,引入线索二叉树来保存这些动态过程得到的信息。

qq_33501207的博客 1110

Android OTA 更新面试题及参考答案

OTA 更新即空中下载技术(Over-the-Air Technology)更新,是一种通过无线网络对移动设备的系统软件或应用程序进行远程更新的技术手段。其原理是设备通过移动网络或 Wi-Fi 连接到服务器,服务器检测设备上可更新的软件版本,当有新的版本时,将更新包发送到设备上。设备接收后,在后台自动完成更新包的下载、安装等一系列操作,无需用户手动下载完整的系统镜像或应用安装包并通过数据线等方式进行安装。例如,当手机厂商推出新的安卓系统版本或安全补丁时,就会通过 OTA 方式推送给用户。

大模型大数据攻城狮的专栏 1631

数据结构 —— 线索二叉树

线索二叉树的意义 对于一个有n个节点的二叉树,每个节点有指向左右孩子的指针域。其中会出现n+ 1个空指针域,这些空间不储存任何事物,浪费着内存的资源。 对于一些需要频繁进行二叉树遍历操作的场合,二叉树的非递归遍历操作过程相对比较复杂,递归遍历虽然简单明了,但是会有额外的开销,对于操作的时间和空间都比较浪费。 我们可以考虑利用这些空地址,存放指向节点在某种遍历次序下的前驱和后继节点的地址。通过这些前驱和后继节点的地址可以知道,从当前位置下一步应该走向哪里。 线索二叉树的定义 指向前驱和后继的指针称为线索

m0_62969222的博客 3470

ResNet改进(51):基于轴向注意力机制的改进ResNet模型

本文介绍了一种结合轴向注意力机制的改进ResNet模型。 通过在传统CNN中引入轴向注意力,我们能够在保持计算效率的同时,增强模型对图像全局上下文的理解能力。这种混合架构结合了CNN的局部特征提取优势和注意力机制的全局建模能力,在图像识别任务中表现出色。 轴向注意力机制的应用不仅限于ResNet,也可以灵活地集成到其他CNN架构中。 未来可以探索更多注意力变体,或将其应用于特定领域任务,如医学图像分析、自动驾驶等需要精确空间理解的场景。 希望本文能帮助你理解如何将注意力机制与传统CNN结合,为你的计

2401_82355416的博客 361

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

数据结构之:线索二叉树

数据结构学习之:线索二叉树线索二叉树1、线索二叉树概述1.1 线索二叉树的使用背景1.2线索二叉树创建原理2、线索二叉树代码实现2.1 线索二叉树创建 线索二叉树 1、线索二叉树概述 1.1 线索二叉树的使用背景 对于一颗二叉树而言(如下图所示),每次我们想要查找二叉树里面的一个节点的时候,我们都必须遍历这棵树,以中序遍历为例,遍历的顺序为4251637,当我们遍历到标号为5这个节点的时候,如果有个指针指向5的前一个节点2或者后一个节点1的话,那么我们跳转到2或者1的效率肯定会大大的提升,那我们在哪里去创建

bandenger的博客 603

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

24考研数据结构-线索二叉树的线索化

线索二叉树的线索化

VengaZ的学习博客 552

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

Java学习——数据结构——线索化二叉树

学习尚硅谷韩顺平老师的Java数据结构笔记,详情请移步网站 1、引子 问题分析: (1) 当我们对上面的二叉树进行中序遍历时,数列为 {8, 3, 10, 1, 6, 14 } (2) 但是 6, 8, 10, 14 这几个节点的 左右指针,并没有完全的利用上. (3) 如果我们希望充分的利用 各个节点的左右指针, 让各个节点可以指向自己的前后节点,怎么办? (4) 解决方案-线索二叉树 2、基本介绍 (1) n 个结点的二叉链表中含有n+1 【公式 2n-(n-1)=n+1】 个空指针域。利用二叉链表

qq_41853002的博客 296

【Java数据结构】线索二叉树

中序线索二叉树线索二叉树概述线索二叉树代码实现线索二叉树的数据结构线索二叉树的遍历线索二叉树示例完整代码线索二叉树类 ThreadedBinaryTree线索二叉树节点类 ThreadedNode测试类 TestThreadBinaryTree 线索二叉树概述 线索化二叉树时, 一个节点的前一个节点,叫做前驱节点; 一个节点的后一个节点,叫做后继节点。 线索二叉树是建立在二叉树的基础上,可以方便...

萌宅鹿的技术小屋 694

C语言 数据结构 线索二叉树

拓展四(1) 线索二叉树 #include <stdio.h> #include <stdlib.h> typedef char ElemType; //线索存储标志位 //Link(0):表示指向左右孩子的指针 //Thread(1):表示指向前驱后继的线索 typedef enum {Link,Thread} PointerTag; typedef struct...

LangYueMoon的博客 312

有趣的数据结构算法16——线索二叉树的构建

有趣的数据结构算法16——线索二叉树的构建什么是线索二叉树线索二叉树的实现形式线索二叉树的代码实现线索二叉树的初始化线索的串联全部实现代码GITHUB下载连接 深度遍历不仅仅有递归的方法噢,还有通过建立线索二叉树进行遍历的方法! 什么是线索二叉树 在二叉树的结点上加上线索的二叉树称为线索二叉树,本文所讲述的线索二叉树主要用于中序遍历。 定义二叉树的时候,我们定义的每一个结点都是属于同一个结构体的...

Bubbliiiing的学习小课堂 4546

简单数据结构的实现之线索二叉树

线索二叉树,我写过的比较恶心的数据结构之一。我一直认为线索化应该是对二叉树的一个操作。可是,线索二叉树与普通的二叉树却实在大有不同。算了,不说了,上代码! #include using namespace std; #ifndef TREENODE_H_INCLU

猫咪的晴天 1284

【数据结构】线索二叉树

二叉树遍历时从任一节点出发只能找到左右孩子,而一般的情况下无法直接找到该结点在某种遍历序列中的前驱和后继结点,这种信息只能在遍历的动态过程中才能得到。 但是,如果在首次遍历二叉树的过程中以某种方式保存了遍历序列中的前驱和后继结点的信息,则以后就可以根据该信息,加快相应的遍历过程。 考虑到一个具有n个结点的二叉树表,在2n个指针中只有n-1个是用来存储孩子结点的地址,存在n+1个空指针,可以利用

_Previous的博客 841

数据结构 java版 线索二叉树

文章目录一、线索二叉树1.1 结构1.2 线索二叉树的建立(中序)1.3 线索二叉树的遍历1.4 测试 一、线索二叉树 1.1 结构 标志位为0时表示节点的对应lnode,rnode保存的是左右子树的引用,否则保存的是前驱节点或者后驱节点的引用。 public class node { // 节点的权值ֵ public int value; //左子树和右子树 public node ...

初心魏的博客 1983

数据结构之——线索二叉树

线索二叉树:数据结构中的高效利器

m0_71974552的博客 2182

C语言数据结构之线索二叉树

C语言数据结构之线索二叉树 tips:前些天学习了二叉树的相关操作,今天来总结一下线索二叉树的操作。 线索二叉树:对二叉树以某种次序遍历得到序列中的前驱和后继,其中指向结点前驱和后继的指针称为线索,再加上线索的二叉树称之为线索二叉树。 线索化:对二叉树以某种次序遍历使其变成线索二叉树的过程称为线索化 1、线索二叉树的存储结构 lchild ltag data rtag rchild 其中,标志域的含义: ltag 0:lchild域指示结点的左孩子; 1:lchild域指示结点的前驱;

wrlovesmile的博客 806
上一篇: 数据结构-哈希表
下一篇: 数据结构-B/B+树
echo20222022
博客等级 码龄5年 5粉丝 38原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

echo20222022

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值