二叉树（链式存储）

最新推荐文章于 2024-05-27 17:28:26 发布
最新推荐文章于 2024-05-27 17:28:26 发布
阅读量1.9k 收藏 6
点赞数 1
分类专栏： Java数据结构与算法笔记 文章标签： 二叉树 链表 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43906881/article/details/108955167
版权

二叉树（链式存储）

1、树数据结构与数组和链表的区别

  1. 数组存储方式的分析

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

在这里插入图片描述

  1. 链式存储方式的分析

    1. 优点： 在一定程度上对数组存储方式有优化(比如： 插入一个数值节点，只需要将插入节点，链接到链表中即可，
      删除效率也很好)。
    2. 缺点： 在进行检索时，效率仍然较低，比如(检索某个值，需要从头节点开始遍历）

    在这里插入图片描述

  2. 树存储方式的分析

    1. 能提高数据存储 ， 读取的效率, 比如利用 二叉排序树(Binary Sort Tree)，既可以保证数据的检索速度，同时也
      可以保证数据的 插入，删除，修改的速度。
    2. 案例: [7, 3, 10, 1, 5, 9, 12]

    在这里插入图片描述

2、树的示意图及常用术语

在这里插入图片描述

/*
树的常用术语(结合示意图理解):
1) 节点
2) 根节点
3) 父节点
4) 子节点
5) 叶子节点 (没有子节点的节点)
6) 节点的权(节点值)
7) 路径(从 root 节点找到该节点的路线)
8) 层
9) 子树
10) 树的高度(最大层数)
11) 森林 :多颗子树构成森林
*/

3、二叉树的概念

  1. 树有很多种，每个节点最多只能有两个子节点的一种形式称为二叉树（注： <=2）
  2. 二叉树的子节点分为左节点和右节点
  3. 示意图

在这里插入图片描述

  1. 如果该二叉树的所有叶子节点都在 最后一层，并且**结点总数= 2^n -1 **（等比数列求和） , n 为层数，则我们称为满二叉树

在这里插入图片描述

  1. 完全二叉树是这样的二叉树：

    ①完全二叉树的倒数第二行及之前的行，都与满二叉树相同。

    ②倒数第一行右半部分可以是空的，也可以是满的，但不能有单个的出现！

    ③倒数第一行左半部分可以是空的，也可以是满的，也可有单个的出现，但有且只能有一个单个，且必须是它父亲的左孩子！

    …………

    这我们就知道了，满二叉树就是完全二叉树的特殊情况！

在这里插入图片描述

4、二叉树遍历的说明

  1. 使用 前序，中序和后序对下面的二叉树进行遍历.
    1. 前序遍历: 先输出父节点，再遍历左子树和右子树 （根左右）
    2. 中序遍历: 先遍历左子树，再输出父节点，再遍历右子树 （左根右）
    3. 后序遍历: 先遍历左子树，再遍历右子树，最后输出父节点 （左右根）
    4. 小结: 看输出父节点的顺序（即遍历父节点是在前面，中间还是后面），就确定是前序，中序还是后序

5、二叉树遍历实验

  1. 应用实例的说明和思路

在这里插入图片描述

  1. 代码实现
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("中序遍历");// 2  1   5   3   4
        binaryTree.infixOrder();

        System.out.println("后序遍历");// 2  5   4   3   1
        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("二叉树为空， 无法遍历");
        }
    }
}

class HeroNode{
    private int no;
    private String name;
    private HeroNode left;//默认null
    private HeroNode right;//默认null

    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、二叉树-查找指定节点

  1. 要求：
    1. 请编写前序查找，中序查找和后序查找的方法。
    2. 并分别使用三种查找方式，查找 herono = 5 的节点
    3. 并分析各种查找方式，分别比较了多少次
    4. 思路分析图解

在这里插入图片描述

  1. 代码实现（只放了新加的，前面的见上一个代码块）
HeroNode类：

//前序遍历查找
public HeroNode  preOrderSearch(int no){
    System.out.println("进入前序遍历查找");
    /*
    要查看查找了几次，得在判断当前节点的上面，
    因为在判断左右子树的上面的话，很多次都只是判断左右有没有节点，并不是在查找
    并且要判断找没找到最终的还是这一步，即便是左递归或者右递归，每个节点都是通过该句来判断是否为目标节点
    （或者说这就是跳出递归的出口）
     */
    //比较当前节点是不是
    if (this.no == no){
        return this;
    }
    //这个引用是为了接收每次递归的结果（包括要查找的那个）
    HeroNode resNode = null;
    //1、判断当前节点的左子树是否为空， 如果不为空， 则递归前序查找
    //2、如果左递归前序查找，找到节点，则返回
    if (this.left != null){
        //注意： 要把以左子树为根节点遍历的结果赋给resNode
        resNode = this.left.preOrderSearch(no);
    }
    //如果resNode不为空
    if (resNode != null){//说明我们的左子树找到了
        return resNode;
    }
    //1、左递归前序查找， 找到节点， 则返回， 否则继续判断，
    //2、当前节点的右节点是否为空， 如果不空， 则继续向右递归前序查找
    if (this.right != null){
        resNode = this.right.preOrderSearch(no);
    }
    return resNode;
}

//中序遍历查找
public HeroNode infixOrderSearch(int no){
    //判断当前节点的左子树是否为空， 如果不为空， 则递归中序查找
    HeroNode resNode = null;
    if (this.left != null){
        resNode = this.left.infixOrderSearch(no);
    }
    if (resNode != null){
        return resNode;
    }
    System.out.println("进入中序遍历查找");
    //如果做递归找到，则返回，如果没有就和当前节点比较， 如果是就返回当前节点
    if (this.no == no){
        return this;
    }
    //否则继续进行右递归的中序查找
    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;
}

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

main里面： 
       //前序遍历查找
//        System.out.println("前序遍历方式~~~~~");
//        HeroNode resNode = binaryTree.preOrderSearch(15);
//        if (resNode != null){
//            System.out.printf("找到了， 信息为 no=%d  name=%s",resNode.getNo(),resNode.getName());
//        }else {
//            System.out.printf("没有找到 no=%d 的英雄",15);
//        }

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

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

7、二叉树-删除节点

  1. 要求：（不考虑删除该节点后是否要把左或右孩子补上来）

    1. 如果删除的节点是叶子节点，则删除该节点
    2. 如果删除的节点是非叶子节点，则删除该子树.
    3. 测试，删除掉 5 号叶子节点 和 3 号子树.
    4. 完成删除思路分析

    在这里插入图片描述

    (注： 首先处理的那步，还包含要删除的节点是根节点的情况，按照要求就是把二叉树置空（这条语句写在BinaryTree类里）

    ​ 对于第一步，其实就是判断当前节点的左孩子或者右孩子是否为我们要删除的节点，因为如果我们是判断当前节点是否要删除的话，那就删不掉了（因为当引用指向要删除的节点的时候，我们无法得到他的父节点）

    )

    1. 代码实现（其它的代码见上一个代码块）
    HeroNode类：
    
     //递归删除节点
    //1.如果删除的节点是叶子节点， 则删除该节点
    //2.如果删除的节点是非叶子节点，则删除该子树（注：是子树）
    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;
        }
        //我们就需要向左子树进行递归删除
        if (this.left != null){
            this.left.delNode(no);
        }
        //则应当向右子树进行递归删除
        if (this.right != null){
            this.right.delNode(no);
        }
    }
    
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("空树！！ 不能删除~");
        }
    }

BinaryTreeDemo类：

//删除节点
System.out.println("删除前， 前序遍历");//1 2 3 5 4
binaryTree.PreOrder();
binaryTree.delNode(5);
System.out.println("删除后， 前序遍历");//1 2 3 4
binaryTree.PreOrder();
是渣渣呀
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树与多叉树
wangzilong_2019的博客
05-10 1300
序言 多叉树 2-3树 B树 B+树 B*树 序言 二叉树的缺点 二叉树需要加载到内存中，如果节点少，没什么问题，若是节点非常多，就会带来问题 当构建二叉树时，需要进行多次I/O操作，构造速度会有影响 节点海量，会造成二叉树的高度非常大降低操作速度 多叉树 每个节点可以右多个子节点 B树 节点的度：此节点拥有子节点的个数称为节点的度 数的度：数中所有节点的度的最大值 B树通过重新组织节点，降低了数的高度 文件系统或是数据库系统利用了磁盘预先读取原理，将一个节点的大小设置为一个页（一个页的大小为4
数据结构-二叉树的链式存储
qq_45967533的博客
03-20 1万+
文章目录二叉树的链式结构链式结构的遍历二叉树链式存储的实现二叉树节点的创建前序遍历中序遍历后序遍历二叉树元素个数叶节点的个数第k层节点的个数查找元素二叉树销毁二叉树的层序遍历判断是否为完全二叉树 二叉树的链式结构 二叉树的存储结构有顺序结构和链式结构两种，顺序结构我已经在上篇进行了详细的讲解，地址：数据结构-二叉树的顺序存储与堆（堆排序），本篇我们就主要讲解二叉树的链式存储。 二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成，数据域和左右
【数据结构】链式二叉树（超详细）
最新发布
qq_74897518的博客
05-27 1058
链式二叉树
树和二叉树：二叉树的存储结构
weixin_51958878的博客
06-02 2237
树和二叉树：二叉树的存储结构 二叉树的顺序存储结构 回顾二叉树的性质4，完全二叉树节点按层序编号： 完全二叉树的顺序存储结构 非完全二叉树的顺序存储结构 二叉树顺序存储结构的特点： 对于完全二叉树来说，其顺序存储是十分合适的 对于一般的二叉树，特别是对于那些单分支节点较多的二叉树来说是很不合适的，因为可能只有少数存储单元被利用，特别是对退化的二叉树（即每个分支节点都是单分支的），空间浪费更是惊人 在顺序存储结构中，找一个节点的双亲和孩子都很容易 二叉树的链式存储结构 借鉴树的孩子链存储结构 - 二
（数据结构）二叉树的链式存储结构
weixin_51927215的博客
03-29 1万+
二叉树的顺序存储的缺点 因为并不是每个二叉树都是完全二叉树，普通二叉树使用顺序表存储或多或少会存在空间浪费的现象 图 1 普通二叉树的转化 如上图 1，普通二叉树里只有二个元素，最好的存储方式当然是开辟相对应的空间，但是顺序存储结构却让我们不能这么做！也就是说我们此时必须花更多的空间去存储相对少的元素 二叉树的链式存储 先慢慢介绍一下链式存储的节点结构！！！ 图 2 普通二叉树示意图 如上图 2 所示，若将其采用链式存储，则只需从树的根节点开始，将各个节点及其左右孩子使用链表存储 因
【数据结构】二叉树（上-链式存储）
m0_57248752的博客
03-24 553
树的基本概念，二叉树的基本概念和特性，二叉树链式存储和基本操作
C语言 二叉树的链式存储实例
12-31
二叉树的链式存储 实现二叉树的基本操作：建立、遍历、计算深度、结点数、叶子数等。 输入C，先序创建二叉树，#表示空节点； 输入H：计算二叉树的高度； 输入L：计算二叉树的叶子个数； 输入N：计算二叉树节点总个数...
链式存储二叉树基本操作函数.rar
03-28
链式存储二叉树是一种在计算机科学中用于表示和操作二叉树的数据结构。与数组存储方式不同，链式存储不依赖于连续的内存空间，而是通过指针连接各个节点，使得二叉树可以在内存中灵活分布。这种存储方式特别适用于...
二叉树的链式存储.py
10-26
二叉树的链式存储 二叉树的链式存储.py二叉树的链式存储.py二叉树的链式存储.py
二叉树链式存储结构 第六章实验报告.doc
07-06
在实验中，学生通过编写和调试这些函数，不仅掌握了二叉树链式存储结构的基本概念，还深化了对二叉树遍历算法的理解，并意识到亲手编写程序对学习的重要性。通过运行程序，可以观察到二叉树的构建和遍历结果，从而...
二叉树的链式存储
08-04
二叉树的链式存储实现代码
使用C语言实现二叉树的链式存储
Keep_Trying_Go的博客
08-18 3093
使用C语言实现二叉树的链式存储
二叉树：链式存储结构基础操作（C语言）
Fexy_的博客
05-05 534
二叉树：链式存储结构
二叉树的链式存储结构
study_way的博客
04-22 5914
二叉树的链式存储结构就是用链表来表示一棵二叉树，即用链表来指示元素之间的逻辑关系。通常有两种存储形式： 链表中每个结点由三个域组成，除了数据域之外，还有两个指针域，分别用来给出该结点的左孩子和右孩子所在的存储地址。 链表中每个结点由四个域组成，除了数据域之外，还有三个指针域，分别用来给出该结点的左孩子、右孩子和双亲结点所在的存储地址。 class NodeL { Node root; public...
二叉树链式存储结构
Youpeng
06-20 1万+
二叉树链式存储结构 ​ 二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址。其结点结构为： 其中，data域存放某结点的数据信息；lchild与rchild分别存放指向左孩子和右孩子的指针，当左孩子或右孩子不存在时，相应指针域值为空（用符号∧或N...
二叉树——特点、性质、存储结构
longjing1113的专栏
01-03 4737
一、二叉树的定义 折半查找引出。 1、二叉树的特点 1）每个结点最多有两棵子树 2）左子树和右子树是有顺序的，不能颠倒次序 3）即使树中只有一棵子树，也要区分是左子树 还是右子树 二叉树有5种形态： 空二叉树、只有一个根结点、根结点只有左子树、根结点只有右子树、根结点有左子树和右子树 2、特殊二叉树 1）斜树：      所有结点都只有左子树——左斜树      所有结点都只
二叉树
热门推荐
zhuboke3344的博客
12-09 2万+
二叉树的基本概念 一、二叉树的概念：一棵二叉树是节点的一个有限集合，该集合或者为空，或者由一个根节点加上两棵左子树和右子树组成 二、二叉树的特点： 1、每个节点最多有两棵子树，即二叉树不存在度大于2的节点 2、二叉树的子树有左右之分，其子树的次序不能颠倒 三、二叉树的形式： 四、满二叉树：在一棵二叉树中，所有分支节点都存在左子树和右子树，并且所有的叶节点都在同一层上 五、完全...
常见数据结构优缺点比较
夏末_那场未盛开的梦的博客
12-11 9103
数据结构是对在计算机内存中的数据的一种安排，数据结构包括数组，链表，栈，二叉树，哈希表等等，数据结构和技术与如何处理现实世界数据存储问题项链，现实世界数据指的是那些描述处于计算机外部的物理实体的数据。今天不展开常见数据结构的原理，仅仅比较他们的优缺点。 数据结构 优点 缺点

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值