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

news2024/11/25 14:33:33

二叉树

二叉树的概念

  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格式化地址信息

背景 最近在折腾一个好玩的库,capa 实现地址的格式化输出。我看的教程是这样的: location_str ["徐汇区虹漕路461号58号楼5楼", "泉州市洛江区万安塘西工业区"] import cpca df cpca.transform(location_str) df在正式的运行代码…

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

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

Maven【入门笔记】

Maven 解决版本依赖的问题 https://www.liaoxuefeng.com/wiki/1252599548343744/1309301146648610 如果没有项目管理工具,在开发项目的时候,我们需要手动管理依赖包,需要管理依赖包的版本、去找到并下载依赖包、还有依赖包所依赖的包 等等。…

解决微服务调用 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的小白以及准备秋…

一起学算法(栈篇)

1.栈的概念 1.栈的定义 栈是仅限在表尾进行插入和删除的线性表,栈又被称为先进后出的线性表,简称“LIFO” 我们这次用数组作为我们栈的底层数据结构,代码会放到结尾供大家参考使用 2.栈顶的定义 栈是一个线性表,我们允许插入…

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

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

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 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 翻转卡片游戏

目录 题目&#xff1a; 示例&#xff1a; 分析&#xff1a; 代码&#xff1a; 题目&#xff1a; 示例&#xff1a; 分析&#xff1a; 这道题不是什么翻转卡片游戏&#xff0c;这就是纯纯的文字游戏&#xff0c;要是能看懂题目那就是非常简单&#xff0c;接下来我就给大家分…

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

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

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

出现上图报错的原因是&#xff0c;前面elb配置了https证书&#xff0c;后端的nginx也配置了证书&#xff0c;导致冲突。 需要修改后端的nginx配置文件&#xff0c;将证书配置注释掉。 如果出现健康检查异常&#xff0c;需要在对应服务器的安全组上配置elb所在的网段的访问权限…

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

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

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有两个核心组件&#xff1a;ESXI&#xff0c;vCenter。ESXI实现的是单机虚拟化&#xff0c;而vCenter实现集群虚拟化&#xff0c;把所有的ESXI统一进行管理。当然了&#xff0c;要想是实现…

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

4 性能分析器 4.1 从 Run&#xff08;运行&#xff09;工具窗口使用分析功能 2023.2 中&#xff0c;可直接从 Run&#xff08;运行&#xff09;工具窗口轻松访问 IntelliJ 分析器的功能。 使用新按钮&#xff0c;点击即可调用&#xff1a; Attach IntelliJ Profiler&#xff…

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

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

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

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