线索化二叉树

最新推荐文章于 2024-02-17 18:05:59 发布
最新推荐文章于 2024-02-17 18:05:59 发布
阅读量970 收藏 1
点赞数
分类专栏： 数据结构与算法 文章标签： 线索化二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44742328/article/details/121894422
版权
本文介绍了如何通过线索二叉树技术，充分利用节点指针，使中序遍历顺序与节点关系保持一致。通过实例展示了如何在HeroNode类中添加线索属性，以及如何实现线索化过程和中序遍历，最终得到83101146的输出序列。
摘要由CSDN通过智能技术生成

先看一个问题
将数列 {1, 3, 6, 8, 10, 14 } 构建成一颗二叉树.

在这里插入图片描述

问题分析:
① 当我们对上面的二叉树进行中序遍历时，数列为 {8, 3, 10, 1, 6, 14 }
② 但是 6, 8, 10, 14 这几个节点的 左右指针，并没有完全的利用上.
③ 如果我们希望充分的利用 各个节点的左右指针， 让各个节点可以指向自己的前后节点,怎么办?
解决方案-线索二叉树

线索二叉树基本介绍

① n个结点的二叉链表中含有n+1 (公式 2n-(n-1)=n+1)个空指针域。利用二叉链表中的空指针域，存放指向该结点在某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为"线索"）
在这里插入图片描述
上面这个图就是六个结点所以有七个空指针域，符合n+1

② 这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树(Threaded BinaryTree)。根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种
在这里插入图片描述
③ 一个结点的前一个结点，称为前驱结点，8就是3的前驱结点。
④ 一个结点的后一个结点，称为后继结点，3就是8的后继结点。

中序线索二叉树

在这里插入图片描述

说明: 当线索化二叉树后，Node节点的 属性 left 和 right ，有如下情况:
① left 指向的是左子树，也可能是指向的前驱节点. 比如 ① 节点 left 指向的左子树, 而 ⑩ 节点的 left 指向的就是前驱节点.
② right指向的是右子树，也可能是指向后继节点，比如 ① 节点right 指向的是右子树，而 ⑩ 节点的right 指向的是后继节点.

首先给实体类加两个属性

这两个属性就是为了处理上面说明中的这种情况

    //说明
    //1.如果leftType == 0表示指向的左子树，如果是1则表示指向的前驱结点
    //2.如果rightType == 0表示指向的右子树，如果是1则表示指向的后驱结点
    private int leftType;
    private int rightType;

实现类
中序线索化，先处理左子树，在处理当前结点，在处理右子树(其实用递归 处理的都是当前结点)

这个处理后继结点，是先把本结点储存为pre结点，然后到下一个节点后，让pre结点指向本节点，这是整个线索化的核心。

//定义ThreadBinaryTree 实现了线索化功能的二叉树
class ThreadBinaryTree {
    private HeroNode root;

    //为了实现线索化，需要创建要给当前结点的前驱结点的指针
    //在递归进行线索化时，pre总是保留前一个结点
    private HeroNode pre = null;

    public void setRoot(HeroNode root) {
        this.root = root;
    }

    //重载threadedNodes，就不用再放root了简单一点，不写也可以
    public void threadedNodes(){
        this.threadedNodes(root);
    }

    //编写对二叉树进行线索化的方法
    /**
     * 都是递归的思想
     * @param node :当前需要线索化的结点
     */
    public void threadedNodes(HeroNode node){
       //如果node == null，不能线索化
        if(node == null){
            return;
        }

        //第一步：先线索化左子树
        threadedNodes(node.getLeft());

        //第二步：线索化当前结点(这一步有点难度)
        //这里我们前驱结点和后继结点要分开处理，因为我们这个中序遍历是线性遍历
        //你不可能在处于一个结点的时候去同时的处理前驱结点和后继结点，我们在结
        //点类中去写pre这个属性也是这个原因，我们是遍历到下一个结点的时候，再
        //处理当前结点的后继结点，这个处理后继结点的思想其实跟处理前驱结点的差
        //不多，前提都是我们要知道前驱结点，我们处理前驱结点的时候，是因为我们
        //已经知道前驱结点了，但是当我们处理后继结点的时候是因为我们不知道我们
        //的后继结点在哪里，所以只能继续遍历到下一个结点，在下一个结点的时候在
        //把我们需要处理的结点当做当前结点的前驱结点进行处理。

        //第二步的第一小步：处理当前结点的前驱结点
        //如果这个node的左子节点为空那么就将其左子节点线索化
        if(node.getLeft() == null){
            //让当前结点的做指针指向前驱结点
            node.setLeft(pre);
            //修改当前结点的左指针的类型，指向前驱结点
            node.setLeftType(1);
        }

        //第二步的第二小步：处理后继结点
        if(pre != null && pre.getRight() == null){
            //让前驱结点的右指针指向当前结点
            pre.setRight(node);
            //修改前驱结点的右指针类型
            pre.setRightType(1);
        }

        //每处理完一个结点过后，让当前结点是下一个结点的前驱结点
        pre = node;

        //第三步：线索化右子树
        threadedNodes(node.getRight());

    }

测试类

/**
 * @author acoffee
 * @create 2021-10-26 19:08
 */
public class ThreadBinaryTreeDemo {
    public static void main(String[] args) {
        //测试
        HeroNode root = new HeroNode(1, "tom");
        HeroNode node2 = new HeroNode(3, "jack");
        HeroNode node3 = new HeroNode(6,"smith");
        HeroNode node4 = new HeroNode(8,"mary");
        HeroNode node5 = new HeroNode(10,"king");
        HeroNode node6 = new HeroNode(14,"frank");


        //我们根据上边的图像创建,二叉树，后面我们要递归创建，现在简单处理使用手动创建
        root.setLeft(node2);
        root.setRight(node3);
        node2.setLeft(node4);
        node2.setRight(node5);
        node3.setLeft(node6);

        //测试线索化
        ThreadBinaryTree threadBinaryTree = new ThreadBinaryTree();
        threadBinaryTree.setRoot(root);
        //调用线索化
        threadBinaryTree.threadedNodes();


        //我们以10号结点测试
        HeroNode left = node5.getLeft();
        System.out.println(left);//HeroNode{no=3, name='jack'}
        HeroNode right = node5.getRight();
        System.out.println(right);//HeroNode{no=1, name='tom'}
    }
}

执行结果：
在这里插入图片描述
在这里插入图片描述
我们可以看到跟我们的图示完全一致，说明中序线索化成功

遍历线索化二叉树（中序）

说明： 对前面的中序线索化的二叉树， 进行遍历
分析： 因为线索化后，各个结点指向有变化，因此原来的遍历方式不能使用，这时需要使用新的方式遍历线索化二叉树，各个节点可以通过线型方式遍历，因此无需使用递归方式，这样也提高了遍历的效率。 遍历的次序应当和中序遍历保持一致。

// 遍历线索化二叉树的方法
public void threadedList(){
    //定义一个变量，存储当前遍历的结点，从root开始
    HeroNode node = root;

    while(node != null){
        //循环的找到的leftType==1的结点,第一个找到就是8结点
        //后面随着遍历变化而变化，因为当leftType==1时,说明
        //该节点是按照线索化处理后的有效结点
        while(node.getLeftType() == 0){
            node = node.getLeft();
        }

        //打印当前这个结点
        System.out.println(node);

        //如果当前结点的右指针指向后继结点，就一直输出
        while(node.getRightType() == 1){
            //获取当前结点的后继结点
            node = node.getRight();
            System.out.println(node);
        }
        //替换这个遍历的结点
        node = node.getRight();
    }
}

测试代码

public static void main(String[] args) {
	   //测试
	   HeroNode root = new HeroNode(1, "tom");
	   HeroNode node2 = new HeroNode(3, "jack");
	   HeroNode node3 = new HeroNode(6,"smith");
	   HeroNode node4 = new HeroNode(8,"mary");
	   HeroNode node5 = new HeroNode(10,"king");
	   HeroNode node6 = new HeroNode(14,"frank");
	
	
	   //我们根据上边的图像创建,二叉树，后面我们要递归创建，现在简单处理使用手动创建
	   root.setLeft(node2);
	   root.setRight(node3);
	   node2.setLeft(node4);
	   node2.setRight(node5);
	   node3.setLeft(node6);
	
	   //测试线索化
	   ThreadBinaryTree threadBinaryTree = new ThreadBinaryTree();
	   threadBinaryTree.setRoot(root);
	   //调用线索化
	   threadBinaryTree.threadedNodes();
	
	   //中序遍历线索化二叉树
	   threadBinaryTree.threadedList();//8  3  10  1  14  6
}

测试结果：
在这里插入图片描述

中序线索化二叉树以及中序遍历线索化二叉树的完整代码

/**
 * @author acoffee
 * @create 2021-10-26 19:08
 */
public class ThreadBinaryTreeDemo {
    public static void main(String[] args) {
        //测试
        HeroNode root = new HeroNode(1, "tom");
        HeroNode node2 = new HeroNode(3, "jack");
        HeroNode node3 = new HeroNode(6,"smith");
        HeroNode node4 = new HeroNode(8,"mary");
        HeroNode node5 = new HeroNode(10,"king");
        HeroNode node6 = new HeroNode(14,"frank");
        
        //我们根据上边的图像创建,二叉树，后面我们要递归创建，现在简单处理使用手动创建
        root.setLeft(node2);
        root.setRight(node3);
        node2.setLeft(node4);
        node2.setRight(node5);
        node3.setLeft(node6);

        //测试线索化
        ThreadBinaryTree threadBinaryTree = new ThreadBinaryTree();
        threadBinaryTree.setRoot(root);
        //调用线索化
        threadBinaryTree.threadedNodes();

        //我们以10号结点测试
        HeroNode left = node5.getLeft();
        System.out.println(left);//HeroNode{no=3, name='jack'}
        HeroNode right = node5.getRight();
        System.out.println(right);//HeroNode{no=1, name='tom'}
        
        //中序遍历线索化二叉树
        threadBinaryTree.threadedList();//8  3  10  1  14  6
    }
}


//定义ThreadBinaryTree 实现了线索化功能的二叉树
class ThreadBinaryTree {
    private HeroNode root;

    //为了实现线索化，需要创建要给当前结点的前驱结点的指针
    //在递归进行线索化时，pre总是保留前一个结点
    private HeroNode pre = null;

    public void setRoot(HeroNode root) {
        this.root = root;
    }

    //重载threadedNodes，就不用再放root了简单一点，不写也可以
    public void threadedNodes(){
        this.threadedNodes(root);
    }

    // 遍历线索化二叉树的方法
    public void threadedList(){
        //定义一个变量，存储当前遍历的结点，从root开始
        HeroNode node = root;

        while(node != null){
            //循环的找到的leftType==1的结点,第一个找到就是8结点
            //后面随着遍历变化而变化，因为当leftType==1时,说明
            //该节点是按照线索化处理后的有效结点
            while(node.getLeftType() == 0){
                node = node.getLeft();
            }

            //打印当前这个结点
            System.out.println(node);

            //如果当前结点的右指针指向后继结点，就一直输出
            while(node.getRightType() == 1){
                //获取当前结点的后继结点
                node = node.getRight();
                System.out.println(node);
            }
            //替换这个遍历的结点
            node = node.getRight();
        }
    }

    //编写对二叉树进行线索化的方法
    /**
     * 都是递归的思想
     * @param node :当前需要线索化的结点
     */
    public void threadedNodes(HeroNode node){
       //如果node == null，不能线索化
        if(node == null){
            return;
        }

        //第一步：先线索化左子树
        threadedNodes(node.getLeft());

        //第二步：线索化当前结点(这一步有点难度)

        //这里我们前驱结点和后继结点要分开处理，因为我们这个中序遍历是线性遍历
        //你不可能在处于一个结点的时候去同时的处理前驱结点和后继结点，我们在结
        //点类中去写pre这个属性也是这个原因，我们是遍历到下一个结点的时候，再
        //处理当前结点的后继结点，这个处理后继结点的思想其实跟处理前驱结点的差
        //不多，前提都是我们要知道前驱结点，我们处理前驱结点的时候，是因为我们
        //已经知道前驱结点了，但是当我们处理后继结点的时候是因为我们不知道我们
        //的后继结点在哪里，所以只能继续遍历到下一个结点，在下一个结点的时候在
        //把我们需要处理的结点当做当前结点的前驱结点进行处理。

        //第二步的第一小步：处理当前结点的前驱结点
        //如果这个node的左子节点为空那么就将其左子节点线索化
        if(node.getLeft() == null){
            //让当前结点的做指针指向前驱结点
            node.setLeft(pre);
            //修改当前结点的左指针的类型，指向前驱结点
            node.setLeftType(1);
        }

        //第二步的第二小步：处理后继结点
        if(pre != null && pre.getRight() == null){
            //让前驱结点的右指针指向当前结点
            pre.setRight(node);
            //修改前驱结点的右指针类型
            pre.setRightType(1);
        }

        //每处理完一个结点过后，让当前结点是下一个结点的前驱结点
        pre = node;

        //第三步：线索化右子树
        threadedNodes(node.getRight());

    }
}

//节点类
class HeroNode {
    private int no;
    private String name;
    private HeroNode left;
    private HeroNode right;

    //说明
    //1.如果leftType == 0表示指向的左子树，如果是1则表示指向的前驱结点
    //2.如果rightType == 0表示指向的右子树，如果是1则表示指向的后驱结点
    private int leftType;
    private int rightType;

    public int getLeftType() {
        return leftType;
    }

    public void setLeftType(int leftType) {
        this.leftType = leftType;
    }

    public HeroNode(int no, String name) {
        this.no = no;
        this.name = name;
    }

    public int getRightType() {
        return rightType;
    }

    public void setRightType(int rightType) {
        this.rightType = rightType;
    }

    public HeroNode() {
        this.no = no;
        this.name = name;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public HeroNode getLeft() {
        return left;
    }

    public void setLeft(HeroNode left) {
        this.left = left;
    }

    public HeroNode getRight() {
        return right;
    }

    public void setRight(HeroNode right) {
        this.right = right;
    }

    //toString 方法不写left 和 right属性 写了有可能会递归调用
    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }
}
中序线索化二叉树的非递归算法.doc
09-12
中序线索化二叉树的非递归算法 中序线索化二叉树的非递归算法是指对二叉树进行中序遍历，并将其转换为线索化二叉树的算法。这里，我们将详细介绍该算法的实现过程和相关知识点。 算法思想 中序线索化二叉树的非...
线索化二叉树C实现代码
02-24
线索化二叉树是一种特殊的二叉树数据结构，它的主要目的是为了在非递归的情况下能够进行二叉树的前序、中序和后序遍历。这种数据结构通过利用二叉树结点中的空指针域，即通常的`left`和`right`指针，来附加线索，...
二叉树线索化
丁香枝上，豆蔻梢头
05-18 493
二叉树的线索化可以使得二叉树的非递归遍历不需借助栈或队列这种数据结构，最主要的是可以为之提供迭代器。线索化二叉树有三种方式：前序线索化、中序线索化、后序线索化（后序线索化需要三叉链结构）这里主要讲前序线索化和中序线索化，并为中序线索化提供迭代器。 线索化的思想就是将一颗二叉树遍历转换成有序双向链表进行访问。这样二叉树的节点结构就应该多一个前驱和后继的线索化标志。 节点结构 enum Point
利用栈实现线索化二叉树_javascript线索化二叉树
weixin_30585729的博客
01-27 248
线索化二叉树数列 {1, 3, 6, 8, 10, 14 } 构建成一颗二叉树(中序遍历的数列为 {8, 3, 10, 1, 14, 6}). n+1=7线索二叉树基本介绍1.n个结点的二叉链表中含有n+1 【公式 2n-(n-1)=n+1】 个空指针域。利用二叉链表中的空指针域，存放指向该结点在某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为"线索"）2.这种加上了线索的二叉链表称...
线索化二叉树详解与代码实现
IronmanJay
01-17 564
文章目录一、问题提出二、线索二叉树基本介绍三、线索二叉树应用案例四、中序线索化二叉树代码实现五、代码运行结果 一、问题提出 当我们对上面的二叉树进行中序遍历时，数列为{8，3，10，1，6，14} 但是6，8，10，14这几个节点的左右指针（红色箭头），并没有完全的利用上 如果我们希望充分的利用各个节点的左右指针，并且让各个节点可以指向自己的前后节点，怎么办？ 二、线索二叉树基本介绍 n个节点的二叉链表中含有n+1个空指针域。利用二叉链表中的空指针域，存放指向该节点在某种遍历次序下的前驱和后继节点的
Python实现线索化二叉树 Python实现线索化存储二叉树 Python线索化二叉树的遍历
storyfull
12-28 3143
Python实现线索化二叉树 Python实现线索化存储二叉树 Python线索化二叉树的遍历
线索化二叉树（先序，中序，后序）+线索化二叉树的遍历【java详解】
最新发布
2302_79862386的博客
02-17 2769
n个结点的二叉链表中含有n+1 【公式 2n-(n-1)=n+1】 个空指针域。利用二叉链表中的空指针域，存放指向该结点在某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为"线索"）这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树(Threaded BinaryTree)。根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种一个结点的前一个结点，称为前驱结点一个结点的后一个结点，称为后继结点//线索化时记录前一个节点//节点存储结构。
二叉树的线索化
热门推荐
编程小霸王的Blog
12-05 2万+
线索二叉树(Threaded BinaryTree) 1.线索二叉树的基本概念       遍历二叉树是以一定规则将二叉树中的结点排列成一个线性序列，得到二叉树中结点的先序序列、中序序列或后序序列。 这实质上是对一个非线性结构进行线性化操作。使每个结点(除第一个和最后一个外)在这些线性序列中有且仅有一个直接前驱和直接后继。      例如二叉树结点的中序序列a+b*c-d-e/f中，“c”
C语言实现的线索化二叉树及其遍历
本篇文章详细介绍了如何在C语言环境下实现线索化二叉树的数据结构和算法。线索化二叉树是一种特殊的二叉树存储结构，通过额外的信息（线索）来辅助遍历操作，使得在遍历时可以更方便地追踪前驱和后继节点，从而简化...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值