【数算-21】线索二叉树

最新推荐文章于 2021-12-13 19:30:07 发布
最新推荐文章于 2021-12-13 19:30:07 发布
阅读量436 收藏 2
点赞数
分类专栏： 笔记 文章标签： 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45729934/article/details/113851019
版权

文章目录

1、线索二叉树的引入

在这里插入图片描述
简而言之就是：因为叶子结点或仅一个子结点存在时，二叉树的左右指针会有资源浪费的现象，因此引入线索化二叉树，重新利用起无指向的指针情况

2、线索二叉树的概念

在这里插入图片描述

3、线索二叉树的应用与图解

  • 问题描述
    在这里插入图片描述
  • 由于线索二叉树是通过无指向的指针来指向前驱结点与后继结点的，因此线索二叉树一定与某种特定的遍历方式有关。所以，这里以中序遍历线索二叉树为例，对线索二叉树进行图解分析
    在这里插入图片描述
    由上图的二叉树可以得出其中序遍历序列：8-3-10-1-14-6
    由线索二叉树的概念可知，将无指向的左指针指向遍历序列中的前驱结点，将无指向的右指针指向遍历序列中的后继结点
    对上图进行修改，可以得到下面的二叉树结构
    在这里插入图片描述
  • 具体说明
    在这里插入图片描述

4、线索二叉树的代码实现

由于在未经线索化的二叉树结构中，结点的左右指针分别指向其左右子树；而在线索化二叉树结构中，左右指针分别指向其前驱结点和后继结点
因此需要对其左右指针所指向的内容需要进行区分
这里通过为左右指针新增对应的type属性来判断该指针指向的到底代表哪种含义

Node.class

package threaded_bin_tree;

/**
 * @author zhihua.li
 * @date 2021/2/15 - 23:46
 **/
public class Node {
    private Integer no;
    private String name;
    private Node left;
    private Node right;
//    若 leftType/rightType 为 0则表示为指向其左/右子树，为1表示指向其前驱/后继结点
    private int leftType;
    private int rightType;

    public int getLeftType() {
        return leftType;
    }

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

    public int getRightType() {
        return rightType;
    }

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

    public Node(Integer no, String name) {
        this.no = no;
        this.name = name;
    }

    //    前序遍历： 根 左 右
    public void preOrderIterate() {
//        不用判断该节点是否为空
        System.out.println(this);
        if (this.left != null) {
            this.left.preOrderIterate();
        }
        if (this.right != null) {
            this.right.preOrderIterate();
        }
    }

    //    中序遍历：左 根 右
    public void midOrderIterate() {
        if (this.left != null) {
            this.left.midOrderIterate();
        }
        System.out.println(this);
        if (this.right != null) {
            this.right.midOrderIterate();
        }
    }

    //    后序遍历：左 右 根
    public void postIterate() {
        if (this.left != null) {
            this.left.postIterate();
        }
        if (this.right != null) {
            this.right.postIterate();
        }
        System.out.println(this);
    }


    @Override
    public String toString() {
        return "binary_tree.Node{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }

    public Integer getNo() {
        return no;
    }

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

    public String getName() {
        return name;
    }

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

    public Node getLeft() {
        return left;
    }

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

    public Node getRight() {
        return right;
    }

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

ThreadedBinaryTree.class

package threaded_bin_tree;
/**
 * @author zhihua.li
 * @date 2021/2/16 - 19:41
 **/


/**
 * @program: DataStructure
 * @description: 线索二叉树代码实现
 * @author: zhihua li
 * @create: 2021-02-16 19:41
 */
public class ThreadedBinaryTree {
    private Node root;
    //    设置前驱结点，初始化为null
    private Node pre = null;

    public ThreadedBinaryTree(Node root) {
        this.root = root;
    }

    public Node getPre() {
        return pre;
    }

    public void setPre(Node pre) {
        this.pre = pre;
    }

    //    先序线索化二叉树
    public void preThreadedNodes(Node node) {
//        若传入结点为空，则直接返回
        if (node == null) {
            return;
        }

//        对当前节点进行线索化：
//        如果当前节点的左子节点为空，则设置当前结点的左子节点为pre，并且设置type为1
        if (node.getLeft() == null) {
            node.setLeft(pre);
            node.setLeftType(1);
        }
//        若保存的pre结点不为空且该节点的右子节点为空，说明可以保存其后继结点到right中
        if (pre != null && pre.getRight() == null) {
//            给pre结点（上一次递归的结点，也为本次执行的前驱结点）设置后继结点为node
            pre.setRight(node);
            pre.setRightType(1);
        }

//        让pre后移为当前节点
        pre = node;

//        对其左子节点进行递归线索化.不加判断的话会造成死循环
//        比如 3-8-3-8....
        if(node.getLeftType()==0) {
            preThreadedNodes(node.getLeft());
        }
//        对其右子节点进行递归线索化
        if(node.getRightType()==0) {
            preThreadedNodes(node.getRight());
        }
    }

    //中序线索化二叉树
    public void midThreadedNodes(Node node) {
//        当前递归的终止条件
        if (node == null) {
            return;
        }
//        线索化左子树
        midThreadedNodes(node.getLeft());

//        线索化当前结点
//        1.处理当前结点的前驱结点：
        if (node.getLeft() == null) {
//            让当前节点的左指针指向前驱结点
            node.setLeft(pre);
//            修改左指针类型
            node.setLeftType(1);
        }
//        2.处理当前结点的后继结点
        if (pre != null && pre.getRight() == null) {
            pre.setRight(node);
            pre.setRightType(1);
        }
//        将当前结点设置为前驱结点以便下次递归设置，pre也是动态的
        pre = node;

//        线索化右子树
        midThreadedNodes(node.getRight());

    }

    //后序线索化二叉树
    public void postThreadedNodes(Node node) {
        if (node == null) {
            return;
        }
//        线索化当前结点的左子结点
        postThreadedNodes(node.getLeft());
//        线索化当前结点的右子结点
        postThreadedNodes(node.getRight());
//        线索化当前结点
//        处理当前结点的前驱结点
        if (node.getLeft() == null) {
            node.setLeft(pre);
            node.setLeftType(1);
        }
//        处理当前结点的后继结点
        if (pre != null && pre.getRight() == null) {
            pre.setRight(node);
            pre.setRightType(1);
        }
//        将当前结点设置为前驱结点以便下次递归设置，pre也是动态的
        pre = node;
    }

    public void preThreadedList(){
        if(root!=null){
            root.preOrderIterate();
        }
        System.out.println("当前根节点为空");
    }

    public void midThreadedList(){
        if(root!=null){
            root.midOrderIterate();
        }
        System.out.println("当前根节点为空");
    }

    public void postThreadedList(){
        if(root!=null){
            root.postIterate();
        }
        System.out.println("当前根节点为空");
    }
}

注意：先序遍历线索化二叉树时，需要对当前结点的左右结点进行判断，看其是否为前驱/后继结点，如果当前结点的左指针已经修改为其前驱结点，就不对其左子树进行递归操作了，同理，右子树也一样

5、线索二叉树的测试

设计二叉树结构为下图，分别对三种遍历方式的线索化进行测试：
在这里插入图片描述

1、先序线索化

ThreadedBinaryTreeTest

package threaded_bin_tree;/**
 * @author zhihua.li
 * @date 2021/2/16 - 21:16
 **/

/**
 *@program: DataStructure
 *@description: 测试线索二叉树
 *@author: zhihua li
 *@create: 2021-02-16 21:16
 */
public class ThreadedBinaryTreeTest {
    public static void main(String[] args) {
        Node root = new Node(1,"tom");
        Node node2 = new Node(3,"jack");
        Node node3 = new Node(6,"smith");
        Node node4 = new Node(8,"mary");
        Node node5 = new Node(10,"king");
        Node node6 = new Node(14,"dim");

        root.setLeft(node2);
        root.setRight(node3);
        node2.setLeft(node4);
        node2.setRight(node5);
        node3.setLeft(node6);

//        测试线索化,以node5为例，若正常线索化，则包含前驱结点和后继结点
//		  由下图中的先序遍历分析可知
//        node5（no=10）的前驱结点为8，后继结点为6
        ThreadedBinaryTree tree = new ThreadedBinaryTree(root);
        tree.preThreadedNodes(root);
        
        System.out.println(node5.getLeft());
        System.out.println(node5.getRight());
    }
}

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

2、中序线索化
package threaded_bin_tree;/**
 * @author zhihua.li
 * @date 2021/2/16 - 21:16
 **/

/**
 *@program: DataStructure
 *@description: 测试线索二叉树
 *@author: zhihua li
 *@create: 2021-02-16 21:16
 */
public class ThreadedBinaryTreeTest {
    public static void main(String[] args) {
        Node root = new Node(1,"tom");
        Node node2 = new Node(3,"jack");
        Node node3 = new Node(6,"smith");
        Node node4 = new Node(8,"mary");
        Node node5 = new Node(10,"king");
        Node node6 = new Node(14,"dim");

        root.setLeft(node2);
        root.setRight(node3);
        node2.setLeft(node4);
        node2.setRight(node5);
        node3.setLeft(node6);

//        测试线索化,以node5为例，若正常线索化，则包含前驱结点和后继结点
//		  由下图中的先序遍历分析可知
//        node5（no=10）的前驱结点为3，后继结点为1
        ThreadedBinaryTree tree = new ThreadedBinaryTree(root);
        tree.midThreadedNodes(root);
        
        System.out.println(node5.getLeft());
        System.out.println(node5.getRight());
    }
}

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

3、后序线索化
package threaded_bin_tree;/**
 * @author zhihua.li
 * @date 2021/2/16 - 21:16
 **/

/**
 *@program: DataStructure
 *@description: 测试线索二叉树
 *@author: zhihua li
 *@create: 2021-02-16 21:16
 */
public class ThreadedBinaryTreeTest {
    public static void main(String[] args) {
        Node root = new Node(1,"tom");
        Node node2 = new Node(3,"jack");
        Node node3 = new Node(6,"smith");
        Node node4 = new Node(8,"mary");
        Node node5 = new Node(10,"king");
        Node node6 = new Node(14,"dim");

        root.setLeft(node2);
        root.setRight(node3);
        node2.setLeft(node4);
        node2.setRight(node5);
        node3.setLeft(node6);

//        测试线索化,以node5为例，若正常线索化，则包含前驱结点和后继结点
//		  由下图中的先序遍历分析可知
//        node5（no=10）的前驱结点为8，后继结点为3
        ThreadedBinaryTree tree = new ThreadedBinaryTree(root);
        tree.postThreadedNodes(root);
        
        System.out.println(node5.getLeft());
        System.out.println(node5.getRight());
    }
}

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

6、线索二叉树的遍历

1、问题描述

在这里插入图片描述
注意点： 遍历线索化二叉树的前提是与线索化的顺序相同，比如中序遍历线索化二叉树时，对象必须是经过中序线索化后的二叉树

2、代码实现
public void midThreadedList() {
        //        定义变量接收当前结点的root结点
        Node node = root;
        while (node != null) {
//            循环的找到leftType为1的点,当leftType为1时，说明该节点已经历过线索化处理
            while (node.getLeftType() == 0) {
                node = node.getLeft();
            }
            System.out.println(node);
//            循环找到rightType为1的点并打印
            while (node.getRightType() == 1) {
                node = node.getRight();
                System.out.println(node);
            }
            node = node.getRight();
        }
    }
3、代码测试
public class ThreadedBinaryTreeTest {
    public static void main(String[] args) {
        Node root = new Node(1,"tom");
        Node node2 = new Node(3,"jack");
        Node node3 = new Node(6,"smith");
        Node node4 = new Node(8,"mary");
        Node node5 = new Node(10,"king");
        Node node6 = new Node(14,"dim");

        root.setLeft(node2);
        root.setRight(node3);
        node2.setLeft(node4);
        node2.setRight(node5);
        node3.setLeft(node6);

		ThreadedBinaryTree tree = new ThreadedBinaryTree(root);
        tree.midThreadedNodes(root);
        // 遍历顺序与线索化顺序必须一致
        tree.midThreadedList();

在这里插入图片描述

4、扩展
1、先序遍历线索化二叉树

前序遍历代码如下：

//    遍历线索化二叉树（先序）的方法：
    public void preThreadedList() {
        Node node = root;
        while (node != null) {
//            先序遍历线索二叉树
//            先打印当前二叉树的根节点
            System.out.println(node);
            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();
        }
    }

在这里插入图片描述

2、后序遍历线索化二叉树【推导较难】

后序遍历遇到的问题：
在本例中，由所给二叉树后序遍历序列为：8-10-3-14-6-1
由后序线索化可得下图中的线索二叉树
在这里插入图片描述

在遍历的过程中会遇到这样的情况：

  • 1-3-8-10的过程省略。。。
    当遍历到10结点时，其后继结点为3，而3的右指针指向的仅仅为右子树而并不代表后继结点，所以在这里会造成一直访问3-8-10-3…而无法直接跳转到右子树中的14结点

  • 因此我想到了需要对左右子树分别遍历，左子树中断后跳转到右子树对右子树进行遍历，最后遍历根结点

  • 其次对于一直3-8-10-3-8-…的循环，为了打破这个死循环，我能想到的只有为遍历过的结点添加一个标志，来避免一直循环该结点

具体代码实现

//    遍历线索化二叉树（后序）的方法：
    public void postThreadedList() {
        Node node = root;
        //为了避免死循环，为Node.class新增hasList属性
        while(node.getLeftType()==0&&node.hasList == false){
            node.hasList = true;
            node = node.getLeft();
        }
        System.out.println(node);
        while (node.getRightType()==1) {
            node = node.getRight();
            System.out.println(node);
        }
        //左子树遍历结束，开始遍历右子树
        node = root.getRight();
        //对右子树进行相同遍历操作
        while(node.getLeftType()==0&&node.hasList == false){
            node.hasList = true;
            node = node.getLeft();
        }
        System.out.println(node);
        while (node.getRightType()==1) {
            node = node.getRight();
            //注意这里不需要对根结点再次输出，因为6结点的后缀结点就为1结点，因此直接循环即可打印出root结点
            System.out.println(node);
        }
        }

在这里插入图片描述

pascalzhli
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【数据结构】-线索二叉树(先序)
RunningSnail的博客
08-10 7209
先序线索化二叉树1.头文件及类型定义2.线索二叉树结点类型定义3.函数声明4.基本操作4.1 先序建立线索二叉树4.2 初始化tag4.3 先序线索化二叉树4.3.1 访问并建立线索4.3.2 遍历4.3.3 先序线索化主过程4.4 寻找先序后继4.5 先序遍历4.5.1 打印结点4.5.2 利用先序后继实现先序遍历4.6 main函数4.7 测试4.7.1 二叉树结构4.7.2 测试结果5.小结 1.头文件及类型定义 #include<stdio.h> #include<stdlib.h
数据结构5.1.1 - 线索二叉树 代码测试
qq_1403034144的博客
05-19 200
目录1 代码2 运行结果2.1 前序线索二叉树2.2 中序线索二叉树2.3 后序线索二叉树 1 代码 #include<bits/stdc++.h> #define max 1000 #define num 100 using namespace std; typedef struct TBNode { int data; //数据 int ltag, rtag; // 0,1; // ltag = 0, lchild指向孩子-左子树; ltag = 1, lchild指向前驱
线索二叉树
weixin_30419799的博客
12-11 40
1 #include<iostream> 2 #include<cstdlib> 3 #include<cstdio> 4 #include<cstring> 5 #include<malloc.h> 6 using namespace std; 7 8 typedef char E...
数算POJ二叉树作业
11-21
数算的二叉树的POJ作业，分别有：二叉树1_二叉树的操作；二叉树2_文本二叉树；二叉树3_由中根序列和后根序列重建二叉树；二叉树4_表达式.表达式树.表达式求值；二叉树5_Huffman编码树；二叉树6_二叉搜索树；二叉树7_...
讲章----数算自己的年日
04-21
讲章----数算自己的年日
2014北大数算期末考试
01-15
2014北大数算期末考试 请大家分享 无答案
北大--2014数算期末考试试题.pdf
01-20
北大--2014数算期末考试试题
数算课后习题
05-25
数算算法与结构一书课后习题答案
面试高频必问-线索化二叉树
qq_25913607的博客
05-13 273
线索化二叉树 1、先看一个问题 将数列{1,3,6,8,10,14}构建成一颗二叉树.n+1=7 问题分析: 当我们对上面的二叉树进行中序遍历时，数列为{8,3,10,1,6,14} 但是6,8,10,14这几个节点的左右指针，并没有完全的利用上. 如果我们希望充分的利用各个节点的左右指针，让各个节点可以指向自己的前后节点,怎么办? 解决方案-线索二叉树 2、线索二叉树基本介绍 n个结点的二叉链表中含有n+1【公式2n-(n-1)=n+1】个空指针域。利用二叉链表中的空指针域，存放指向该结点在某种遍
打印二叉搜索树的叶子结点_线索二叉树
weixin_32821811的博客
01-16 383
产生的背景:存在空间浪费的二叉树如上图的二叉树中，如果没有左孩子或者没有右孩子时，就存在空间浪费，如果二叉树很大时，空间浪费就会非常严重。如果想知道某个结点的前驱和后继时，就要通过遍历一次来确定。所以为了解决这个问题，现在可以利用这些浪费的空间来存储结点的前驱和后继。按照一种的顺序来存储前驱和后继。(例如中序遍历的方式)利用浪费的空间来做有限的线索化目的: 解决空间浪费问题；寻找某个结点的前驱和后...
学习笔记：线索二叉树
张小憨憨的博客
12-13 1627
线索二叉树线索二叉树内容回顾：线索二叉树：1. 线索二叉树基本概念线索二叉树的结点结构：线索二叉树的分类：2. 二叉树线索化线索化的实现方法：线索化实现算法：3. 线索二叉树的遍历 线索二叉树 内容回顾： 二叉树的遍历过程较为复杂，需要用到递归或栈。 二叉树结点的遍历序列是一个线性系列。 二叉链表难以获得遍历序列前驱，后继结点信息。 二叉链表中，N个结点，2N个指针，N+1个空指针。 线索二叉树： 1. 线索二叉树基本概念 指向遍历序列前驱，后继结点的指针称为线索。 把空指针修改为线索的过程称为线索化。
链表和二叉树 指针和双指针
diamond0369的博客
07-24 303
被二叉树定义中的双指针困扰了很久 typedef struct Tree{ char flag; struct Tree*left; struct Tree*right; }tree; void CreatTree(tree**root) //指向指针的指针 理解为什么要这样 { char val = 0; scanf(" %c",&v...
二叉树
unspoken0714的博客
08-01 225
二叉树可以按左边小，右边大，构建 二叉树分左右两个两个指针，分别指向左右两个分支。 其遍历方式可以分为三种: 前序遍历:先访问根节点，然后访问左节点，最后右节点 中序遍历:先访问左节点，然后访问根节点，最后右节点 后续遍历:先访问左节点，然后访问右节点，最后根节点 public class node { int num; node left; node right; public node(int num){ this.num = num;
5.3 线索二叉树
猫宁的博客
12-09 149
question：如何根据中序遍历序列找到一个结点的前驱 使用土办法：分配两个指针，一个根据遍历找到该结点，一个结点记录该结点的前一个结点 BiNode *p = NULL; BiNode *pre = NULL; BiNode *final = NULL; void findInorder(BiTree T){ if(T!=NULL){ findInorder(T->lchild); visit(T); findInorder(T->rchi.
详解线索二叉树
02-20 395
线索二叉树概念 1．定义 　　n个结点的二叉链表中含有n+1个空指针域。利用二叉链表中的空指针域，存放指向结点在某种遍历次序下的前趋和后继结点的指针（这种附加的指针称为"线索"）。 　　这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树(Threaded   BinaryTree)。根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种。
c语言输入n个数算平均数
最新发布
07-09
很高兴回答您的问题！要计算 n 个数的平均值，您可以使用 C 语言编写以下代码： ```c #include int main() { int n, i; float sum = 0, num, average;... printf("请输入要计算平均值的数的个数：");...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

pascalzhli

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

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

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

打赏作者

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

抵扣说明：

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

余额充值