数据结构与算法十一：二叉树

分类：算法作者：编程之家用户

一、什么是二叉树

1.概述

首先，需要了解树这种数据结构的定义：

树：是一类重要的非线性数据结构，是以分支关系定义的层次结构。每个结点有零个或多个子结点；没有父结点的结点称为根结点；每一个非根结点有且只有一个父结点；除了根结点外，每个子结点可以分为多个不相交的子树

树的结构类似现实中的树，一个父节点有若干子节点，而一个子节点又有若干子节点，以此类推。

2.名词解释

名称 含义
根节点 树的顶端结点
父节点 若一个节点含有子节点，则这个节点称为其子节点的父节点
子节点 具有相同父节点的节点
兄弟节点 彼此都拥有同一个父节点的节点
叶子节点 即没有子节点的节点
节点的权 即节点值
路节点的度 一个节点含有的子树的个数
树的度 一棵树中，最大的节点的度称为树的度
深度 根结点到这个结点所经历的边的个数
层数 该节点的深度+1
高度 结点到叶子结点的最长路径所经历的边的个数
树高度 即根节点的高度
森林 由m（m>=0）棵互不相交的树的集合称为森林

3.二叉树

二叉树就是每个节点最多只有两颗子树的树：

对于二叉树有：

  • 满二叉树：所有的子节点都在最后一层，且节点总数与层数有节点总数=2^n-1

  • 完全二叉树：从根节点到倒数第二层都符合满二叉树，但是最后一层节点不完全充填，叶子结点都靠左对齐

二、二叉树的遍历

二叉树遍历分为三种：

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

可见，根据父节点输出顺序即可以判断是哪一种遍历。

1.简单代码实现

先创建节点类：

/**
 * @Author：黄成兴
 * @Date：2020-07-11 17:30
 * @Description：二叉树
 */
public class BinaryTreeNode {

    private int nodeNum;

    /**
     * 右子节点
     */
    private BinaryTreeNode right;

    /**
     * 左子节点
     */
    private BinaryTreeNode left;

    public BinaryTreeNode(int nodeNum) {
        this.nodeNum = nodeNum;
    }

    @Override
    public String toString() {
        return "BinaryTreeNode{" +
                "nodeNum=" + nodeNum +
                '}';
    }

    public int getNodeNum() {
        return nodeNum;
    }

    public void setNodeNum(int nodeNum) {
        this.nodeNum = nodeNum;
    }

    public BinaryTreeNode getRight() {
        return right;
    }

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

    public BinaryTreeNode getLeft() {
        return left;
    }

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

实现遍历方法：

/**
 * @Author：黄成兴
 * @Date：2020-07-11 17:44
 * @Description：二叉树
 */
public class BinaryTree {

    private BinaryTreeNode root;

    public BinaryTree(BinaryTreeNode root) {
        if (root == null) {
            throw new RuntimeException("根节点不允许为空！");
        }
        this.root = root;
    }

    public void preOrder(){
        preOrder(root);
    }
    /**
     * 前序遍历
     */
    public void preOrder(BinaryTreeNode node){
        //打印节点
        System.out.println(node);
        //向左子树前序遍历
        if (node.getLeft() != null) {
            preOrder(node.getLeft());
        }
        //向右子树前序遍历
        if (node.getRight() != null) {
            preOrder(node.getRight());
        }
    }

    public void inOrder(){
        inOrder(root);
    }
    /**
     * 中序遍历
     */
    public void inOrder(BinaryTreeNode node){
        //向左子树中序遍历
        if (node.getLeft() != null) {
            inOrder(node.getLeft());
        }
        //打印节点
        System.out.println(node);
        //向右子树中序遍历
        if (node.getRight() != null) {
            inOrder(node.getRight());
        }
    }

    public void postOrder(){
        postOrder(root);
    }
    /**
     * 后序遍历
     */
    public void postOrder(BinaryTreeNode node){
        //向左子树中序遍历
        if (node.getLeft() != null) {
            postOrder(node.getLeft());
        }
        //向右子树中序遍历
        if (node.getRight() != null) {
            postOrder(node.getRight());
        }
        //打印节点
        System.out.println(node);
    }
}

2.测试

对含有7个简单的满二叉树进行遍历的结果：

前序遍历：
BinaryTreeNode{nodeNum=1}
BinaryTreeNode{nodeNum=2}
BinaryTreeNode{nodeNum=4}
BinaryTreeNode{nodeNum=5}
BinaryTreeNode{nodeNum=3}
BinaryTreeNode{nodeNum=6}
BinaryTreeNode{nodeNum=7}
中序遍历：
BinaryTreeNode{nodeNum=4}
BinaryTreeNode{nodeNum=2}
BinaryTreeNode{nodeNum=5}
BinaryTreeNode{nodeNum=1}
BinaryTreeNode{nodeNum=6}
BinaryTreeNode{nodeNum=3}
BinaryTreeNode{nodeNum=7}
后序遍历：
BinaryTreeNode{nodeNum=4}
BinaryTreeNode{nodeNum=5}
BinaryTreeNode{nodeNum=2}
BinaryTreeNode{nodeNum=6}
BinaryTreeNode{nodeNum=7}
BinaryTreeNode{nodeNum=3}
BinaryTreeNode{nodeNum=1}

三、二叉树的查找

大体逻辑同遍历，这里就不在赘述了，直接放代码：

/**
 * 前序查找
 * @param num
 * @param node
 * @return
 */
public BinaryTreeNode preSearch(int num,BinaryTreeNode node){
    BinaryTreeNode result = null;

    //判断当前节点是否为查找节点
    if (node.getNodeNum() == num) {
        result = node;
    }
    //判断左节点是否为空，不为空就前序查找节点
    if (node.getLeft() != null) {
        result = preSearch(num,node.getLeft());
    }
    //如果左树找到就返回
    if (result != null){
        return result;
    }
    //否则就判断并递归前序查找右树
    if (node.getRight() != null) {
        result = preSearch(num,node.getRight());
    }
    return result;
}

/**
 * 中序查找
 * @param num
 * @param node
 * @return
 */
public BinaryTreeNode inSearch(int num,BinaryTreeNode node){
    BinaryTreeNode result = null;

    //判断左节点是否为空，不为空就中序查找节点
    if (node.getLeft() != null) {
        result = inSearch(num,node.getLeft());
    }
    //如果左树找到就返回
    if (result != null){
        return result;
    }
    //如果左树未找到就判断当前节点是不是
    if (node.getNodeNum() == num) {
        result = node;
    }
    //否则就判断并递归前序查找右树
    if (node.getRight() != null) {
        result = inSearch(num,node.getRight());
    }
    return result;
}

/**
 * 后序查找
 * @param num
 * @param node
 * @return
 */
public BinaryTreeNode postSearch(int num,BinaryTreeNode node){
    BinaryTreeNode result = null;

    //判断左节点是否为空，不为空就后序查找节点
    if (node.getLeft() != null) {
        result = postSearch(num,node.getLeft());
    }
    //如果左树找到就返回
    if (result != null){
        return result;
    }

    //否则就判断并递归后序查找右树
    if (node.getRight() != null) {
        result = postSearch(num,node.getRight());
    }
    //判断右树是否找到
    if (result != null){
        return result;
    }

    //如果右树仍未找到就判断当前节点是不是
    if (node.getNodeNum() == num) {
        result = node;
    }
    return result;
}

四、二叉树的删除

对于二叉树的删除，有以下逻辑：

  • 由于树的节点和节点之间的联系是单向的，对于要删除的节点，需要找到他的父节点进行删除
  • 从根节点开始遍历节点，判断节点的左右子节点是否为目标节点
  • 如果是就删除并返回
  • 否则就持续向右或左递归，直到找到目标节点，或者将树遍历完为止
/**
 * 删除节点
 * @param num
 * @param node
 * @return
 */
public void delete(int num,BinaryTreeNode node) {
    //判断删除的是否为根节点
    if (root.getNodeNum() == num) {
        throw new RuntimeException("不允许删除根节点！");
    }
    //如果子节点就是要删除的节点
    if (node.getLeft() != null && node.getLeft().getNodeNum() == num) {
        node.setLeft(null);
        return;
    }
    if (node.getRight() != null && node.getRight().getNodeNum() == num) {
        node.setRight(null);
        return;
    }
    //否则就往左树或右树遍历直到找到或遍历完为止
    if (node.getLeft() != null) {
        delete(num,node.getLeft());
    }
    if (node.getRight() != null) {
        delete(num,node.getRight());
    }
}

五、顺序存储二叉树

一般想到二叉树都会先想到较为形象的链式存储，即用含有左右指针的节点来组成树，实际上，通过计算，也可以使用数组来表示二叉树。

可以简单的理解：顺序存储二叉树是逻辑的上一棵树，而链式存储二叉树是物理上的一棵树。

以下图的树为例：

假设数组为{1,2,3,4,5,6,7,}，我们可以知道：

  • 下标为n的元素的左节点为：2*n+1
  • 下标为n的元素的右节点为：2*n+2
  • 下标为n的元素的父节点为：(n-1)/2

如果给顺序存储二叉树写一个前序遍历急就是这样：

/**
 * 前序遍历
 * @param index
 */
public void preOrder(int index) {
    //输出数组
    System.out.println(arr[index]);
    //向左递归
    if ((index * 2 + 1) < arr.length) {
        preOrder(index * 2 + 1);
    }
    //向右递归
    if ((index * 2 + 2) < arr.length) {
        preOrder(index * 2 + 2);
    }
}

在代码的实现上和链式二叉树是差不多的，这里就不再一一列举了。

当然，由于顺序存储二叉树的性质，当树需要排序的情况下，顺序存储二叉树就会出现空间浪费的情况：

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

负数原码与补码之间相互转换
背景：计算机内部用补码表示二进制数。符号位1表示负数，0表示正数。正数：无区别，正数 的原码= 反码 = 补码重点讨论负数若已知 负数 -8，则其原码为：1000 1000，（1为符号位，为1代表负数，为0代表正数）反码为：1111 0111，（符号位保持不变，其他位置按位取反）补码为：1111 1000，（反码 + 1）即在计算机中 用 1111 1000表示 -8若已知补码为 1111 1000，如何求其原码呢？（1）方法1：求负数 原码---&gt;补...
MD5 加密算法介绍
大家好,我们现在来讲解关于加密方面的知识,说到加密我认为不得不提MD5,因为这是一种特殊的加密方式,它到底特殊在哪,现在我们就开始学习它全称:message-digest algorithm 5翻译过来就是:信息 摘要 算法 5加密和摘要，是不一样的加密后的消息是完整的；具有解密算法，得到原始数据；摘要得到的消息是不完整的；通过摘要的数据，不能得到原始数据；所以，当看到很多人说，md5，加密，解密的时候，呵呵一笑就好了。MD5长度有人说md5,128位，32位，16位，到
新的快速排序算法: 《Dual-Pivot QuickSort》阅读笔记
相信大家在大学的《算法与数据结构》里面都学过快速排序(QuickSort), 知道这种排序的性能很好，JDK里面直到JDK6用的都是这种经典快排的算法。但是到了JDK7的时候JDK内置的排序算法已经由经典快排变成了Dual-Pivot排序算法。那么Dual-Pivot到底是何方圣神，能比我们学过的经典快排还要快呢？我们一起来看看。经典快排在学习新的快排之前，我们首先来复习一下经典快排，它的核心思想是:接受一个数组，挑一个数(pivot)，然后把比它小的那一摊数放在它的左边，把比它大的那一摊数放
对称加密与非对称加密
加密在编程中的应用的是非常广泛的，尤其是在各种网络协议之中，对称/非对称加密则是经常被提及的两种加密方式。对称加密我们平时碰到的绝大多数加密就是对称加密，比如：指纹解锁，PIN 码锁，保险箱密码锁，账号密码等都是使用了对称加密。对称加密：加密和解密用的是同一个密码或者同一套逻辑的加密方式。这个密码也叫对称秘钥，其实这个对称和不对称指的就是加密和解密用的秘钥是不是同一个。我在上大学的时候做过一个命令行版的图书馆管理系统作为 C 语言课设。登入系统时需要输入账号密码，当然，校验用户输入的密码
详解vue的diff算法
前言我的目标是写一个非常详细的关于diff的干货，所以本文有点长。也会用到大量的图片以及代码举例，目的让看这篇文章的朋友一定弄明白diff的边边角角。先来了解几个点...1. 当数据发生变化时，vue是怎么更新节点的？要知道渲染真实DOM的开销是很大的，比如有时候我们修改了某个数据，如果直接渲染到真实dom上会引起整个dom树的重绘和重排，有没有可能我们只更新我们修改的那一小块dom而不要更新整个dom呢？diff算法能够帮助我们。我们先根据真实DOM生成一颗virtual DOM，当v
对称加密算法
对称加密算法 所有的对称加密都有一个共同的特点：加密和解密所用的密钥是相同的。现代对称密码可以分为序列密码和分组密码两类：序列密码将明文中的每个字符单独加密后再组合成密文；而分组密码将原文分为若干个组，每个组进行整体加密，其最终加密结果依赖于同组的各位字符的具体内容。也就是说，分组加密的结果不仅受密钥影响，也会受到同组其他字符的影响。序列密码分组密码序列密码的安全性看上去要更弱一些，但是由于序列密码只需要对单个位进行操作，因此运行速度比分组加密要快...
RSA密钥长度、明文长度和密文长度
本文介绍RSA加解密中必须考虑到的密钥长度、明文长度和密文长度问题，对第一次接触RSA的开发人员来讲，RSA算是比较复杂的算法，RSA算法自己其实也很简单，RSA的复杂度是由于数学家把效率和安全也考虑进去的缘故。html本文先只谈密钥长度、明文长度和密文长度的概念知识，RSA的理论及示例等之后再谈。提到密钥，咱们不得不提到RSA的三个重要大数：公钥指数e、私钥指数d和模值n。这三个大数是咱们使用RSA时须要直接接触的，理解了本文的基础概念，即便未接触过RSA的开发人员也能应对自如的使用RSA相关函数库，
布隆过滤器(Bloom Filter)详解
直观的说，bloom算法类似一个hash set，用来判断某个元素（key）是否在某个集合中。和一般的hash set不同的是，这个算法无需存储key的值，对于每个key，只需要k个比特位，每个存储一个标志，用来判断key是否在集合中。算法：1. 首先需要k个hash函数，每个函数可以把key散列成为1个整数2. 初始化时，需要一个长度为n比特的数组，每个比特位初始化为03. 某个key加入集合时，用k个hash函数计算出k个散列值，并把数组中对应的比特位置为14. 判断某个key是否在集合时
如何防范密码被破解
你会用什么样的算法来为你的用户保存密码？如果你还在用明码的话，那么一旦你的网站被hack了，那么你所有的用户口令都会被泄露了，这意味着，你的系统或是网站就此完蛋了。所以，我们需要通过一些不可逆的算法来保存用户的密码。比如：MD5, SHA1, SHA256, SHA512, SHA-3,等Hash算法。这些算法都是不可逆的。系统在验证用户的口令时，需要把Hash加密过后的口令与后面存放口令的数据库中的口令做比较，如果一致才算验证通过。但你觉得这些算法好吗？我说的是：MD5, SHA1, SHA256,
Excel表格如何筛选重复内容筛选重复数据的方法
在日常工作中经常会使用excel，有时在表格中需要筛选出重复的数据，该怎么操作呢？1、以下图中的表格数据为例，筛选出列中重复的内容；2、打开文件，选中需要筛选的数据列，依次点击菜单项【开始】-【条件格式】-【突出显示单元格规则】-【重复值】；3、将重复的值突出颜色显示；4、选中数据列，点击【数据】-【筛选】；5、点击列标题的的下拉小三角，点击【按颜色筛选】，即可看到重复的数据；...
第三方接口联调加解密与签名验签
工作中经常有和第三方机构联调接口的事情，顾将用到过的做以记录。 在和第三方联调时，主要步骤为：网络、加解密/签名验签、接口数据等，其中接口数据没啥好说的。 在联调前就需要先将两边的网络连通，一般公司的生产环境都加了防火墙，测试环境有的是有防火墙，有的则没有防火墙，这个需要和第三方人员沟通，如果有防火墙的就需要将我们的出口ip或域名发送给第三方做配置，配置了之后网络一般都是通的。加解密与签名验签： 一般第三方公司都会有加解密或签名验签的，毕竟为了数据安全。一般就是三...
Spring Security安全框架中BCrypt强哈希加密算法使用
此文章不包含认证机制。任何应用考虑到安全，绝不能明文的方式保存密码。密码应该通过某种方式进行加密。如今已有很多标准的算法比如SHA或者MD5再结合salt(盐)使用是一个不错的选择。废话不多说！直接开始SpringBoot 中提供了Spring Security：BCryptPasswordEncoder类,实现Spring的PasswordEncoder接口使用BCrypt强哈希方法来加密密码。第一步：pom导入依赖：&lt;dependency&gt; &lt;groupId...
哈希加密详解和md5、sha1、sha256、Java 工具类
前言在所有的加密算法中使用最多的就是哈希加密了，很多人第一次接触的加密算法如MD5、SHA1都是典型的哈希加密算法，而哈希加密除了用在密码加密上，它还有很多的用途，如提取内容摘要、生成签名、文件对比、区块链等等。这篇文章就是想详细的讲解一下哈希加密，并分享一个哈希加密的工具类。概述哈希函数（Hash Function），也称为散列函数或杂凑函数。哈希函数是一个公开函数，可以将任意长度的消息M映射成为一个长度较短且长度固定的值H（M），称H（M）为哈希值、散列值（Hash Value）、杂凑值或者消息
[排序算法] 快速排序 (C++) (含三种写法)
#快速排序解释 快速排序 Quick Sort 与归并排序一样，也是典型的分治法的应用。 (如果有对 归并排序还不了解的童鞋，可以看看这里哟~ 归并排序)❤❤❤ ###快速排序的分治模式 1、选取基准
[排序算法] 堆排序 (C++)
#堆排序解释 ##什么是堆 堆 heap 是一种近似完全二叉树的数据结构，其满足一下两个性质 1. 堆中某个结点的值总是不大于(或不小于)其父结点的值； 2. 堆总是一棵完全二叉树 将根结点最大的堆叫
[排序算法] 希尔排序 (C++)
#前言 本文章是建立在插入排序的基础上写的喔，如果有对插入排序还有不懂的童鞋，可以看看这里。 ❤❤❤ 直接/折半插入排序 2路插入排序 ❤❤❤ #希尔排序解释 希尔排序 Shell Sort 又名&q
[排序算法] 归并排序 (C++)
#归并排序解释 归并排序 Merge Sort 是典型的分治法的应用，其算法步骤完全遵循分治模式。 ##分治法思想 分治法 思想: 将原问题分解为几个规模较小但又保持原问题性质的子问题，递归求解这些子
[排序算法] 双向冒泡排序 (C++)
#前言 本文章是建立在冒泡排序的基础上写的，如还有对 冒泡排序 不了解的童鞋，可以看看这里哦~ 冒泡排序 C++ #双向冒泡排序原理 双向冒泡排序 的基本思想与 冒泡排序还是一样的。冒泡排序 每次将相
[排序算法] 直接/折半插入排序 (C++)
#插入排序解释 插入排序很好理解，其步骤是 ：先将第一个数据元素看作是一个有序序列，后面的 n-1 个数据元素看作是未排序序列。对后面未排序序列中的第一个数据元素在这个有序序列中进行从后往前扫描，找到
[排序算法] 桶排序 (C++)
#桶排序解释 ##桶排序思想 桶排序 是一种空间换取时间的排序方式，是非基于比较的。 桶排序 顾名思义，就是构建多个映射数据的桶，将数据放入桶内，对每个桶内元素进行单独排序。假设我们有 n 个待排序的
pythonJavaScriptjavaHTMLPHPreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-boot