线索化二叉树前序、中序、后序遍历

最新推荐文章于 2024-05-26 14:39:41 发布
最新推荐文章于 2024-05-26 14:39:41 发布
阅读量1.5k 收藏 20
点赞数 7
分类专栏： JAVA 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42696192/article/details/103430453
版权

文章目录

节点信息

public class HeroNode {
    private int no;
    private String name;
    private HeroNode left;
    private HeroNode right;
    private HeroNode child;

    //说明
    //1、如果lefttype == 0表示指向的是左子树，如果是1则表示指向前驱节点
    //2、如果righttype == 0 表示指向是右子树，如果1表示指向后继节点
    private int lefttype;
    private int righttype;
    public HeroNode(int no, String name) {
        this.no = no;
        this.name = name;
    }

    public int getNo() {
        return no;
    }

    public String getName() {
        return name;
    }

    public HeroNode getLeft() {
        return left;
    }

    public HeroNode getRight() {
        return right;
    }

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

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

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

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

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }
     //前序遍历
    public void preOrder(){
        println(this);
        //递归左子树
        if (this.left != null){
             this.left.preOrder();
        }
        //递归向右子树遍历
        if (this.right != null)
        {
            this.right.preOrder();
        }
    }

    //中序遍历
    public void middleOrder(){

        //递归左子树
        if (this.left != null){
            this.left.middleOrder();
        }
        println(this);
        //递归向右子树遍历
        if (this.right != null)
        {
            this.right.middleOrder();
        }
    }

    //后序遍历
    public void postOrder(){

        //递归左子树
        if (this.left != null){
            this.left.postOrder();
        }
        //递归向右子树遍历
        if (this.right != null)
        {
            this.right.postOrder();
        }
        println(this);
    }

    /**
     * 前序遍历查找
     *  no 查找序号
     * @param no
     * @return
     */
    public HeroNode preOrderSearch(int no){
        println("前序遍历");
        if (this.no == no){
            return this;
        }
        HeroNode resNode = null;
        if (this.left != null){
            resNode = this.left.preOrderSearch(no);
        }
        if (resNode != null){
            return resNode;
        }
        if (this.right != null){
            resNode = this.right.preOrderSearch(no);
        }
        return resNode;
    }


    /**
     *中序遍历查找
     *  no 查找序号
     * @param no
     * @return
     */
    public HeroNode middleOrderSearch(int no){
        HeroNode resNode = null;
        if (this.left != null){
            resNode = this.left.middleOrderSearch(no);
        }
        if (resNode != null){
            return resNode;
        }
        println("中序遍历");
        if (this.no == no){
            return this;
        }

        if (this.right != null){
            resNode = this.right.middleOrderSearch(no);
        }
        return resNode;
    }


    /**
     *后序遍历查找
     *  no 查找序号
     * @param no
     * @return
     */
    public HeroNode postOrderSearch(int no){
        HeroNode resNode = null;
        if (this.left != null){
            resNode = this.left.postOrderSearch(no);
        }
        if (resNode != null){
            return resNode;
        }
        if (this.right != null){
            resNode = this.right.postOrderSearch(no);
        }
        if (resNode != null){
            return resNode;
        }
        println("后序遍历");
        //左右子树搜没有找到，比较当前节点
        if (this.no == no){
            return this;
        }
        return resNode;
    }

    //递归删除结点
    public void delNode(int no){
        if (this.left != null && this.left.no == no){
            this.left = null;
            return;
        }
        if (this.right != null && this.right.no == no){
            this.right = null;
            return;
        }
        if (this.left  != null){
            this.left.delNode(no);
        }
        if (this.right != null){
            this.right.delNode(no);
        }

    }

    public void setLefttype(int lefttype) {
        this.lefttype = lefttype;
    }

    public void setRighttype(int righttype) {
        this.righttype = righttype;
    }

    public int getLefttype() {
        return lefttype;
    }

    public int getRighttype() {
        return righttype;
    }

    public HeroNode getChild() {
        return child;
    }

    public void setChild(HeroNode node) {
        this.child = node;
    }
}
二叉树的构建

在这里插入图片描述

前序线索化二叉树

在这里插入图片描述

前序遍历

0 1 2 3 4 5
前序线索化思路
1、 先找到线索化的起始点—当前节点的左节点为空 node.getLeft() == null
2、然后把当前节点右指针指向前驱结点
3、在处理后继结点，并把前驱结点的右指针设置为当前节点
4、最后把当前节点设置为前驱结点
5、线索化左子树
6、线索化右子树
前序线索化遍历思路
1、 先找到线索化的起始点，边找边输出当前节点
2、然后寻找当前结点的后继结点，并输出
 /**
     *二叉树进行前序线索化的方法
     * @param node 就是当前需要线索化的节点
     */
    public void prethreadedNodes(HeroNode node){
        if (node == null){
            return;
        }
        //一、线索化当前节点
        //先处理当前结点的前驱结点
        if (node.getLeft() == null)
        {
            //让当前结点的左指针指向前驱结点
            node.setLeft(pre);
            //修改当前结点的左指针类型，指向前驱结点
            node.setLefttype(1);
        }
        //处理后继结点
        if (pre!=null && pre.getRight() == null){
            //让前驱结点的右指针指向当前结点
            pre.setRight(node);
            //修改前驱结点的右指针类型
            pre.setRighttype(1);
        }

        // 每处理一个结点后，让当前结点是下一个结点的前驱结点
        pre  = node;
        //二、先线索化左子树
        if (node.getLefttype()==0)
            prethreadedNodes(node.getLeft());
        //三、再线索化右子树
        if (node.getRighttype()==0)
        prethreadedNodes(node.getRight());
    }

前序线索化二叉树遍历

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

            //循环的找到leftType == 1的结点
            //后面随着遍历而变化，因为leftType==1，说明该结点是按照线索化处理后的有效结点
            while (node.getLefttype() == 0){
                //打印当前结点
                println(node);
                node = node.getLeft();
            }
            //如果当前结点的右指针指向的是后继结点，就一直输出
            while (node.getRighttype() == 1){
                //打印当前结点
                println(node);
                //获取到当前结点的后继结点
                node = node.getRight();
            }
            println(node);
            //替换这个遍历的结点
            node  = node.getRight();
        }
    }

中序线索化二叉树

在这里插入图片描述

中序遍历

1 3 2 0 4 5
中序线索化思路
1、先线索化左子树
2、找到线索化的起始点—当前节点的左节点为空 node.getLeft() == null
3、然后把当前节点右指针指向前驱结点
4、在处理后继结点，并把前驱结点的右指针设置为当前节点
5、最后把当前节点设置为前驱结点
6、线索化右子树
中序线索化遍历思路
1、 先找到线索化的起始点
2、输出当前节点信息
3、然后寻找当前结点的后继结点，并输出

    /**
     *二叉树进行中序线索化的方法
     * @param node 就是当前需要线索化的节点
     */
    public void middlethreadedNodes(HeroNode node){
        if (node == null){
            return;
        }
        //一、先线索化左子树
        middlethreadedNodes(node.getLeft());
        //二、线索化当前节点
        //先处理当前结点的前驱结点
        if (node.getLeft() == null)
        {
            //让当前结点的左指针指向前驱结点
            node.setLeft(pre);
            //修改当前结点的左指针类型，指向前驱结点
            node.setLefttype(1);
        }
        //处理后继结点
        if (pre!=null && pre.getRight() == null){
            //让前驱结点的右指针指向当前结点
            pre.setRight(node);
            //修改前驱结点的右指针类型
            pre.setRighttype(1);
        }
        // 每处理一个结点后，让当前结点是下一个结点的前驱结点
        pre  = node;
        //三、再线索化右子树
        middlethreadedNodes(node.getRight());
    }

中序线索化二叉树遍历

 //中序遍历线索化二叉树
    public void middlethreadedList(){
        //定义一个变量，存储当前遍历的结点，从root开始
        HeroNode node = root;
        while (node != null){
            //循环的找到leftType == 1的结点，第一个找到就是结点8
            //后面随着遍历而变化，因为leftType==1，说明该结点是按照线索化处理后的有效结点
            while (node.getLefttype() == 0){
                 node = node.getLeft();
            }
            //打印当前结点
            println(node);
            //如果当前结点的右指针指向的是后继结点，就一直输出
            while (node.getRighttype() == 1){
                //获取到当前结点的后继结点
                node = node.getRight();
                println(node);
            }
            //替换这个遍历的结点
            node  = node.getRight();
        }
    }

后序线索化二叉树

后序遍历

1 3 2 0 4 5
后序线索化思路
1、先线索化左子树
2、在线索化右子树
3、找到线索化的起始点—当前节点的左节点为空 node.getLeft() == null
4、然后把当前节点右指针指向前驱结点
5、在处理后继结点，并把前驱结点的右指针设置为当前节点，如果前驱结点的右节点不为空，那么就把前驱结点的孩子设置为当前节点（避免遍历时进入到死循环）
6、最后把当前节点设置为前驱结点
后序线索化遍历思路
1、 先找到线索化的起始点
2、然后寻找当前结点的后继结点，并输出
3、如果当前节点是根节点就输出信息并返回
4、如果当前结点的右节点与前驱结点相同，输出当前结点信息并迭代孩子结点
5、获取右结点
  /**
     *二叉树进行后序线索化的方法
     * @param node 就是当前需要线索化的节点
     */
    public void postthreadedNodes(HeroNode 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);
        }else if (pre!=null && pre.getRight()!=null){
            pre.setChild(node);
        }
        // 每处理一个结点后，让当前结点是下一个结点的前驱结点
        pre  = node;
    }

后序线索化二叉树遍历

//后序遍历线索化二叉树
    public void postthreadedList(){
        //定义一个变量，存储当前遍历的结点，从root开始
        HeroNode node = root;
        HeroNode Prev = null;
        while (node != null){
            //循环的找到leftType == 1的结点
            //后面随着遍历而变化，因为leftType==1，说明该结点是按照线索化处理后的有效结点
            while (node.getLefttype() == 0){
                node = node.getLeft();
            }
            //如果当前结点的右指针指向的是后继结点，就一直输出
            while (node.getRighttype() == 1){
                println(node);
                Prev = node;
                //获取到当前结点的后继结点
                node = node.getRight();
            }
            if (node ==root){
                println(node);
                return;
            }
            while (node !=null && node.getRight()==Prev){
                println(node);
                Prev = node;
                //替换这个遍历的结点
                node  = node.getChild();
            }
            if(node!=null && node.getRighttype()==0) {
                node = node.getRight();
            }
        }
    }

测试

/**
 * 线索化二叉树
 */
public class ThreadedBinaryTreeDemo {
    public static void main(String[] args) {
        //中序遍历
        HeroNode root = new HeroNode(0, "tom");
        HeroNode node1 = new HeroNode(1, "jack");
        HeroNode node2 = new HeroNode(2, "smith");
        HeroNode node3 = new HeroNode(3, "mary");
        HeroNode node4 = new HeroNode(4, "king");
        HeroNode node5 = new HeroNode(5, "dim");
//        HeroNode node6 = new HeroNode(15, "tim");
        //二叉树创建
        root.setLeft(node1);
        root.setRight(node4);
//        node2.setLeft(node6);
        node1.setRight(node2);
        node2.setLeft(node3);
        node4.setRight(node5);
        //测试线索化
        ThreadBinaryTree threadBinaryTree = new ThreadBinaryTree();
        threadBinaryTree.setRoot(root);
        //后序遍历
        threadBinaryTree.postOrder();
        //线索化
//        threadBinaryTree.prethreadedNodes();
//        threadBinaryTree.middlethreadedNodes();
        threadBinaryTree.postthreadedNodes();


        //测试
        HeroNode nodeLeft = node3.getLeft();
        println("结点对的前驱结点： "+nodeLeft);
        HeroNode nodeRight = node3.getRight();
        println("结点对的后继结点： "+nodeRight);

//        println("使用线索化的方式先序遍历线索化二叉树");
//        threadBinaryTree.prethreadedList();
//
//        println("使用线索化的方式后序遍历线索化二叉树");
//        threadBinaryTree.middlethreadedList();

        println("使用线索化的方式后序遍历线索化二叉树");
        threadBinaryTree.postthreadedList();

    }
}
往事随风，浮生若梦
关注
  • 7
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
二叉树的后序线索化及遍历（Java）
weixin_43967331的博客
09-26 1182
这里把个人的代码记录下来，仅供各位同学参考，代码有不妥之处欢迎指正。 节点类 class HeroNode{ private int no; private String name; private HeroNode left; private HeroNode right; //子节点的类型，0为左子树，1为前驱节点 private int leftType; private int rightType; } 后序线索化 /** 后序线索化
java前序遍历_Java实现线索化二叉树并遍历（前序，中序，后序）
weixin_39822629的博客
02-20 184
/*** 线索化二叉树的节点*/public class IndexNode {public int id;public String name;public IndexNode left;public IndexNode right;public IndexNode parent = null; // 后序线索化的时候需要使用public boolean isLeftIndexed; // 0...
二叉树的前中后序遍历
最新发布
friendhan2005的博客
05-26 191
前中后序的实现
线索二叉树（C语言实现）——先序线索链表
Mr_John
11-04 1755
#include<stdio.h> #include<stdlib.h> #include<stdbool.h> typedef char DataType; // 标志域利用枚举常量来实现 typedef enum { Link, // Link(0)—指针 Thread // Thread(1)—线索 }flag; typedef struct TNode { DataType data; // 数据域 struct TNode * lc.
C++线索二叉树（先序/前序线索二叉树及遍历）
qq_58240448的博客
07-10 2463
使用c++实现 先序/前序线索二叉树及其先序遍历
数据结构——二叉树线索化遍历(前中后序遍历)
qq_58240849的博客
09-07 2264
二叉树线索化是一种将普通二叉树转换为具有特殊线索（指向前驱和后继节点）的二叉树的过程。这种线索化的目的是为了提高对二叉树的遍历效率，特别是在不使用递归或栈的情况下进行遍历。将二叉树线索化的主要目的是为了提高对二叉树的遍历效率以及节省存储空间。线索化使得在不使用递归或栈的情况下可以更快速地进行遍历，特别是在特定顺序的遍历时，如前序、中序或后序遍历。：线索化后，可以在常量时间内找到节点的前驱和后继节点，从而实现更高效的遍历。这对于需要频繁遍历大型二叉树或需要在树的中间部分执行插入和删除操作时特别有用。
非递归前序,中序,后序遍历二叉树(优化算法).rar_nooneyh_二叉树 非递归_前序 中序 后序_树遍历算法_遍历二叉树
09-14
对于二叉树的非递归遍历算法，除了优化栈空间使用之外，还有助于理解和实现其他数据结构，如线索二叉树，以及在实际问题中的应用，如序列化和反序列化二叉树。这些算法在面试中也经常被问到，是每个程序员应该掌握的...
二叉树的非递归建立，前序、中序、后序遍历
07-17
关于数据结构实验的二叉树问题
建立二叉树，并输出二叉树的先序，中序和后序遍历序列，以及二叉树的叶子数
07-11
[问题描述] 建立二叉树，并输出二叉树的先序，中序和后序遍历序列，以及二叉树的叶子数。 [基本要求] 要求根据读取的元素建立二叉树，能输出各种遍历。 [实现提示] 可通过输入带空格的前序序列建立二叉链表。
二叉树的基本操作，包括前序、中序、后序遍历的递归和非递归算法
10-21
本文将深入探讨二叉树的前序、中序、后序遍历的递归和非递归算法。 1. **前序遍历**： - **递归算法**：首先访问根节点，然后递归地对左子树进行前序遍历，最后对右子树进行前序遍历。伪代码如下： ``` function...
线索二叉树的先序、中序、后序遍历
dong18292000671的博客
05-07 1312
线索化二叉树： 当某个节点的左孩子为空时，将_pLeft指针指向他的前一个节点； 当某个节点的右孩子为空时，将_pRight指针指向它的后一个结点。根据遍历方式不同，得到的前后节点也不同，线索化二叉树分为三种不同的情况： 先序遍历线索化二叉树 中序遍历线索化二叉树 后序遍历线索化二叉树 线索二叉树与普通二叉树有什么区别呢？线索化二叉树中空的指针域至多2个，至少1个； 普通二叉树中空的指
二叉线索树的先序、中序、后序的线索化及其遍历
m0_43456002的博客
02-15 7830
线索二叉树 二叉线索树的概念 二叉线索树是在传统二叉树结构的基础上，加上判断结点左右孩子是否为空的标志–LTag,RTag。 当左孩子为空的时候，lchild指向该节点的前驱结点，当右孩子为空的时候，rchild指向该节点后继结点。以此提高链表的储存密度。下面我们给出二叉线索树的结构： typedef struct BiTNode { char data;//数据域 int LTa...
【数据结构·考研】后序线索二叉树
Jiawen9的博客
03-09 1672
后序线索二叉树c++实现
图解前序遍历线索化二叉树，前序线索二叉树遍历，C\C++描述
dfuw13072的博客
06-25 1683
body, table{font-family: 微软雅黑; font-size: 13.5pt} table{border-collapse: collapse; border: solid gray; border-width: 2px 0 2px 0;} th{border: 1p...
剑指 Offer 07. 重建二叉树 - python
javaisnotgood的博客
10-12 366
输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。 例如，给出 前序遍历 preorder =[3,9,20,15,7] 中序遍历 inorder = [9,3,15,20,7] 返回如下的二叉树： 3 / \ 9 20 / \ 15 7 思路：首先通过先序遍历序列可以得到树的根节点，然后在中序序列中找到根节点的位置，则以根节点为界限，向左到0,为左子树，向右到len() - 1 位右子树，然...
线索化二叉树的创建和遍历(前序、中序、后序)
m0_49039508的博客
05-31 1321
线索化二叉树的创建和遍历(前序、中序、后序) 什么是线索化二叉树？ 首先，n个结点的二叉链表中含有n+1 公式 2n-(n-1)=n+1 个空指针域。利用二叉链表中的空指针域，存放指向该结点在某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为"线索"） 在遍历结果中，一个结点的前一个结点，称为前驱结点 在遍历结果中，一个结点的后一个结点，称为后继结点 这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树(Threaded BinaryTree)。根据线索性质的不同，线索二叉树可分
数据结构（十七） -- C语言版 -- 树 - 二叉树的线索化及遍历 -- 先序线索化、中序线索化、后序线索化
热门推荐
青椒*^_^*凤爪爪的博客
06-20 2万+
在二叉树的结点上加上线索的二叉树称为线索二叉树，对二叉树以某种遍历方式（如先序、中序、后序或层次等）进行遍历，使其变为线索二叉树的过程称为对二叉树进行线索化。
数据结构之线索二叉树的前序,中序和后序遍历
微风
10-09 1万+
BinaryTree线索化二叉树      二叉树是一种非线性结构，在之前实现的二叉树遍历中不管是递归还是非递归用二叉树作为存储结构时只能取到该结点的左孩子和右孩子，不能得到该结点的前驱和后继。为了保存这种在遍历中需要的信息，同时也为了充分利用结点中的空指针域，我们利用二叉树中指向左右子树的空指针来存放结点的前驱和后继.同时在有n个结点的二叉链表中必定存在n+1个空链域.      那仫问题来
前序、中序、后序二叉树的线索化及遍历
优雅永不过时
06-25 1769
先看一个问题 将数列{1，3，6，8，10，14}构建成一颗二叉树 如图 问题分析： 1.当我们对上边的二叉树进行中序遍历时，数列为{8，3，10，1，14，6} 2.但是6，8，10，14这几个节点的左右指针并没有完全利用上 3.如果我们希望充分的利用各个节点的左右指针，让各个节点可以指向自己的前后节点怎么办 解决方法-线索二叉树 线索二叉树基本介绍 1.n个节点的二叉链表中含有n+1公式2n-(n-1)=n+1个空指针域。利用二叉链表中的空指针域，存放指向节点在某种遍历次序下的前驱和后继节点的指针（这种
算法笔记，二叉树的层序遍历||
03-19
二叉树有三种主要的遍历方式：前序遍历、中序遍历和后序遍历。本资料重点介绍了如何利用中序遍历和后序遍历的序列来构建原二叉树。 中序遍历的特点是从左到右依次访问左子树、根节点和右子树，而后序遍历则是先遍历...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值