Java之中序二叉树实现

最新推荐文章于 2022-02-22 15:08:17 发布
最新推荐文章于 2022-02-22 15:08:17 发布
阅读量166 收藏
点赞数
分类专栏： java 文章标签： 二叉树 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41347226/article/details/108393869
版权
这篇博客介绍了如何在Java中创建一个中序线索二叉树，包括HeroNode节点的定义，以及ThreadedBinaryTree类的实现，用于实现线索化二叉树的功能。文章通过main方法进行了测试。
摘要由CSDN通过智能技术生成

创建HeroNode 节点及方法

class HeroNode {
    private int no;
    private String name;
    private HeroNode left;//默认null
    private HeroNode right;//默认null
    //说明
    //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 int getRightType() {
        return rightType;
    }
    public void setRightType(int rightType) {
        this.rightType = rightType;
    }
    public HeroNode(int no, String name) {
        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;
    }
    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }
    //递归删除节点
    //1、如果删除的节点是叶子节点，则删除该节点
    //2、如果删除的节点是非叶子节点，则删除该子树
    public void delNode(int no) {
        /**
         * 思路
         * 1、因为我们的二叉树是单向的，所以我们是判断当前节点的子节点是否需要删除节点，
         * 而不能去判断当前这个节点是不是需要删除节点
         * 2、如果当前节点的左子节点不为空，并且左子节点就是要删除节点，就将this.left = null,并且返回
         * (结束递归删除)
         * 3、如果当前结束点的右子节点不为空，并且右子节点就是要删除节点，就将this.right=null,
         * 并且就返回(结束递归删除)
         * 4、如果第2和第3步没有删除节点，那么我们就需要向左子树进行递归删除
         * 5、如果第4步也没有删除节点，则应当向右子树进行递归删除
         */
        //2、如果当前节点的左子节点不为空，并且左子节点就是要删除节点，就将this.left = null,并且返回(结束递归删除)
        if (this.left != null && this.left.no == no) {
            this.left = null;
            return;
        }
        //3、如果当前结束点的右子节点不为空，并且右子节点就是要删除节点，就将this.right=null, 并且就返回(结束递归删除)
        if (this.right != null && this.right.no == no) {
            this.right = null;
            return;
        }
        //4、我们就需要向左子树进行递归删除
        if (this.left != null) {
            this.left.delNode(no);
        }
        //5、则应当向右子树进行递归删除
        if (this.right != null) {
            this.right.delNode(no);
        }
    }
    //编写前序遍历的方法
    public void perOrder() {
        System.out.println(this);//先输出父节点
        //递归向左子树前序遍历
        if (this.left != null) {
            this.left.perOrder();
        }
        //递归向右子树前序遍历
        if (this.right != null) {
            this.right.perOrder();
        }
    }
    //中序遍历
    public void infixOrder() {
        //递归向左子树中序遍历
        if (this.left != null) {
            this.left.infixOrder();
        }
        //输出父节点
        System.out.println(this);
        //递归向右子树中序遍历
        if (this.right != null) {
            this.right.infixOrder();
        }
    }
    //后序遍历
    public void postOrder() {
        if (this.left != null) {
            this.left.postOrder();
        }
        if (this.right != null) {
            this.right.postOrder();
        }
        System.out.println(this);
    }
    //前序遍历查找

    /**
     * @param no 查找no
     * @return 如果找到就返回该Node, 如果没有找到返回null
     */
    public HeroNode preOrderSearch(int no) {

        //比较当前节点是不是
        if (this.no == no) {
            return this;
        }
        //1、则判断当前节点的左子节点是否为空，如果不为空，则递归前序查找
        //2、如果左递归前序查找，找到节点，则返回
        HeroNode heroNode = null;
        if (this.left != null) {
            heroNode = this.left.preOrderSearch(no);
        }
        if (heroNode != null) {//说明我们左子树找到
            return heroNode;
        }
        //1、左递归前序查找，找到节点，则返回，否继续判断
        //2、当前的节点的右节点是否为空，如果不空，则继续向右递归前序查找
        if (this.right != null) {
            heroNode = this.right.preOrderSearch(no);
        }
        return heroNode;
    }
    //中序遍历查找
    public HeroNode infixOrderSearch(int no) {
        //判断当前节点的左子节点是否为空，如果不为空，则递归中序查找
        HeroNode heroNode = null;
        if (this.left != null) {
            heroNode = this.left.infixOrderSearch(no);
        }
        if (heroNode != null) {
            return heroNode;
        }
        //如果找到，则返回，如果没有找到，就和当前节点比较，如果是则返回当前节点
        if (this.no == no) {
            return this;
        }
        //否则继续进行右递归的中序查找
        if (this.right != null) {
            heroNode = this.right.infixOrderSearch(no);
        }
        return heroNode;
    }

    //后序遍历查找
    public HeroNode postOrderSearch(int no) {
        //判断当前节点的左子节点是否为空，如果不为空，则递归后序查找
        HeroNode heroNode = null;
        if (this.left != null) {
            heroNode = this.left.postOrderSearch(no);
        }
        if (heroNode != null) {//说明在左子树找到
            return heroNode;
        }
        //如果左子树没有找到，则向右子树递归进行后序遍历查找
        if (this.right != null) {
            heroNode = this.right.postOrderSearch(no);
        }
        if (heroNode != null) {
            return heroNode;
        }
        //如果左右子树都没有找到，就比较当前节点是不是
        if (this.no == no) {
            return this;
        }
        return heroNode;
    }
}

定义ThreadedBinaryTree 实现线索化功能的二叉树

class ThreadedBinaryTree {
    private HeroNode root;

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

    public void setRoot(HeroNode root) {
        this.root = 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());
        //②线索化当前节点(难度大)

        //处理当前节点的前驱节点
        //以8节点来理解
        //8节点的.left=null ,8节点的.leftType = 1
        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());
    }
    //删除节点
    public void delNode(int no) {
        if (root != null) {
            if (root != null) {
                //如果只有一个root节点，这里立即判断root是不是就是要删除节点
                if (root.getNo() == no) {
                    root = null;
                } else {
                    //递归删除
                    root.delNode(no);
                }
            } else {
                System.out.println("空时，不能删除");
            }
        }
    }
    //前序遍历
    public void preOrder() {
        if (this.root != null) {
            this.root.perOrder();
        } else {
            System.out.println("二叉树为空，无法遍历");
        }
    }
    //中序遍历
    public void infixOrder() {
        if (this.root != null) {
            this.root.infixOrder();
        } else {
            System.out.println("二叉树为空，无法遍历!");
        }
    }
    //后序遍历
    public void postOrder() {
        if (this.root != null) {
            this.root.postOrder();
        } else {
            System.out.println("二叉树为空，无法遍历！");
        }
    }
    //前序遍历
    public HeroNode preOrderSearch(int no) {
        if (root != null) {
            return root.preOrderSearch(no);
        } else {
            return null;
        }
    }
    //中序遍历
    public HeroNode infixOrderSearch(int no) {
        if (root != null) {
            return root.infixOrderSearch(no);
        } else {
            return null;
        }
    }

    //后序遍历
    public HeroNode postOrderSearch(int no) {
        if (root != null) {
            return root.infixOrderSearch(no);
        } else {
            return null;
        }
    }

}

main方法测试

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, "dim");

        //二叉树，后面我们递归创建，现在简单处理使用手动处理
        root.setLeft(node2);
        root.setRight(node3);
        node2.setLeft(node4);
        node2.setRight(node5);
        node3.setLeft(node6);

        //测试线索化
        ThreadedBinaryTree threadedBinaryTree = new ThreadedBinaryTree();
        threadedBinaryTree.setRoot(root);
        threadedBinaryTree.threadedNodes();

        //测试:以10号节点测试
        HeroNode leftNode = node5.getLeft();
        HeroNode rightNode = node5.getRight();
        System.out.println("10号节点的前驱节点是=" + leftNode);
        System.out.println("10号节点的后继节点是=" + rightNode);

        System.out.println("使用线索化的方式遍历 线索化二叉树");
        threadedBinaryTree.threadedList();
    }
蜗牛般的程序员
关注
专栏目录
Java实现二叉链表构建二叉树，实现相关功能
**My Coding Family**
07-23 967
ok，以上就是我这期的Bug修复内容啦，如果还想查找更多解决方案，你可以看看我专门收集Bug及提供解决方案的专栏《CSDN问答解惑-专业版》，都是实战中碰到的Bug，希望对你有所帮助。到此，咱们下期拜拜。码字不易，如果这篇文章对你有所帮助，帮忙给 bug菌 来个，您的支持就是我坚持写作分享知识点传播技术的最大动力。「猿圈奇妙屋」；
二叉树的遍历（前、中、后、层）
hi_siri的博客
11-17 383
二叉树的遍历二叉树代码前序遍历中序遍历后序遍历层序遍历推算遍历结果（知二求一） 二叉树代码 先展示二叉树的代码，此处的二叉树实现通过前序遍历加上补空的字符串来实现二叉树，具体代码如下： public class Tree { TreeNode root=null; class TreeNode<T>{//自定义二叉树结点类 T value; TreeNode left; TreeNode right; TreeNo
Java之二叉树前中后遍历
weixin_41347226的博客
09-01 186
先创建HeroNode 节点 public class HeroNode { private int no; private String name; private HeroNode left;//默认null private HeroNode right;//默认null public HeroNode(int no, String name) { this.no = no; this.name = name; }
Java数据结构和算法之二叉树的前中后遍历、前中后查找、删除
qq_43437122的博客
05-13 182
二叉树的概念： 1）树有很多种，每个节点最多只能有两个子节点的一种形式称为二叉树。 2）二叉树的子节点分为左节点和右节点。 3）如果该二叉树的所有叶子节点都在最后一层，并且结点总数= 2^n -1 , n 为层数，则我们称为满二叉树。 4）如果该二叉树的所有叶子节点都在最后一层或者倒数第二层，而且最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续，我们称为完全二叉树。 注意： 1）遍历的方法和原理估计大家都懂，这里不再赘述。代码里面有三种遍历方式的实现，认真看看就行了。 2）查找和遍历类似，只不
(java)二叉树的前中后序遍历
qq_39147389的博客
08-31 400
import java.util.LinkedList; import java.util.Queue; import java.util.Stack; public class 二叉树的前中后遍历 {     //建立二叉树结构     private static class Node {           Node leftChild;           Node rightChi...
java实现二叉树的前中后遍历（递归和非递归）
Crazer_cy的博客
02-25 299
这里使用下图的二叉树作为例子：首先建立树这个类：public class Node { private int data; private Node leftNode; private Node rightNode; public Node(int data, Node leftNode, Node rightNode) { this.data =...
数据结构之二叉树（JAVA实现）
weixin_38419670的博客
02-22 2014
1. 什么是二叉树 满足以下两个条件的树称之为二叉树： 1. 本质上为有序树； 2. 每个结点的度不能超过2，即结点的度仅能为0，1，2。 2. 二叉树的性质 性质1：二叉树第i层的结点数最多为2^(i-1) (i>=1)。 性质2：深度为k的二叉树最多有2^k - 1个结点。 性质3：在任意一颗二叉树中，若终端结点（叶子结点）的个数为n0，度为2的结点树为n2，则n0=n2+1。 证明：设二叉树中度为1的结点数为n1，结点总数为n，则n = n0 + n1 +n2。同时，度为2的子结
详解java实现遍历二叉树的三种情况
08-30
总结来说，Java中遍历二叉树的方法主要有前序、中序、后序以及层次遍历，其中层次遍历又包括正常层次遍历和之字形层次遍历。这些遍历方法都是二叉树算法设计中的基础，理解和掌握它们有助于解决各种复杂的问题。
java实现按层遍历二叉树
08-26
在Java编程中，二叉树是一种常见的数据结构，它由节点（或称为结点）构成，每个节点包含一个值，并可能有两个子节点：左子节点和右子节点。二叉树的操作之一是按层遍历，也称为层次遍历或宽度优先搜索（BFS）。这种...
java二叉树算法_Java实现二叉树基本算法
weixin_39654917的博客
02-16 648
二叉树遍历概念和算法遍历(Traverse)：所谓遍历(Traversal)是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。从二叉树的递归定义可知，一棵非空的二叉树由根结点及左、右子树这三个基本部分组成。因此，在任一给定结点上，可以按某种次序执行三个操作：⑴ 访问结点本身(D)，⑵ 遍历该结点的左子树(L)，⑶ 遍历该结点的右子树(R)。先序/根遍历DLR：根 左子树 ...
java二叉树前中后顺序遍历代码（递归）
小泰坦的博客
05-14 253
package test; import java.util.LinkedList; import java.util.List; public class BinTreeTraverse2 { private int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; private static List<Node> nodeList = null; /** * 内部类：节点 * * @author ocaicai@yeah.net @d
Java实现二叉树的遍历（多种方式实现前中后序的遍历）
Lover
05-29 489
二叉树的Node节点： public class Node { private char key ; private Node left ; private Node right ; public Node() { } public Node(char key){ this(key,null,null); } public Node(char key,Node
(Java)二叉树前中后遍历(递归)
weixin_45122262的博客
07-05 151
二叉树的前中后遍历,用递归的方法来写,代码是很容易的,只需短短的几行代码便可完成要求,不过理解递归思想才是最重要的,理解了递归思想,二叉树的前中后序的递归方法遍历便可迎刃而解 具体代码如下: leecode 144 二叉树的前序遍历 /** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * Tr
java树的遍历，前中后bfs dfs
xufeifandj的专栏
07-29 190
package com.example.lib; import java.util.ArrayDeque; import java.util.Queue; import java.util.Stack; import javax.swing.tree.TreeNode; public class TreeUtils { public static void main(String[] args) { // 1 // 2 3 // .
二叉树的前中后序遍历
MisterPan
10-26 300
二叉树的前中后遍历，其前中后，您可理解为指的是根结点所在的序。 前序遍历：前序遍历的顺序为根-左-右 中序遍历：中序遍历的顺序为左-根-右 后序遍历：后序遍历的顺序为左-右-根 1.前序遍历 思路：利用栈后进先出的特性。 1.根结点入栈； 2.循环取栈顶元素、右子结点入栈、左子结点入栈。 JAVA参考代码 public class TreeNode { int val; ...
二叉树前中后序遍历
小吕的博客
05-17 151
#include<iostream> #include<vector> #include<stack> #include<queue> using namespace std; struct TreeNode{ int val; TreeNode *left; TreeNode *right; TreeNode(int v) :val(v), left(NULL), right(NULL){} }; //-----------.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值