数据结构-二叉树

已于 2022-06-13 20:34:54 修改
阅读量126 收藏
点赞数
分类专栏： Java 数据结构与算法 文章标签： 数据结构 二叉树
于 2021-10-24 14:02:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yao_wen_yu/article/details/120906354
版权

文章目录

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

  • 数组存储方式分析
    • 优点：通过下标的方式访问元素,速度快。对于有序数组，还可以使用二分查找提高检索速度。
    • 缺点：如果要检索具体某一个值，或者插入值（按一定顺序）会整体移动，效率极低 【示意图】

在这里插入图片描述

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

在这里插入图片描述

  • 树存储方式分析
    能提高数据存储，读取的效率，比如利用二叉排序树，既可以保证数据的检索速度，同时也能保证数据的插入、删除、修改的速度 【示意图】

在这里插入图片描述

  • 树示意图

在这里插入图片描述
树的常用术语

-  节点
-  根节点
- 父节点
- 子节点
- 叶子节点(没有子节点的节点)
- 节点的权(节点值)
- 路径(从 root 节点到该节点的路线)
- 层
- 子树
- 树的高度(最大层数)
- 森林：多棵子树构成森林

2、二叉树的概念

  • 二叉树的概念

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

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

    3. 示意图
      在这里插入图片描述

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

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

3、 二叉树的遍历说明

使用前序、中序和后序进行二叉树的遍历

1. 前序遍历：先输入父节点，再遍历左子树和右子树
2. 中序遍历：先遍历左子树，再输出父节点，在遍历右子树
3. 后序遍历：先遍历左子树，再遍历右子树，再输出父节点

💻 代码实现

package com.yao.tree;

/**
 * @Author: Yao
 * @Date: 2021/10/19 11:30
 */
public class BinaryTreeErgodic {
    public static void main(String[] args) {

        //定义二叉树
        BinaryTree binaryTree = new BinaryTree();

        HeroNode root = new HeroNode(1, "宋江");
        HeroNode heroNode2 = new HeroNode(2, "吴用");
        HeroNode heroNode3 = new HeroNode(3, "卢俊义");
        HeroNode heroNode4 = new HeroNode(4, "林冲");
        HeroNode heroNode5 = new HeroNode(5, "关胜");
        binaryTree.setRoot(root);
        root.setLeft(heroNode2);
        root.setRight(heroNode3);
        heroNode3.setLeft(heroNode5);
        heroNode3.setRight(heroNode4);

        System.out.println("先序遍历..");
        binaryTree.preOrder();

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

        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 midOrder(){
        if (this.root != null){
            this.root.midOrder();
        }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 midOrder(){
        //如果当前节点的左子树不为空，递归中序遍历
        if (this.left != null){
            this.left.midOrder();
        }
        //输出当前节点
        System.out.println(this);
        //如果当前节点的右子树不为空，递归中序遍历
        if(this.right != null){
            this.right.midOrder();
        }
    }

    /**
     * 二叉树的后序遍历
     */
    public void postOrder(){
        //如果当前节点的左子树不为空，递归后序遍历
        if (this.left != null){
            this.left.postOrder();
        }
        //如果当前节点的右子树不为空，递归后序遍历
        if (this.right != null){
            this.right.postOrder();
        }
        //输出当前节点
        System.out.println(this);
    }

}

4、 二叉树查找指定节点

  • 编写前序查找、中序查找、后序查找的方法
  • 分别使用三种查找方式，查找 heroNo = 5 的节点
  • 分析三种查找方式
  • 思路分析图解

在这里插入图片描述

💻 代码实现

package com.yao.tree;

/**
 * @Author: Yao
 * @Date: 2021/10/20 9:48
 */
public class BinaryTreeSearch {
    public static void main(String[] args) {
        BinaryTree2 binaryTree2 = new BinaryTree2();
        HeroNode2 root = new HeroNode2(1, "宋江");
        HeroNode2 heroNode2 = new HeroNode2(2, "吴用");
        HeroNode2 heroNode3 = new HeroNode2(3, "卢俊义");
        HeroNode2 heroNode4 = new HeroNode2(4, "林冲");
        HeroNode2 heroNode5 = new HeroNode2(5, "关胜");
        binaryTree2.setRoot(root);
        root.setLeft(heroNode2);
        root.setRight(heroNode3);
        heroNode3.setLeft(heroNode5);
        heroNode3.setRight(heroNode4);

        //先序遍历查找 no=5
        System.out.println(binaryTree2.preSearch(5));
        //中序遍历查找 no=5
        System.out.println(binaryTree2.midSearch(5));
        //后序遍历查找 no=5
        System.out.println(binaryTree2.postSearch(5));

    }
}

//创建一颗二叉树
class BinaryTree2{
    private HeroNode2 root;

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

    //二叉树前序查找
    public HeroNode2 preSearch(int no){

        if (this.root != null){
            return this.root.preOrderSearch(no);
        }else{
            System.out.println("该二叉树为空.....");
            return null;
        }
    }

    //二叉树中序查找
    public HeroNode2 midSearch(int no){
        if (this.root != null){
            return this.root.midOrderSearch(no);
        }else{
            System.out.println("该二叉树为空.....");
            return null;
        }
    }

    //二叉树后序查找
    public HeroNode2 postSearch(int no){
        if (this.root != null){
            return this.root.postOrderSearch(no);
        }else{
            System.out.println("该二叉树为空.....");
            return null;
        }
    }


}


//创建二叉树的节点
class HeroNode2{

    private  int no;

    private String name;

    private HeroNode2 left;

    private HeroNode2 right;

    public HeroNode2(int no, String name){
        this.no = no;
        this.name = name;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public void setName(String name) {
        this.name = name;
    }

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

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

    public int getNo() {
        return no;
    }

    public String getName() {
        return name;
    }

    public HeroNode2 getLeft() {
        return left;
    }

    public HeroNode2 getRight() {
        return right;
    }

    @Override
    public String toString() {
        return "HeroNode2{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }


    //二叉树的前序查找
    public HeroNode2 preOrderSearch(int no){
        HeroNode2 resNode = null;
        //判断当前节点是否是要查找的节点，如果是就返回
        System.out.println("进入先序查找遍历....");
        if (this.no == no){
            return this;
        }
        //如果不是，就判断当前节点的左子树是否为空，不为空就进行先序递归，如果找到就返回
        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;

    }

    //二叉树的中序查找
    public HeroNode2 midOrderSearch(int no){
        HeroNode2 resNode = null;
        //先判断当前节点的左子树是否为空，如果不为空，就进行中序递归，找到就返回
        if (this.left != null){
            resNode = this.left.midOrderSearch(no);
        }
        if (resNode != null){
            return resNode;
        }
        //当前节点的左子树没有找到，就与当前节点进行比较，找到就返回
        System.out.println("进入中序查找遍历....");
        if (this.no == no){
            return this;
        }
        //当前节点没有找到，就判断当前节点的右子树是否为空，不为空就进行中序递归，找到就返回
        if (this.right != null){
            resNode = this.right.midOrderSearch(no);
        }
        return resNode;
    }

    //二叉树的后序查找
    public HeroNode2 postOrderSearch(int no){
        HeroNode2 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);
        }
        //当前节点的右子树没有找到，就与当前节点进行比较
        System.out.println("进入后序查找遍历....");
        if (this.no == no){
            return this;
        }

        return resNode;
    }

}

5、 二叉树删除节点

  • 如果删除的节点是叶子节点，则删除该节点
  • 如果删除的节点是非叶子节点，则删除该子树.
  • 删除思路分析

在这里插入图片描述

💻 代码实现

package com.yao.tree;

/**
 * @Author: Yao
 * @Date: 2021/10/19 11:30
 */
public class BinaryTreeErgodic {
    public static void main(String[] args) {

        //定义二叉树
        BinaryTree binaryTree = new BinaryTree();

        HeroNode root = new HeroNode(1, "宋江");
        HeroNode heroNode2 = new HeroNode(2, "吴用");
        HeroNode heroNode3 = new HeroNode(3, "卢俊义");
        HeroNode heroNode4 = new HeroNode(4, "林冲");
        HeroNode heroNode5 = new HeroNode(5, "关胜");
        binaryTree.setRoot(root);
        root.setLeft(heroNode2);
        root.setRight(heroNode3);
        heroNode3.setLeft(heroNode5);
        heroNode3.setRight(heroNode4);

        System.out.println("先序遍历..");
        binaryTree.preOrder();

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

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

        System.out.println("------------------------");
        System.out.println("先序遍历..");
        binaryTree.preOrder();
        binaryTree.delNode(3);
        System.out.println("先序遍历..");
        binaryTree.preOrder();
    }
}

//创建一个 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 midOrder(){
        if (this.root != null){
            this.root.midOrder();
        }else{
            System.out.println("二叉树为空，无法遍历...");
        }
    }

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


    public void delNode(int no){
        //如果根节点不为空，并且就是要删除的节点，就直接删除
        if (this.root != null && this.root.getNo() == no){
            root = null;
            return;
        }else if(this.root != null){ //如果根节点不为空，并且不是要删除的节点，就进行判断左右子树
            this.root.delNode(no);
        }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 midOrder(){
        //如果当前节点的左子树不为空，递归中序遍历
        if (this.left != null){
            this.left.midOrder();
        }
        //输出当前节点
        System.out.println(this);
        //如果当前节点的右子树不为空，递归中序遍历
        if(this.right != null){
            this.right.midOrder();
        }
    }

    /**
     * 二叉树的后序遍历
     */
    public void postOrder(){
        //如果当前节点的左子树不为空，递归后序遍历
        if (this.left != null){
            this.left.postOrder();
        }
        //如果当前节点的右子树不为空，递归后序遍历
        if (this.right != null){
            this.right.postOrder();
        }
        //输出当前节点
        System.out.println(this);
    }


    //二叉树节点删除
    public void delNode(int no){
        //判断当前节点的左节点，如果不为空并且是需要删除的节点时，直接删除
        if (this.left != null && this.left.no == no){
            this.left = null;
            return;
        }
        //判断当前节点的右节点，如果不为空并且是需要删除的节点时，直接删除
        if (this.right != null && this.right.no == no){
            this.right = null;
            return;
        }

        //如果当前节点的左节点不是要删除的节点，那么就进行左子树的递归删除
        if (this.left != null){
            //递归删除
            this.left.delNode(no);
        }
        //如果当前节点的右节点不是要删除的节点，那么就进行右子树的递归删除
        if (this.right != null){
            //递归删除
            this.right.delNode(no);
        }

    }
}

🎃 完结

_子栖_
关注
专栏目录
数据结构——二叉树
02-06
该文件包括二叉树的头文件（BitTree开头）和堆栈的头文件（Seq开头），另外还实现了编写按层次顺序（同一层自左至右）遍历二叉树的算法、后序递归遍历计算二叉树的深度的算法、判断给定二叉树是否为完全二叉树（通过左右子树情况以及总结点数）、统计二叉树中所有结点的个数的算法
数据结构之二叉树
博采众长，自成一派；
03-10 2432
数据结构之二叉树 本文详细介绍了二叉树的遍历算法；根据遍历序列还原二叉树的方法；二叉搜索树及其插入、删除算法；AVL树及其插入、删除算法；红黑树及其插入和删除算法；二叉线索树、哈夫曼树以及union-find树等知识； 本文github源码（Java语言实现，现已完成至二叉平衡树，即将开始红黑树实现） 二叉树的遍历方法及特点分析 访问一棵树时： 先序遍历：首先访问树的根结点，然后先序遍...
【数据结构】二叉树
DerrictC的博客
09-18 980
该算法从堆的根节点开始，通过比较和交换节点值，将根节点调整到其在堆中的正确位置，以确保堆的每个父节点的值都大于或等于其子节点的值（在最大堆中），或者小于或等于其子节点的值（在最小堆中）。我们常见的二叉树的结构叫逻辑结构如下图1，这是我们自己想象出来的二叉树的样子，但实际上二叉树并不是就像图中所示的那样，二叉树真正的结构，也叫物理结构，是像数组一样每个数据一行排开，如图2，图2所示及是实实在在。也就是说，如果一个二叉树的层数为K，且结点总数是(2^k) -1 ，则它就是满二叉树。如果二叉树为空，则退出；
2020-12-15
m0_46381363的博客
12-15 67
/*给定二叉树的前序遍历、中序遍历和后序遍历中的一种或多种，判断是否能够唯一确定一棵二叉树。 基本要求： （1）用户输入二叉树的前序、中序和后序的一种或多种遍历序列； （2）判断是否能够唯一确定一棵二叉树； （3）若能确定，则输出二叉树的所有遍历序列、叶子节点和深度； （4）输出该二叉树对应的森林的遍历前序和后序遍历序列。*/ 哪个大佬帮忙写一下呗，求求了 ...
二叉树
2302_80364740的博客
02-01 419
1.树的基本概念树是有n个结点的有限集（一种递归定义的数据结构）当n=0时，说明这个树是一个空树有且只有一个根节点.没有后继的结点是叶子结点（终端结点）.有后继的结点（除了根结点）都称之为分支结点（非终端结点）.除了根结点外，其余结点都有且仅有一个前驱每个结点都有0个或者多个后继子树的概念：子树的概念是相对于某一个结点而言的，子树也是树。比如说，B延伸所形成的树就是A的子树，E延伸所形成的树，就是B的子树，所以说，子树没有绝对的概念，只不过是相对的树的图解。
树：二叉树
——
02-24 1617
之前写了一些链表和排序的blog，其中有说到多链表，堆，其中提到了一种特殊的数据结构：树。 人们发明树结构，用于储存和搜索海量的数据。 树的种类 无序树：树中任意节点的子结点之间没有顺序关系，这种树称为无序树,也称为自由树; 有序树：树中任意节点的子结点之间有顺序关系，这种树称为有序树； 二叉树：每个节点最多含有两个子树的树称为二叉树； 完全二叉树：二叉树的所有子树要么没有
数据结构--二叉树--思维导图.pdf
08-29
"数据结构--二叉树--思维导图" 二叉树是一种常见的数据结构，它是一种树形结构，每个节点最多有两个孩子节点，分别是左子树和右子树。二叉树可以用来存储大量数据，并且可以快速地查找、插入和删除数据。 二叉树的...
数据结构-二叉树Java实现及其遍历算法
最新发布
09-24
数据结构-二叉树Java实现及其遍历算法，代码示例中实现了中序遍历，简单易学。
5.C-数据结构-二叉树
09-19
5.C_数据结构_二叉树
数据结构-二叉树相关功能及算法
06-11
二叉树是数据结构中的重要概念，它是一种特殊的树形数据结构，每个节点最多有两个子节点，通常称为左子节点和右子节点。在计算机科学中，二叉树的应用广泛，涉及搜索、排序、编译器设计等多个领域。本主题将深入探讨...
数据结构-二叉树的广度优先遍历
08-23
// 定义二叉树的节点结构 typedef struct Node { int data; struct Node* left; struct Node* right; } Node; // 创建新节点 Node* createNode(int data) { Node* newNode = (Node*)malloc(sizeof(Node)); new...
数据结构-二叉树结点计数方法解析
"这篇资料主要讨论了数据结构中的树，特别是二叉树的节点计数方法，以及相关术语和操作。由雷惊风主讲，涵盖了树的基本概念、二叉树的定义、性质、遍历等核心内容。" 在数据结构中，树是一种重要的抽象数据类型，它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_子栖_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值