【韩顺平-数据结构】树结构基础（学习笔记）

已于 2023-08-04 13:54:55 修改
阅读量62 收藏
点赞数
分类专栏： 数据结构（学习笔记） 文章标签： java 数据结构
于 2023-08-04 13:52:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wmh1024/article/details/132102828
版权

一、二叉树

1、为什么需要树

1）数组存储方式的分析

优点：通过下标方式访问元素，速度快。对于有序数组，还可使用二分查找提高检索速度。

缺点：如果要检索具体某个值，或者插入值（按一定顺序）会整体移动，效率较低

2）链式存储方式的分析

优点：在一定程度上对数组存储方式有优化（比如：插入一个数值节点，只需要将插入节点，链按到链表中即可，删除效率也很好）。

缺点：在进行检索时，效率仍然较低，比如（检索某个值，需要从头节点开始遍历）

3）树存储方式的分析

可以提高数据存储，读取的效率

比如利用二叉排序树（Binary Sort Tree），既可以保证数据的检索速度，同时也可以保证数据的插入，删除，修改的速度。

2、树的常用术语

  1. 节点
  2. 根节点
  3. 父节点
  4. 子节点
  5. 叶子节点：没有子节点的节点
  6. 节点的权：节点值
  7. 路径：从root 节点找到该节点的路线
  8. 层
  9. 子树
  10. 树的高度（最大层数）
  11. 森林 ：多颗子树构成森林

3、二叉树概述

  1. 二叉树：每个节点最多只能有两个子节点（左节点和右节点）
  2. 满二叉树：二叉树的所有叶子节点都在最后一层，并且结点总数=2^n-1（n 为层数）
  3. 完全二叉树：二叉树的所有叶子节点都在最后一层或者倒数第二层，而且最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续

4、二叉树遍历概述

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

小结：看输出父节点的顺序，就确定是前序，中序还是后序

5、二叉树代码实现

package work.rexhao.tree;

/**
 * 二叉树的遍历和查找
 */
public class BinaryTreeDemo {
    public static void main(String[] args) {
        BinaryTree bt = new BinaryTree();
        System.out.print("先序遍历: ");
        BinaryTree.preOrder(bt.head);//先序遍历：12453
        System.out.println();
        System.out.print("中序遍历: ");
        BinaryTree.infixOrder(bt.head);//中序遍历：42513
        System.out.println();
        System.out.print("后序遍历: ");
        BinaryTree.postOrder(bt.head);//后续遍历：45231
        System.out.println();
        System.out.println("------------");
        System.out.println("先序查找3: " + BinaryTree.preOrderSearch(bt.head, 3));
        System.out.println("先序查找6: " + BinaryTree.preOrderSearch(bt.head, 6));
        System.out.println("中序查找3: " + BinaryTree.infixOrderSearch(bt.head, 3));
        System.out.println("中序查找6: " + BinaryTree.infixOrderSearch(bt.head, 6));
        System.out.println("后序查找3: " + BinaryTree.postOrderSearch(bt.head, 3));
        System.out.println("后序查找6: " + BinaryTree.postOrderSearch(bt.head, 6));
        System.out.println("------------");
        BinaryTree.delTree(bt.head, 2);
        BinaryTree.infixOrder(bt.head);//中序遍历：13
        System.out.println();
        BinaryTree.delTree(bt.head, 6);
        BinaryTree.infixOrder(bt.head);//中序遍历：13
        System.out.println();
        System.out.println("------------");
        bt = new BinaryTree();
        BinaryTree.delNode(bt.head, 2);
        BinaryTree.infixOrder(bt.head);//中序遍历：453
        System.out.println();
    }
}

/**
 * 二叉树
 */
class BinaryTree {
    TreeNode head;

    public BinaryTree() {
        head = new TreeNode(1);
        head.leftNode = new TreeNode(2);
        head.rightNode = new TreeNode(3);
        head.leftNode.leftNode = new TreeNode(4);
        head.leftNode.rightNode = new TreeNode(5);
        /*
        初始化树结构示意图
                 1
               /  \
              2    3
            /  \
           4    5

        先序遍历：12453
        中序遍历：42513
        后续遍历：45231
         */
    }

    /**
     * 先序遍历
     */
    public static void preOrder(TreeNode tn) {
        if (tn != null) {
            System.out.print(tn.getData());
            preOrder(tn.leftNode);
            preOrder(tn.rightNode);
        }
    }

    /**
     * 中序遍历
     */
    public static void infixOrder(TreeNode tn) {
        if (tn != null) {
            infixOrder(tn.leftNode);
            System.out.print(tn.getData());
            infixOrder(tn.rightNode);
        }
    }

    /**
     * 后序遍历
     */
    public static void postOrder(TreeNode tn) {
        if (tn != null) {
            postOrder(tn.leftNode);
            postOrder(tn.rightNode);
            System.out.print(tn.getData());
        }
    }

    /**
     * 先序查找
     */
    public static boolean preOrderSearch(TreeNode tn, int target) {
        if (tn == null) return false;
        if (target == tn.getData()) {
            return true;
        } else if (preOrderSearch(tn.leftNode, target)) {
            return preOrderSearch(tn.leftNode, target);
        } else {
            return preOrderSearch(tn.rightNode, target);
        }
    }

    /**
     * 中序查找
     */
    public static boolean infixOrderSearch(TreeNode tn, int target) {
        if (tn == null) return false;
        if (infixOrderSearch(tn.leftNode, target)) {
            return infixOrderSearch(tn.leftNode, target);
        } else if (target == tn.getData()) {
            return true;
        } else {
            return infixOrderSearch(tn.rightNode, target);
        }
    }

    /**
     * 后序查找
     */
    public static boolean postOrderSearch(TreeNode tn, int target) {
        if (tn == null) return false;
        if (postOrderSearch(tn.leftNode, target)) {
            return postOrderSearch(tn.leftNode, target);
        } else if (postOrderSearch(tn.rightNode, target)) {
            return postOrderSearch(tn.rightNode, target);
        } else {
            return target == tn.getData();
        }
    }

    /**
     * 删除子树
     * 叶子结点：删除节点
     * 非叶子节点：删除子树
     * 注：不删除根节点
     */
    public static void delTree(TreeNode tn, int target) {
        if (tn == null) {
            return;
        }
        if (tn.leftNode != null) {
            if (tn.leftNode.getData() == target) {
                tn.leftNode = null;
                return;
            } else {
                delTree(tn.leftNode, target);
            }
        }
        if (tn.rightNode != null) {
            if (tn.rightNode.getData() == target) {
                tn.rightNode = null;
                return;
            } else {
                delTree(tn.rightNode, target);
            }
        }
    }

    /**
     * 删除节点
     * 叶子节点：删除
     * 非叶子节点（一个子节点）：替代原节点
     * 非叶子节点（两个子节点）：左节点代替原节点
     */
    public static void delNode(TreeNode tn, int target) {
        if (tn == null) return;
        if (tn.leftNode != null) {
            if (tn.leftNode.getData() == target) {
                if (tn.leftNode.rightNode == null && tn.leftNode.leftNode == null) {
                    // 叶子节点
                    tn.leftNode = null;
                } else if (tn.leftNode.rightNode != null && tn.leftNode.leftNode != null) {
                    // 两个节点
                    tn.leftNode = tn.leftNode.leftNode;
                } else {
                    // 一个节点
                    if (tn.leftNode.leftNode != null) {
                        // 左节点
                        tn.leftNode = tn.leftNode.leftNode;
                    } else {
                        // 右节点
                        tn.leftNode = tn.leftNode.rightNode;
                    }
                }
                return;
            } else {
                delNode(tn.leftNode, target);
            }
        }
        if (tn.rightNode != null) {
            if (tn.rightNode.getData() == target) {
                if (tn.rightNode.rightNode == null && tn.rightNode.leftNode == null) {
                    // 叶子节点
                    tn.rightNode = null;
                } else if (tn.rightNode.rightNode != null && tn.rightNode.leftNode != null) {
                    // 两个节点
                    tn.rightNode = tn.rightNode.leftNode;
                } else {
                    // 一个节点
                    if (tn.rightNode.leftNode != null) {
                        // 左节点
                        tn.rightNode = tn.rightNode.leftNode;
                    } else {
                        // 右节点
                        tn.rightNode = tn.rightNode.rightNode;
                    }
                }
                return;
            } else {
                delNode(tn.rightNode, target);
            }
        }
    }

}

/**
 * 二叉树的节点
 */
class TreeNode {
    private int data;
    TreeNode leftNode;
    TreeNode rightNode;

    TreeNode(int data) {
        this.data = data;
    }

    public int getData() {
        return data;
    }

    public void setData(int data) {
        this.data = data;
    }

}

二、顺序存储二叉树

1、顺序存储二叉树的说明

从数据存储来看，数组存储方式和树的存储方式可以相互转换，即数组可以转换成树，树也可以转换成数组

2、顺序存储二叉树的特点

  1. 顺序二叉树通常只考虑完全二叉树
  2. 第n个元素的左子节点为 2*n+1
  3. 第n个元素的右子节点为 2*n+2
  4. 第n个元素的父节点为 (n-1)/2
  5. n：表示二叉树中的第几个元素（按0开始编号）

3、顺序存储二叉树代码实现

package work.rexhao.tree;

/**
 * 顺序存储二叉树
 */
public class ArrBinaryTreeDemo {
    public static void main(String[] args) {
        ArrBinaryTree abt = new ArrBinaryTree(7);
        for (int i = 0; i < abt.data.length; i++) {
            abt.data[i] = i + 1;
        }
        System.out.print("前序:");
        ArrBinaryTree.preOrder(abt, 0);
        System.out.println();
        System.out.print("中序:");
        ArrBinaryTree.infixOrder(abt, 0);
        System.out.println();
        System.out.print("后序:");
        ArrBinaryTree.postOrder(abt, 0);
        System.out.println();

    }
}

class ArrBinaryTree {
    int[] data;

    ArrBinaryTree(int maxSize) {
        data = new int[maxSize];
    }

    /**
     * 先序遍历
     */
    public static void preOrder(ArrBinaryTree abt, int index) {
        // 数组越界
        if (index >= abt.data.length) {
            return;
        }
        System.out.print(abt.data[index]);
        preOrder(abt, index * 2 + 1);
        preOrder(abt, index * 2 + 2);
    }

    /**
     * 中序遍历
     */
    public static void infixOrder(ArrBinaryTree abt, int index) {
        // 数组越界
        if (index >= abt.data.length) {
            return;
        }
        infixOrder(abt, index * 2 + 1);
        System.out.print(abt.data[index]);
        infixOrder(abt, index * 2 + 2);
    }

    /**
     * 后序遍历
     */
    public static void postOrder(ArrBinaryTree abt, int index) {
        // 数组越界
        if (index >= abt.data.length) {
            return;
        }
        postOrder(abt, index * 2 + 1);
        postOrder(abt, index * 2 + 2);
        System.out.print(abt.data[index]);
    }
}
wmh1024
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
韩顺平java视频教程百度网盘地址.txt
10-08
韩顺平java基础视频百度网盘地址，欢迎需要学习java的基础的过来下载参考学习，失败的请留言我，我重新上传新的百度网盘地址
学习韩顺平-Linux：
qq_45888242的博客
09-13 862
用户的配置文件包含每个用户登录 Linux 系统所必需的的信息登录shell： 类似于编码常用 3 和 5init 5： 使用5 级别 ： （图形界面）init 3： 使用3 级别 ： （无图形界面）如此设置 重启后失效linux 的每个用户都 具有一个组， 用户不可独立于组外。每个文件都具有其 所有者其它组： 除去 文件所有者和所在组 的用户以外 ，系统的其他用户第0 位 ：文件类型​ I 链接 d 文件夹 c 设备 b 块设备 - 普通文件标识。
自学韩顺平java笔记
weixin_43548992的博客
06-11 361
韩顺平java学习笔记
韩顺平Linux基础篇
z972065491的博客
08-09 720
Linux是什么 Linux是一个操作系统
2021韩顺平图解linux_狗剩学习笔记
热门推荐
狗剩的专栏
02-06 10万+
韩顺平图解Linux全面升级 https://www.bilibili.com/video/BV1Sv411r7vd P001_韩顺平图解Linux全面升级_课程内容 20:37 P002_韩顺平图解Linux全面升级_应用领域 05:05 P003_韩顺平图解Linux全面升级_概述 16:37 P004_韩顺平图解Linux全面升级_Linux与Unix 18:09 P005_韩顺平图解Linux全面升级_vmware15.5安装 17:36 P006_韩顺平图解
韩顺平老师尚硅谷Java数据结构与算法194集笔记
10-12
这是我从B站上看韩老师讲的数据结构与算法后整理的笔记 代码经过运行，欢迎批评指正 有些地方我感觉还是挺难的 大都经过我自己的语言进行描述，韩老师中期的表达可能或多或少也影响可阅读性，望先生们见谅
Linux-韩顺平学习笔记 - PDF-PPT
07-28
Linux课程学习笔记 -韩顺平 包含c/c++/python/java 专项 面试题 PDF PPT 笔记 面试题 （百度网盘链接 永久有效） 自学,做笔记,复习可用
韩顺平JAVA数据结构与算法，重点是算法！.zip
01-14
Java是一种高性能、跨平台的面向对象编程语言。它由Sun Microsystems（现在是Oracle Corporation）的James Gosling等人在1995年推出，被设计为一种简单、健壮、可移植、多线程、动态的语言。Java的主要特点和优势...
韩顺平java笔记--初级
kc7w91的博客
02-21 725
韩顺平Java基础
【韩顺平-数据结构】递归（学习笔记）
wmh的博客
12-11 158
一、递归概述 递归：方法自己调用自己，每次调用时传入不同的变量。递归有助于编程者解决复杂的问题，同时可以让代码变得简洁。 二、递归的调用机制 当程序执行到一个方法时，就会开辟一个独立的空间（栈） 每个空间的数据（局部变量）都是独立的 三、递归解决的问题 各种数学问题如：8 皇后问题，汉诺塔，阶乘问题，迷宫问题，球和篮子的问题（google 编程大赛） 各种算法中也会使用到递归，比如快排，归并排序，二分查找，分治算法等 将用栈解决的问题 --> 递归代码比较简洁
Java事务入门：从基础概念到初步实践
Huazie
05-29 967
本文 Huazie 从 Java 事物的基础概念出发，带大家通过不同的事物管理方式进行实践，进一步加深了对 Java 事物的理解。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 900
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 673
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
Java手动启动jar包
liangweihao的博客
05-29 227
【代码】Java手动启动jar包。
java多线程创建方式
weixin_57763462的博客
05-28 1052
这种方式是通过创建一个实现了Runnable接口的类，并实现run()方法来创建线程。然后将这个类的对象作为参数传递给Thread类的构造器，并调用Thread对象的start()方法来启动线程。这种方式是通过创建一个实现了Callable接口的类，实现call()方法，并使用FutureTask或者ExecutorService来创建线程。这种方式的优点在于，由于Java不支持多重继承，如果你的类需要继承其他类，那么实现Runnable接口将是唯一的选择。// 在这里定义线程的执行逻辑。
Redis学习笔记【基础篇】
qq_42192253的博客
05-30 774
这样以来，我们就可以把不同类型的数据区分开了。从而避免了key的冲突问题。HSET key field value：添加或者修改hash类型key的field的值。获取sorted set 中的指定元素的排名：ZRANK key member。HGET key field：获取一个hash类型key的field的值。通过给key添加前缀加以区分，不过这个前缀不是随便加的，有一定的规范。HMSET：批量添加多个hash类型key的field的值。HMGET：批量获取多个hash类型key的field的值。
C语言基础——数组
2302_80177460的博客
05-27 1051
C语言基础——字符串与数组及部分操作符-CSDN博客），这里再简单说明一下吧。我们都知道，如果我们在C语言中想要创建很多个变量，如果是一个一个创建的话那效率太低下了，这个时候或许会有人想到用循环来搞定，但是我们再细想想，如果用循环来表示的话我们应该把这组数据储存在哪里呢，如果只是创建一个变量的话那么后一次循环会覆盖掉前一次循环，但是如果创建很多个变量的话又不好在循环之中插入，这个时候我们便可以使用我们心心念念的数组啦。我们这一章节就来具体看看数组到底是什么吧。
Java入门基础教程-字面量、变量、关键字与标识符
码客笔记
05-27 155
变量是存储数据值的容器，其值可以在程序执行过程中被修改。变量有一个名字（即标识符），并且总是与特定的数据类型相关联。在Java中，变量的声明和初始化是分开的，但也可以同时进行。大家不要被这个词搞晕了，它其实很简单，我们知道计算机是来处理数据的，字面量其实就是告诉程序员数据在程序中的书写格式。所谓标志符其实就是我们自己取的名字。像前面我们取的类名，变量名其实都是标志符。如何识别那些单词是关键字？
linux学习笔记-b站韩顺平
09-12
B站上的韩顺平老师的《Linux学习笔记》系列课程非常值得推荐。通过这个课程，我学到了很多关于Linux操作系统的知识和技能。 首先，韩老师在课程中详细介绍了Linux的基本概念和特点。我清楚地了解到Linux是一个开源...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

wmh1024

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

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

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

打赏作者

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

抵扣说明：

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

余额充值