【Java】二叉树解析

最新推荐文章于 2024-06-21 22:23:19 发布
最新推荐文章于 2024-06-21 22:23:19 发布
阅读量131 收藏 1
点赞数 6
分类专栏： 数据结构 文章标签： java 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45417714/article/details/134130385
版权

文章目录

二叉树的概念

  1. 树有很多种，每个节点最多只能有两个子节点的一种形式称为二叉树。

  2. 二叉树的子节点分为左节点和右节点

  3. 示意图

在这里插入图片描述

  1. 如果该二叉树的所有叶子节点都在最后一层，并且结点总数= 2^n -1 , n 为层数，则我们称为满二叉树。

在这里插入图片描述

  1. 如果该二叉树的所有叶子节点都在最后一层或者倒数第二层，而且最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续，我们称为完全二叉树

在这里插入图片描述

二叉树遍历的说明

使用前序，中序和后序对下面的二叉树进行遍历.

  1. 前序遍历: 先输出父节点，再遍历左子树和右子树

  2. 中序遍历: 先遍历左子树，再输出父节点，再遍历右子树

  3. 后序遍历: 先遍历左子树，再遍历右子树，最后输出父节点

  4. 小结: 看输出父节点的顺序，就确定是前序，中序还是后序

代码实现

package com.romanticlei.tree;

public class BinaryTreeDemo {
    public static void main(String[] args) {
        // 先创建一个二叉树
        BinaryTree binaryTree = new BinaryTree();
        HeroNode root = new HeroNode(1, "宋江");
        HeroNode node2 = new HeroNode(2, "吴用");
        HeroNode node3 = new HeroNode(3, "卢俊义");
        HeroNode node4 = new HeroNode(4, "林冲");
        HeroNode node5 = new HeroNode(5, "关胜");

        root.setLeft(node2);
        root.setRight(node3);
        node3.setRight(node4);
        node3.setLeft(node5);
        binaryTree.setRoot(root);

        System.out.println("测试前序遍历");
        binaryTree.preOrder(); // 1,2,3,5,4

        System.out.println("测试中序遍历");
        binaryTree.infixOrder(); // 2,1,5,3,4

        System.out.println("测试后序遍历");
        binaryTree.postOrder(); // 2,5,4,3,1

    }
}

class BinaryTree {
    private HeroNode root;

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

    // 前序遍历
    public void preOrder() {
        if (this.root == null) {
            System.out.println("二叉树为空，无法遍历");
            return;
        }

        this.root.preOrder();
    }

    // 中序遍历
    public void infixOrder() {
        if (this.root == null) {
            System.out.println("二叉树为空，无法遍历");
            return;
        }

        this.root.infixOrder();
    }

    // 后续遍历
    public void postOrder() {
        if (this.root == null) {
            System.out.println("二叉树为空，无法遍历");
            return;
        }

        this.root.postOrder();
    }
}

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;
    }

    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 + '\'' +
                '}';
    }

    // 遍历前序遍历的方法
    public void preOrder() {
        System.out.println(this); // 先输出父节点
        // 递归向左子树前序遍历
        if (this.left != null) {
            this.left.preOrder();
        }
        // 递归向右子树前序遍历
        if (this.right != null) {
            this.right.preOrder();
        }
    }

    // 遍历中序遍历的方法
    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);
    }
}
二叉树-查找指定节点

要求

  1. 请编写前序查找，中序查找和后序查找的方法。

  2. 并分别使用三种查找方式，查找 heroNO = 5 的节点

  3. 并分析各种查找方式，分别比较了多少次

  4. 思路分析图解

在这里插入图片描述

代码如下

package com.romanticlei.tree;

public class BinaryTreeDemo {
    public static void main(String[] args) {
        // 先创建一个二叉树
        BinaryTree binaryTree = new BinaryTree();
        HeroNode root = new HeroNode(1, "宋江");
        HeroNode node2 = new HeroNode(2, "吴用");
        HeroNode node3 = new HeroNode(3, "卢俊义");
        HeroNode node4 = new HeroNode(4, "林冲");
        HeroNode node5 = new HeroNode(5, "关胜");
        HeroNode node6 = new HeroNode(6, "玉麒麟");
        HeroNode node7 = new HeroNode(7, "鲁智深");

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

        System.out.println("测试前序遍历");
        binaryTree.preOrder(); // 1,2,3,5,4

        System.out.println("测试中序遍历");
        binaryTree.infixOrder(); // 2,1,5,3,4

        System.out.println("测试后序遍历");
        binaryTree.postOrder(); // 2,5,4,3,1

        // 前序遍历查找值
        System.out.println("前序遍历方式~~");
        HeroNode resNode = binaryTree.preOrderSearch(5);
        if (resNode != null) {
            // 查找编号为5 的数据，前序查找花费 4次
            System.out.printf("找到了，信息为 no = %d \t name = %s", resNode.getNo(), resNode.getName());
        }

        System.out.println();

        // 中序遍历查找值
        System.out.println("中序遍历方式~~");
        resNode = binaryTree.infixOrderSearch(5);
        if (resNode != null) {
            // 查找编号为5 的数据，中序查找花费 3次
            System.out.printf("找到了，信息为 no = %d \t name = %s", resNode.getNo(), resNode.getName());
        }

        System.out.println();

        // 后序遍历查找值
        System.out.println("后序遍历方式~~");
        resNode = binaryTree.postOrderSearch(5);
        if (resNode != null) {
            // 查找编号为5 的数据，后序查找花费 2次
            System.out.printf("找到了，信息为 no = %d \t name = %s", resNode.getNo(), resNode.getName());
        }
    }
}

class BinaryTree {
    private HeroNode root;

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

    // 前序遍历
    public void preOrder() {
        if (this.root == null) {
            System.out.println("二叉树为空，无法遍历");
            return;
        }

        this.root.preOrder();
    }

    // 中序遍历
    public void infixOrder() {
        if (this.root == null) {
            System.out.println("二叉树为空，无法遍历");
            return;
        }

        this.root.infixOrder();
    }

    // 后续遍历
    public void postOrder() {
        if (this.root == null) {
            System.out.println("二叉树为空，无法遍历");
            return;
        }

        this.root.postOrder();
    }

    // 前序遍历寻找目标值
    public HeroNode preOrderSearch(int no) {
        if (root != null) {
            return root.preOrderSeach(no);
        }
        return null;
    }

    // 中序遍历寻找目标值
    public HeroNode infixOrderSearch(int no) {
        if (root != null) {
            return root.infixOrderSearch(no);
        }
        return null;
    }

    // 后序遍历寻找目标值
    public HeroNode postOrderSearch(int no) {
        if (root != null) {
            return root.postOrderSearch(no);
        }
        return null;
    }
}

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;
    }

    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 + '\'' +
                '}';
    }

    // 遍历前序遍历的方法
    public void preOrder() {
        System.out.println(this); // 先输出父节点
        // 递归向左子树前序遍历
        if (this.left != null) {
            this.left.preOrder();
        }
        // 递归向右子树前序遍历
        if (this.right != null) {
            this.right.preOrder();
        }
    }

    // 遍历中序遍历的方法
    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);
    }

    // 前序遍历查找，如果没有就返回 null
    public HeroNode preOrderSeach(int no) {
        System.out.println("*********前序遍历查找*********");
        // 比较当前结点是不是需要查找的结点
        if (this.no == no) {
            return this;
        }

        // 判断当前结点的左子节点是否为空，如果不为空，则递归前序查找
        // 如果左递归前序查找，找到结点就返回
        HeroNode resNode = null;
        if (this.left != null) {
            resNode = this.left.preOrderSeach(no);
        }

        // 找到了直接返回结点
        if (resNode != null) {
            return resNode;
        }

        // 没有找到，继续判断当前结点的右结点是否为空，如果不空，继续右递归
        if (this.right != null) {
            resNode = this.right.preOrderSeach(no);
        }

        // 向右查找不管有没有找到都直接返回（有就是返回数据，没有就是返回 null）
        return resNode;
    }

    // 中序遍历查找
    public HeroNode infixOrderSearch(int no) {
        HeroNode resNode = null;
        if (this.left != null) {
            resNode = this.left.infixOrderSearch(no);
        }

        if (resNode != null) {
            return resNode;
        }

        System.out.println("*********中序遍历查找*********");
        if (this.no == no) {
            return this;
        }

        // 否则继续进行右递归
        if (this.right != null) {
            resNode = this.right.infixOrderSearch(no);
        }

        return resNode;
    }

    // 后序遍历
    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;
        }

        System.out.println("*********后序遍历查找*********");
        if (this.no == no) {
            return this;
        }

        // 如果都没有找到就返回 null
        return resNode;
    }
}

二叉树-删除节点及子树

要求

  1. 如果删除的节点是叶子节点，则删除该节点

  2. 如果删除的节点是非叶子节点，则删除该子树.

  3. 测试，删除掉 5 号叶子节点 和 3 号子树.

  4. 完成删除思路分析

在这里插入图片描述

代码实现

// 递归删除节点
// 1.如果删除的节点是叶子节点，则删除该节点
// 2.如果删除的节点是非叶子结点，则删除该子树
public void delAllNode(int no) {
    // 如果当前节点的左子节点不为空，并且左子节点就是要删除的节点，那么就将this.left = null，并且返回
    if (this.left != null && this.left.no == no) {
        this.left = null;
        return;
    }

    // 如果当前节点右子节点不为空，并且右子节点就是要删除节点，那么就将this.right = null，并且返回
    if (this.right != null && this.right.no == no) {
        this.right = null;
        return;
    }

    // 当前节点的左右节点都不是要删除的节点，需要向左子树进行递归
    if (this.left != null) {
        this.left.delAllNode(no);
    }

    // 当前节点的左右节点都不是要删除的节点，需要向右子树进行递归
    if (this.right != null) {
        this.right.delAllNode(no);
    }
}
ZL_Alvin
关注
  • 6
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java二叉树递归算法_java算法：递归二叉树算法
weixin_33026363的博客
02-20 316
java算法：递归二叉树算法二叉树的本质是递归结构，很多可以使用递归分治法完成的，推广了遍历算法。在只给定指向树的一个指针的前提下，经常需要找到树的各种结构参数的值。例1：树参数的计算，树的结点树和高度Java代码 privatestaticintcount(Nodeh){if(h==null){reutrn0;}returncount(h.l)+count(h.r)+1;}intcou...
二叉树 java泛型_java二叉树
weixin_36331336的博客
02-13 571
二叉树的非递归遍历二叉树的非递归遍历java的非递归后续遍历文章yichudu2014-04-04791浏览量Java工程师必知词汇：二叉树|名词定义|二叉树(Binary tree)是每个节点最多只有两个分支(即不存在分支度大于2的节点)的树结构。通常分支被称作“左子树”或“右子树”。二叉树的分支具有左右次序，不能随意颠倒。二叉树而言，在进行数据获取的时候也有三种形式：前序遍历(根-左-右)、中...
java二叉树详解_二叉树详解
weixin_28730131的博客
02-25 811
树是一种比较重要的数据结构，尤其是二叉树。二叉树是一种特殊的树，在二叉树中每个节点最多有两个子节点，一般称为左子节点和右子节点(或左孩子和右孩子)，并且二叉树的子树有左右之分，其次序不能任意颠倒。本篇博客将详细为大家解析二叉树。首先介绍两个概念：满二叉树：在一棵二叉树中，如果所有分支结点都有左孩子和右孩子结点，并且叶子结点都集中在二叉树的最下层，这样的树叫做满二叉树如：完全二叉树：若二叉树中最多只...
Java数据结构之深度解析二叉树
qq15035899256的博客
08-04 277
本文是Java数据结构的学习，认识了二叉树，以及二叉树的相关操作(前序、中序、后序、层序遍历)。之后的学习内容将持续更新！！！
Java中关于二叉树详解
dddddrrrzz的博客
01-10 3090
目录一、树形结构1.1 相关概念1.2树的表示形式1.3树的应用：文件系统管理（目录和文件）二、二叉树2.1相关概念2.2 二叉树的基本形态2.3 两种特殊的二叉树2.4 二叉树的性质2.5 二叉树的存储2.6 二叉树的基本操作2.6.1二叉树的遍历2.6.2 二叉树的基本操作总结 一、树形结构 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点： 有一个特殊的节点，称为根节点，
java二叉树算法面试题大全含答案，月薪20k+的Java面试都问些什么
2401_84413631的博客
04-23 900
21二叉树算法刷题LeetCode中文版：二叉树。
【二叉树 Java】二叉树的层序遍历
liuwanqing233333的博客
10-28 5182
二叉树层序遍历思路解析及Java代码
java二叉树面试题总结，挥泪整理面经
m0_57699613的博客
06-21 304
20个二叉树面试高频 0. 几个概念 1. 求二叉树中的节点个数 2. 求二叉树的最大层数(最大深度) 3. 先序遍历/前序遍历 4. 中序遍历 5. 后序遍历 6. 分层遍历 7. 求二叉树第K层的节点个数 8. 求二叉树第K层的叶子节点个数 9. 判断两棵二叉树是否结构相同 10. 判断二叉树是不是平衡二叉树 11. 求二叉树的镜像 12. 求二叉树中两个节点的最低公共祖先节点 13. 求二叉树的直径 14. 由前序遍历序列和中序遍历序列重建二叉树 15. 判断二叉树是不是完全二叉树 16. 树的子结
【Java】二叉树入门详解（包含二叉树0J练习解析）
热门推荐
意愿三七
06-05 3万+
目录一、 树型结构（了解）1.1 概念1.2 概念（重要）1.3 树的表示形式（了解）1.4 树的应用二、 二叉树的认识（重点）2.1 概念2.2 二叉树的基本形态2.3 两种特殊的二叉树2.4 二叉树的性质2.5 二叉树的存储2.6 二叉树的基本操作2.6.1 二叉树的遍历.2.6.2 二叉树的基本操作（1）前序遍历（2）中序遍历（3）后序遍历(4)遍历思路-求结点个数(5.)子问题思路-求结点个数(6)遍历思路-求叶子结点个数(7)子问题思路-求叶子结点个数(8)子问题思路-求第 k 层结点个数(9)获
java平衡二叉树左旋,Java 平衡二叉树之单旋（左旋，右旋）与双旋
weixin_28674303的博客
03-12 483
1.平衡二叉树平衡二叉树也叫平衡二叉搜索树(Self-balancing binary search tree)又被称为AVL树， 可以保证查询效率较高。具有以下特点：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。首先要明确的是，平衡二叉树是一棵二叉排序树，它的出现是为了解决普通二叉排序树(普通二叉排序树)不平衡的问题。如图，在插入结点之前首先要查找...
Java实现表达式二叉树
09-01
【Java实现表达式二叉树】是编程领域中一种数据结构的应用，主要用于处理数学表达式。在计算机科学中，二叉树是一种特殊的树形数据结构，每个节点最多有两个子节点，通常分为左子节点和右子节点。表达式二叉树，又...
mission2:在 Java 中使用二叉树解释和导出分析表达式
07-13
任务2 在 Java 中使用二叉树解释和导出分析表达式
java 数据结构二叉树的实现代码
09-01
在实际应用中，二叉树常用于搜索、排序、表达式解析等场景。例如，二叉搜索树（Binary Search Tree, BST）可以高效地执行查找、插入和删除操作；平衡二叉树如AVL树和红黑树则进一步优化了性能，确保了操作的平衡性和...
Java实现顺序栈原理解析
08-25
Java实现顺序栈原理解析 Java实现顺序栈原理解析是指使用Java语言实现顺序栈的...Java实现顺序栈原理解析有很多的应用场景，如子程序的调用、递归的调用、表达式的转换与求值、二叉树的遍历、图形的深度优先搜索等。
java创建树和解析树（支持二叉树）
04-11
NULL 博文链接：https://anyue100.iteye.com/blog/1678470
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 626
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
Day43
m0_67496588的博客
06-20 708
JSON，Ajax
Geoserver源码解读三 GeoServerBasePage
Yuanben_wuxin的博客
06-19 955
GeoServerBasePage 登录
Javase.认识异常
最新发布
Joseit的博客
06-21 1136
在Java开发中，异常处理是确保程序稳定性和可靠性的关键环节。这篇blog深入解析了Java异常的概念、体系、处理策略及自定义异常类。它介绍了异常的基本概念与分类，详细阐述了异常抛出、捕获与处理的最佳实践，包括防御式编程策略、try-catch结构的使用、以及finally块在资源清理中的作用。此外，还涵盖了自定义异常类以满足特定业务需求的重要性。通过学习本blog，读者可以深入理解Java异常处理机制，提升代码质量。
java 二叉树
05-26
以下是一个Java实现的简单二叉树示例： ```java public class BinaryTree { Node root; // 节点类 class Node { int data; Node left, right; public Node(int data) { this.data = data; left = right =...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值