18 二叉树

最新推荐文章于 2024-07-13 16:00:03 发布
最新推荐文章于 2024-07-13 16:00:03 发布
阅读量317 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 算法 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/andyonlines/article/details/129104940
版权

文章目录

1 为什么需要树这种数据结构

1) 数组存储方式的分析
优点：通过下标方式访问元素，速度快。对于有序数组，还可使用二分查找提高检索速度。
缺点：如果要检索具体某个值，或者插入值(按一定顺序)会整体移动，效率较低 [示意图]画出操作示意图：

在这里插入图片描述
2) 链式存储方式的分析
优点：在一定程度上对数组存储方式有优化(比如：插入一个数值节点，只需要将插入节点，链接到链表中即可，删除效率也很好)。
缺点：在进行检索时，效率仍然较低，比如(检索某个值，需要从头节点开始遍历) 【示意图】操作示意图：

在这里插入图片描述
3) 树存储方式的分析
能提高数据存储，读取的效率, 比如利用 二叉排序树(Binary Sort Tree)，既可以保证数据的检索速度，同时也可以保证数据的插入，删除，修改的速度。【示意图,后面详讲】
案例: [7, 3, 10, 1, 5, 9, 12]

在这里插入图片描述

2 树示意图

在这里插入图片描述
在这里插入图片描述

3 二叉树的概念

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

在这里插入图片描述
4) 如果该二叉树的所有叶子节点都在最后一层，并且结点总数= 2^n -1 , n 为层数，则我们称为满二叉树。

在这里插入图片描述
5) 如果该二叉树的所有叶子节点都在最后一层或者倒数第二层，而且最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续，我们称为完全二叉树

在这里插入图片描述

4 二叉树的遍历

1) 前序遍历: 先输出父节点，再遍历左子树和右子树
2) 中序遍历: 先遍历左子树，再输出父节点，再遍历右子树
3) 后序遍历: 先遍历左子树，再遍历右子树，最后输出父节点
4) 小结: 看输出父节点的顺序，就确定是前序，中序还是后序

在这里插入图片描述

5 二叉树的遍历的代码实现

package tree;

/**
 * @author Andy
 * @email andy.gsq@qq.com
 * @date 2023/2/18 21:36:06
 * @desc 二叉树的演示
 */

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("前序遍历"); // 1,2,3,5,4
        binaryTree.preOrder();
        //测试
        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 HeroNode getRoot() {
        return root;
    }

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

    public BinaryTree() {
    }

    public BinaryTree(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("二叉树为空，无法遍历");
        }
    }

}

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

6 二叉树的遍历查找的代码实现

package tree;

/**
 * @author Andy
 * @email andy.gsq@qq.com
 * @date 2023/2/18 21:36:06
 * @desc 二叉树的演示
 */

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("前序遍历"); // 1,2,3,5,4
        binaryTree.preOrder();
        //测试
        System.out.println("中序遍历");
        binaryTree.infixOrder(); // 2,1,5,3,4
        //
        System.out.println("后序遍历");
        binaryTree.postOrder(); // 2,5,4,3,1


        //前序遍历
        //前序遍历的次数 ：4
        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);
        }

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

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

class BinaryTree {
    private HeroNode root;

    public HeroNode getRoot() {
        return root;
    }

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

    public BinaryTree() {
    }

    public BinaryTree(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("二叉树为空，无法遍历");
        }
    }

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

}

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

    /**
     * 前序遍历查找
     *
     * @param no 查找 no
     * @return 如果找到就返回该 Node ,如果没有找到返回 null
     */
    public HeroNode preOrderSearch(int no) {
        System.out.println("进入前序遍历");
        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;//说明我们左子树找到
        }

        //1.左递归前序查找，找到结点，则返回，否继续判断，
        //2.当前的结点的右子节点是否为空，如果不空，则继续向右递归前序查找

        if (this.right != null) {
            resNode = this.right.preOrderSearch(no);
        }

        return resNode;
    }

    /**
     * 前序遍历查找
     *
     * @param no 查找 no
     * @return 如果找到就返回该 Node ,如果没有找到返回 null
     */
    public HeroNode infixOrderSearch(int no) {
        System.out.println("进入前序遍历");

        //1.则判断当前结点的左子节点是否为空，如果不为空，则递归前序查找
        //2.如果左递归前序查找，找到结点，则返回
        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.当前的结点的右子节点是否为空，如果不空，则继续向右递归前序查找

        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;
        }
        return resNode;
    }
}
andyonlines
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树家谱
07-21
18、信息统计基本要求包括：平均身高，平均寿命，男女成员各多少，平均 家庭人口数目（假定每个成员构成一个家庭，该家庭的家庭成员是指成 员本人和他的孩子，即家庭人口数=孩子数+1）。要给出统计项的选择界 面....
基于51的DS18B20二叉树程序
11-20
基于DS18B20的单总线程序，采用二叉树的方式查找所有挂载在单总线上的DS18B20,对每一个DS18B20进行温度的读取，本程序为二叉树遍历DS18B20和单总线驱动程序
18 二叉树镜像
weixin_39964659的博客
04-18 92
18 二叉树镜像题目描述操作给定的二叉树，将其变换为源二叉树的镜像。输入描述:二叉树的镜像定义：源二叉树 8 / \ 6 10 / \ / \ 5 7 9 11 镜像二叉树 8 / \ 10 6 / \ / \ 11 9 7 5...
JZ18 二叉树的镜像
了凡
09-09 329
题目描述 操作给定的二叉树，将其变换为源二叉树的镜像。 输入描述: 思路 观察图像可知，全部左右节点交换即可，思路比较简单。 代码 /** public class TreeNode { int val = 0; TreeNode left = null; TreeNode right = null; public TreeNode(int val) { this.val = val; } } */ public class Solution
18 二叉树查找指定节点
朱古力的博客
06-17 415
二叉树查找指定节点 通过 前序遍历、中序遍历、后序遍历 在二叉树中查找符合条件的节点。 代码实现 public class BinaryTreeDemo { public static void main(String[] args) { // 手动构建二叉树 Node root = new Node(1); Node node2 = new Node(2); Node node3 = new Node(3);
18 二叉树：层次遍历
Ultravioletrays的博客
05-01 499
18二叉树：层次遍历 作者:冯向阳时间限制:1S章节:DS:树 截止日期:2022-06-30 23:55:00 问题描述 : 目的：使用C++模板设计并逐步完善二叉树的抽象数据类型（ADT）。 内容：（1）请参照链表的ADT模板，设计二叉树并逐步完善的抽象数据类型。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。参考教材、课件，以及网盘中的链表ADT原型文件，自行设计二叉树的ADT。） 注意：二叉...
day18 二叉树pt2
2401_84436813的博客
05-04 121
思路上难点是vector<vector<int >>result 的创建作用 思考后可以理解为树是一个大vector 每一行都是一个小vector 在这里面都是插入队列 表示每行的元素 队列保证元素都是有序输出的。3）对称二叉树的递归法比较好理解 就是罗列出啥情况flase 啥情况是true 一 一返回就完成 子节点非空继续 是空就结束。这道题看完解析就是一道简单题 主要问题是只要抓住反转的是左右孩子 在用迭代法遍历 之前调用一个swap就可以解决。1）首先是层序遍历二叉树。
Day18 二叉树part05
qq_44763553的博客
01-31 448
只会写迭代，就是层序遍历里面把tmp[0]输出就可以秒了。这个题可以改一下之前求所有路径的那个题，但是比较浪费？
Day18 二叉树 part05
xiaoantu的博客
11-26 424
Day18 二叉树 part05
代码随想录 Day18 二叉树
2302_77073236的博客
02-17 148
18二叉树的镜像
anqiu4023的博客
11-17 50
题目描述 操作给定的二叉树，将其变换为源二叉树的镜像。 输入描述:二叉树的镜像定义：源二叉树 8 / \ 6 10 / \ / \ 5 7 9 11 镜像二叉树 8 / \ 10 6 / \ / \ ...
JZ18 二叉树的镜像 Java
ChaoticNg的博客
10-28 253
题目描述 操作给定的二叉树，将其变换为源二叉树的镜像。 思路： 不要想得太多反而想复杂了，其实就把每个左右节点调换即可。 /** public class TreeNode { int val = 0; TreeNode left = null; TreeNode right = null; public TreeNode(int val) { this.val = val; } } */ public class Solutio.
ds18b20二叉树搜索算法.pdf
11-16
ds18b20二叉树搜索算法.pdf 这篇文章主要介绍了ds18b20二叉树搜索算法的原理和实现。下面是文章中提到的知识点： 1. 单总线技术：单总线技术是一种简单的三步操作过程的重复，即先读一位，接着读该位的反码，然后...
ds18b20二叉树搜索算法.doc
05-07
ds18b20 二叉树搜索算法 ds18b20 是一种单总线技术的温度传感器，单总线技术搜索 ROM 的过程是主设备获取单总线上从器件的注册码的过程。该过程是一个简单的三步操作过程的重复，即先读一位，其次读该位的反码，...
8张图详解电源二叉树
01-12
此次就给大家介绍一个电源二叉树分析实例。 电源二叉的树分析步骤： 寻源： 即找电源入口 顺藤摸瓜： 即顺着电源入口找到每路电源转换路径，直至找到使用此电源的终端（终负载）实例分析一路电源 图1示是电源...
数据结构 Java DS——链表部分经典题目 (1)
cjejwe的博客
07-09 679
笔者计划在暑假啃完JavaDS,Mysql的内容当然也会继续更这次给读者们分享的是链表的几个比较典型的题目,关于如何手搓一个链表,笔者还在筹划中,毕竟链表的种类也有那么多,但是在下面的题目中,只有单向链表。
数据结构和算法（0-1）----递归
yanminghe66666的博客
07-09 593
递归算法，爬楼梯等解法
二分查找和斐波那契查找
最新发布
weixin_50960004的博客
07-13 318
表面上看，后一调整存在风险，此时只能确定切分点arr[mid]＞target ，“贸然”地将arr[mi]排除在进一步的查找范围之外，似乎可能因遗漏这些元素，而导致本应成功的查找以失败告终。也就是说，无论朝哪个方向深入，都只需做1次元素的大小比较，其二，统一沿两个方向深入所需要执行的比较次数，比如都统一为一次。在有序向量中的查找，遇到重复的元素时会返回秩最大的那个，上述查找无法实现这个功能，因此加以改进。所以这样的话，想进入左半区间，进行一次比较，想进入右半区间，会进行两次比较，右侧比较会多。
代码随想录第十二天|226.翻转二叉树、 101.对称二叉树、104.二叉树的最大深度、111.二叉树的最小深度
semirc9的博客
07-09 752
二叉树

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值