【数据结构与算法】二叉树

news2024/9/22 4:00:58

二叉树

二叉树的概念

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

在这里插入图片描述

  1. 如果该二叉树的所有叶子节点都在最后一层，并且节点总数 = 2^n - 1，n 为层数，则我们称为满二叉树。
  2. 如果该二叉树的所有叶子节点都在最后一层或者倒数第二层，而且最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续，我们称为完全二叉树。
    在这里插入图片描述

二叉树的前序、中序和后序遍历

使用前序，中序，后序对二叉树进行遍历。

  • 前序遍历：先输出父节点，再遍历左子树和右子树。
  • 中序遍历：先遍历左子树，再输出父节点，再遍历右子树。
  • 后序遍历：先遍历左子树，再遍历右子树，最后输出父节点。

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

前序遍历

遍历步骤：

  1. 创建二叉树
  2. 前序遍历
    1. 先输出当前节点（初始的时候是root节点）
    2. 如果左子节点不为空，则递归继续前序遍历
    3. 如果右子节点不为空，则递归继续前序遍历

中序遍历

遍历步骤：

  1. 创建二叉树
  2. 中序遍历
    1. 如果当前节点的左子节点不为空，则递归中序遍历
    2. 输出当前节点
    3. 如果当前节点的右子节点不为空，则递归中序遍历

后序遍历

遍历步骤：

  1. 创建二叉树
  2. 后序遍历
    1. 如果当前节点的左子节点不为空，则递归后序遍历
    2. 如果当前节点的右子节点不为空，则递归后序遍历
    3. 输出当前节点

代码演示：

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.setLeft(node5);
        node3.setRight(node4);
        binaryTree.setRoot(root);

        // 测试
        System.out.println("前序遍历");
        binaryTree.preOrder();

        System.out.println("中序遍历");
        binaryTree.infixOrder();

        System.out.println("后序遍历");
        binaryTree.postOrder();

    }
}

// 定义 BinaryTree 二叉树
class BinaryTree {
    private HeroNode root;

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

    // 前序遍历
    public void preOrder() {
        if (this.root != null) {
            this.root.preOrder();
        } 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("二叉树为空，无法遍历");
        }
    }
}

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

    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. 先判断当前节点的 no 是否等于要查找的 no
  2. 如果相等，则返回当前节点
  3. 如果不等，则判断当前节点的左子节点是否为空，如果不为空，则递归前序查找
  4. 如果左递归前序查找，找到节点，则返回，否则继续判断，当前节点的右子节点是否为空，如果不为空，则继续向右递归前序查找

中序查找

查找步骤：

  1. 先判断当前节点的左子节点是否为空，如果不为空，则递归中序查找
  2. 如果找到，则返回；如果没有找到，就和当前节点比较，如果是，则返回当前节点，如果不是，继续进行右递归中序查找
  3. 如果右递归中序查找找到就返回，否则返回 null

后序查找

查找步骤：

  1. 判断当前节点的左子节点是否为空，如果不为空，则递归后序查找
  2. 如果找到，就返回，如果没有找到，就判断当前节点的右子节点是否为空，如果不为空，则右递归进行后序查找，如果找到，就返回
  3. 如果没有找到就和当前节点进行比较，如果是则返回，否则返回 null

代码演示：

主方法：

System.out.println("前序查找");
        HeroNode resNode1 = binaryTree.preOrderSearch(5);
        if (resNode1 != null) {
            System.out.printf("找到了，信息为 no=%d name=%s\n", resNode1.getNo(), resNode1.getName());
        } else {
            System.out.printf("没有找到 no=%d 的英雄\n", 5);
        }

        System.out.println("中序查找");
        HeroNode resNode2 = binaryTree.infixOrderSearch(4);
        if (resNode2 != null) {
            System.out.printf("找到了，信息为 no=%d name=%s\n", resNode2.getNo(), resNode2.getName());
        } else {
            System.out.printf("没有找到 no=%d 的英雄\n", 4);
        }

        System.out.println("后序查找");
        HeroNode resNode3 = binaryTree.postOrderSearch(3);
        if (resNode3 != null) {
            System.out.printf("找到了，信息为 no=%d name=%s\n", resNode3.getNo(), resNode3.getName());
        } else {
            System.out.printf("没有找到 no=%d 的英雄\n", 3);
        }

BinaryTree 类：

// 前序查找
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.postOrderSearch(no);
    } else {
        return null;
    }
}

HeroNode 类：

	/**
     * 前序查找
     *
     * @param no 查找的 no
     * @return 如果找到就返回该 Node，否则就返回 null
     */
    public HeroNode preOrderSearch(int no) {
        // 比较当前节点
        if (this.no == no) {
            return this;
        }
        // 1. 判断当前节点的左子节点是否为空，如果不为空，则递归前序查找
        // 2. 如果左递归前序查找，找到节点，则返回
        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;
    }

    /**
     * 中序查找
     *
     * @param no 查找的 no
     * @return 如果找到就返回该 Node，否则就返回 null
     */
    public HeroNode infixOrderSearch(int no) {
        // 判断当前节点的左子节点是否为空，如果不为空，则递归中序查找
        HeroNode resNode = null;
        if (this.left != null) {
            resNode = this.left.infixOrderSearch(no);
        }
        if (resNode != null) {
            return resNode;
        }
        // 如果没有找到，就和当前节点比较
        if (this.no == no) {
            return this;
        }
        // 1. 继续进行右递归中序查找
        // 2. 如果右递归中序查找找到就返回，否则返回 null
        if (this.right != null) {
            resNode = this.right.infixOrderSearch(no);
        }
        return resNode;
    }

    /**
     * 后序查找
     *
     * @param no 查找的 no
     * @return 如果找到就返回该 Node，否则就返回 null
     */
    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;
        }
        // 和当前节点进行比较，如果是则返回，否则返回 null
        if (this.no == no) {
            return this;
        }
        return resNode;
    }

删除节点

要求：

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

思路：

  1. 首先，考虑如果树是空树 root，如果只有一个 root 节点，则等价将二叉树置空。
  2. 因为我们的二叉树是单向的，所以我们判断当前节点的子节点是否需要删除节点，而不能去判断当前这个节点是不是需要删除的节点。
  3. 如果当前节点的左子节点不为空，并且左子节点及时需要删除的节点，就将 this.left = null；并且返回（结束递归删除）。
  4. 如果当前节点的右子节点不为空，并且右子节点及时需要删除的节点，就将 this.right = null；并且返回（结束递归删除）。
  5. 如果第 3 步和第 4 步没有删除节点，那么我们就需要向左子树进行递归删除。
  6. 如果第 5 步也没有删除节点，那么我们就需要向右子树进行递归删除。

代码演示：

主方法：

 		System.out.println("删除前");
        binaryTree.preOrder();
        binaryTree.delNode(5);
        System.out.println("删除后");
        binaryTree.preOrder();

BinaryTree 类：

    // 删除节点
    public void delNode(int no) {
        if (root != null) {
            // 如果只有一个 root 节点，这里立即判断 root 是不是就是要删除的节点
            if (root.getNo() == no) {
                root = null;
            } else {
                // 递归删除
                root.delNode(no);
            }
        } else {
            System.out.println("空树，不能删除~");
        }
    }

HeroNode 类：

    /**
     * 递归删除节点
     * 1. 如果删除的节点是叶子结点，则删除该节点
     * 2. 如果删除的节点是非叶子节点，则删除该子树
     *
     * @param no 需要删除的 no
     */
    public void delNode(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;
        }
        // 如果第 3 步和第 4 步没有删除节点，那么我们就需要向左子树进行递归删除。
        if (this.left != null) {
            this.left.delNode(no);
        }
        // 如果第 5 步也没有删除节点，那么我们就需要向右子树进行递归删除。
        if (this.right != null) {
            this.right.delNode(no);
        }
    }

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/824382.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

python格式化地址信息

python格式化地址信息

背景 最近在折腾一个好玩的库，capa 实现地址的格式化输出。我看的教程是这样的： location_str ["徐汇区虹漕路461号58号楼5楼", "泉州市洛江区万安塘西工业区"] import cpca df cpca.transform(location_str) df在正式的运行代码…
阅读更多...
SI24R2H 2.4G+125K中长跑应用原理

SI24R2H 2.4G+125K中长跑应用原理

一、中长跑计时系统应用背景 采用125KHZ低频唤醒高频射频识别系统和先进的技术、计算机信息处理等高新技术与体育竞赛相结合，便于运动员携带而不影响其跑步状态，当运 动员带着射频识别卡经过计时线圈时，读卡天线能够立即检测到通过的卡片信息…
阅读更多...
Maven【入门笔记】

Maven【入门笔记】

Maven 解决版本依赖的问题 https://www.liaoxuefeng.com/wiki/1252599548343744/1309301146648610 如果没有项目管理工具，在开发项目的时候，我们需要手动管理依赖包，需要管理依赖包的版本、去找到并下载依赖包、还有依赖包所依赖的包 等等。…
阅读更多...
解决微服务调用 file文件传递出现的 Current request is not a multipart request 问题

解决微服务调用 file文件传递出现的 Current request is not a multipart request 问题

在单体服务中通过使用RequestParam(“file”) MultipartFile multipartFile方式接收文件是没有问题的 多服务传递,如端层到服务层,上述方式就会出现Current request is not a multipart request问题 解决Current request is not a multipart request问题的步骤 将 RequestPar…
阅读更多...
Java虚拟机在类加载阶段都做了些什么，才使得我们可以运行Java程序

Java虚拟机在类加载阶段都做了些什么，才使得我们可以运行Java程序

前言： 今天和大家探讨一道Java中经典的面试题，这道面试题经常出现在各个公司的面试中，结合周志明，老师的《深入理解Java虚拟机》书籍，本篇文章主要讲解Java类加载机制的知识。该专栏比较适合刚入坑Java的小白以及准备秋…
阅读更多...
一起学算法（栈篇）

一起学算法（栈篇）

1.栈的概念 1.栈的定义 栈是仅限在表尾进行插入和删除的线性表，栈又被称为先进后出的线性表，简称“LIFO” 我们这次用数组作为我们栈的底层数据结构，代码会放到结尾供大家参考使用 2.栈顶的定义 栈是一个线性表，我们允许插入…
阅读更多...
I-STARIS国际演艺集团五洲女子组合练习生2023年度考核开启

I-STARIS国际演艺集团五洲女子组合练习生2023年度考核开启

I-STARIS国际演艺集团五洲女子组合举行了年度考核，从演员的形象管理、表演技巧、才艺水平及中文语言功底等多方面维度来评定。他们非常认真对待，通过不断的努力学习持续提升自己。 作为一年一度的年度考核，大家都非常紧张，除了专业…
阅读更多...
tomcat限制IP访问

tomcat限制IP访问

tomcat可以通过增加配置&#xff0c;来对来源ip进行限制&#xff0c;即只允许某些ip访问或禁止某些来源ip访问。 配置路径&#xff1a;server.xml 文件下 标签下。与同级 <Valve className"org.apache.catalina.valves.RemoteAddrValve" allow"192.168.x.x&…
阅读更多...
企业工程管理系统源码-数字化可视化项目管理平台

企业工程管理系统源码-数字化可视化项目管理平台

工程项目各模块及其功能点清单 一、系统管理 1、数据字典&#xff1a;实现对数据字典标签的增删改查操作 2、编码管理&#xff1a;实现对系统编码的增删改查操作 3、用户管理&#xff1a;管理和查看用户角色 4、菜单管理&#xff1a;实现对系统菜单的增删改查操…
阅读更多...
(一)基于Spring Reactor框架响应式异步编程|道法术器

(一)基于Spring Reactor框架响应式异步编程|道法术器

Spring WebFlux 响应式异步编程|道法术器(一) Spring WeFlux响应式编程整合另一种方案|道法术器(二) R2DBC简介 Spring data R2DBC是更大的Spring data 系列的一部分&#xff0c;它使得实现基于R2DBC的存储库变得容易。R2DBC代表反应式关系数据库连接&#xff0c;这是一种使用…
阅读更多...
网络四元组

网络四元组

问题描述与解释 四元组&#xff0c;简单理解就是在 TCP 协议中&#xff0c;去确定一个客户端连接的组成要素&#xff0c;它包括 1、源 IP 地址 2、目标 IP 地址 3、源端口号 4、目标端口号 正常情况下&#xff0c;我们对于网络通信的认识可能是这样&#xff08;如图&#xff09…
阅读更多...
【力扣每日一题】2023.8.2 翻转卡片游戏

【力扣每日一题】2023.8.2 翻转卡片游戏

目录 题目&#xff1a; 示例&#xff1a; 分析&#xff1a; 代码&#xff1a; 题目&#xff1a; 示例&#xff1a; 分析&#xff1a; 这道题不是什么翻转卡片游戏&#xff0c;这就是纯纯的文字游戏&#xff0c;要是能看懂题目那就是非常简单&#xff0c;接下来我就给大家分…
阅读更多...
相机存储卡数据恢复，掌握这2个方法就够啦！

相机存储卡数据恢复，掌握这2个方法就够啦！

“上次和朋友出去旅游拍了好多好看的视频和照片&#xff0c;都特别有纪念意义。但将相机存储卡插入电脑后&#xff0c;很多照片和视频都消失了&#xff0c;怎么恢复相机存储卡里照片呢&#xff1f;求帮助&#xff01;” 对于喜欢拍摄的朋友来说&#xff0c;相机的存储卡真的是个…
阅读更多...
elb 直接配置到后端服务器组

elb 直接配置到后端服务器组

出现上图报错的原因是&#xff0c;前面elb配置了https证书&#xff0c;后端的nginx也配置了证书&#xff0c;导致冲突。 需要修改后端的nginx配置文件&#xff0c;将证书配置注释掉。 如果出现健康检查异常&#xff0c;需要在对应服务器的安全组上配置elb所在的网段的访问权限…
阅读更多...
不同USB口上的颜色各有什么含义和区别？

不同USB口上的颜色各有什么含义和区别？

在生活中&#xff0c;当我们仔细观察手机、电视、电脑、音箱等电子设备时&#xff0c;就会发现USB端口的颜色有很多。单纯的你可能会认为只是为了好看&#xff0c;实际上不同的颜色代表着不同性能。 01.USB接口的概念 USB通用串行总线&#xff08;Universal Serial Bus&#x…
阅读更多...
JVM内存模型【入门】

JVM内存模型【入门】

计算机结构简图 JVM内存模型 详细说明&#xff1a;https://blog.csdn.net/m0_71777195/article/details/126247090 什么是JVM&#xff1f; JVM是Java Virtual Machine&#xff08;Java虚拟机&#xff09;的缩写&#xff0c;JVM是一个虚构出来的计算机&#xff0c;有着自己完善…
阅读更多...
VMware vSphere整体解决方案及实验拓扑

VMware vSphere整体解决方案及实验拓扑

VMware vSphere整体解决方案及实验拓扑 VMware vSphere完整的解决方案 VMware vSphere有两个核心组件&#xff1a;ESXI&#xff0c;vCenter。ESXI实现的是单机虚拟化&#xff0c;而vCenter实现集群虚拟化&#xff0c;把所有的ESXI统一进行管理。当然了&#xff0c;要想是实现…
阅读更多...
IntelliJ IDEA 2023.2新特性详解第二弹！

IntelliJ IDEA 2023.2新特性详解第二弹！

4 性能分析器 4.1 从 Run&#xff08;运行&#xff09;工具窗口使用分析功能 2023.2 中&#xff0c;可直接从 Run&#xff08;运行&#xff09;工具窗口轻松访问 IntelliJ 分析器的功能。 使用新按钮&#xff0c;点击即可调用&#xff1a; Attach IntelliJ Profiler&#xff…
阅读更多...
基于“RWEQ+”集成技术在土壤风蚀模拟与风蚀模数估算、变化归因分析中的应用

基于“RWEQ+”集成技术在土壤风蚀模拟与风蚀模数估算、变化归因分析中的应用

土壤风蚀是一个全球性的环境问题。中国是世界上受土壤风蚀危害最严重的国家之一&#xff0c;土壤风蚀是中国干旱、半干旱及部分湿润地区土地荒漠化的首要过程。中国风蚀荒漠化面积达160.74104km2&#xff0c;占国土总面积的16.7%&#xff0c;严重影响这些地区的资源开发和社会经…
阅读更多...
Linux【网络基础】之宏观认识

Linux【网络基础】之宏观认识

文章目录 一、计算机网络背景二、计算机网络协议&#xff08;1&#xff09;网络协议的概念&#xff08;2&#xff09;协议分层&#xff08;3&#xff09;数据封装与分用&#xff08;4&#xff09;地址管理 一、计算机网络背景 学习计算机网络我们首先要有宏观的认识&#xff0…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023