Java--二叉树概念及其基础应用

bbq粉刷匠2025-12-26 11:22

1.树的基础概念

树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看 起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点： 有一个特殊的结点，称为根结点，根结点没有前驱结点

  1. 除根结点外，其余结点被分成M(M > 0)个互不相交的集合T1、T2、......、Tm，其中每一个集合Ti (1<= i<=m )又是一棵与树类似的子树。
  2. 每棵子树的根结点有且只有一个前驱，可以有0个或多个后继
  3. 树是递归定义的。

一个完整的数是下面这样的：

1.1 树相关知识点

  • 结点的度：一个结点含有子树的个数称为该结点的度； 如上图：A的度为6
  • 树的度：一棵树中，所有结点度的最大值称为树的度； 如上图：树的度为6
  • 叶子结点或终端结点：度为0的结点称为叶结点； 如上图：B、C、H、I...等节点为叶结点
  • 双亲结点或父结点：若一个结点含有子结点，则这个结点称为其子结点的父结点； 如上图：A是B的父结点
  • 孩子结点或子结点：一个结点含有的子树的根结点称为该结点的子结点； 如上图：B是A的孩子结点
  • 根结点：一棵树中，没有双亲结点的结点；如上图：A 结点的层次：从根开始定义起，根为第1层，根的子结点为第2层，以此类推
  • 树的高度或深度：树中结点的最大层次； 如上图：树的高度为4 树的

以下概念只需了解，只要知道是什么意思即可

  • 非终端结点或分支结点：度不为0的结点； 如上图：D、E、F、G...等节点为分支结点
  • 兄弟结点：具有相同父结点的结点互称为兄弟结点； 如上图：B、C是兄弟结点
  • 堂兄弟结点：双亲在同一层的结点互为堂兄弟；如上图：H、I互为兄弟结点
  • 结点的祖先：从根到该结点所经分支上的所有结点；如上图：A是所有结点的祖先
  • 子孙：以某结点为根的子树中任一结点都称为该结点的子孙。如上图：所有结点都是A的子孙
  • 森林：由m（m>=0）棵互不相交的树组成的集合称为森林

树的基础定义方法：(孩子兄弟法)

树的实际应用一般是在文件夹这种结构~

2.二叉树

2.1 二叉树概念

一棵二叉树是结点的一个有限集合，该集合：1. 为空 2. 或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成。

上面是二叉树的结构图，可以看出在二叉树中，一个节点不会大于2个度，而且二叉树还有左右子树之分，所以二叉树也是一个有顺序的数~~

二叉树也可以看作一下几个小结构组合而成的

这个是现实中存在的二叉树~~~

2.2 两种特殊的二叉树

  1. 满二叉树: 一棵二叉树，如果每层的结点数都达到最大值，则这棵二叉树就是满二叉树。也就是说，如果一棵 二叉树的层数为K，且结点总数是 2^k - 1，则它就是满二叉树。
  2. 完全二叉树: 完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n 个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从0至n-1的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。

满二叉树还要求结点数为：2^k - 1(k为层数),我们可以看到画的第一个二叉树是有三层的也就是2^3-1 = 8-1=7，正好和节点数一样~所以我们可以认为只要每个结点都有与之对应的左子树和右子树就是一个满二叉树~~

而且上面的完全二叉树其实也能算是从左往右的，因为完全二叉树要求结点必须包含左右子树，所以一定是满足从左往右的~

2.3 二叉树的性质

    1. 若规定根结点的层数为1，则一棵非空二叉树的第i层上最多有2^i - 1 (i>0)个结点
    1. 若规定只有根结点的二叉树的深度为1，则深度为K的二叉树的最大结点数是 2^k - 1(k>=0)
    1. 对任何一棵二叉树, 如果其叶结点个数为 n0, 度为2的非叶结点个数为 n2,则有n0＝n2＋1
    1. 具有n个结点的完全二叉树的深度k为 log2(n+1) 上取整
    1. 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的顺序对所有节点从0开始编号，则对于序号为i 的结点有：
  • 若i>0，双亲序号：(i-1)/2；i=0，i为根结点编号，无双亲结点
  • 若2i+1，左孩子序号：2i+1，否则无左孩子
  • 若2i+2，右孩子序号：2i+2，否则无右孩子

2.4 二叉树的存储

二叉树的存储结构分为：顺序存储和类似于链表的链式存储，这里先讲一下链式存储

以上是两个比较常用的定义方法~ 这里先使用孩子表示法去讲解~~

2.5 二叉树的创建

这里为了方便了解二叉树结构，先用通俗易懂的方式去创建一个二叉树，后续再去单独说明一下二叉树真正该如何创建~

java 复制代码 
static class TreeNode{
        char val;//值
        TreeNode left;//左子树
        TreeNode right;//右子树
        
        public TreeNode(char val){
            this.val = val;
        }
    }

public TreeNode createBinaryTree() {
        TreeNode A = new TreeNode('A');
        TreeNode B = new TreeNode('B');
        TreeNode C = new TreeNode('C');
        TreeNode D = new TreeNode('D');
        TreeNode E = new TreeNode('E');
        TreeNode F = new TreeNode('F');
        TreeNode G = new TreeNode('G');

        A.left = B;
        A.right = C;//A左树为B，右树为C
        B.left = D;
        B.right = E;//B左数为D，右树为E
        C.left = F;
        C.right = G;//C左数为F，右树为G

        return A;//返回根节点为了后面遍历等等操作
    }

这课树创建出来为：

前面说过二叉树是递归式的~后续操作都需要依赖递归哦~~不过我会很详细去拆解每一步的递归的

2.6 二叉树的遍历

二叉树的遍历是沿着某条搜索路线，依次对树中每个结 点均做一次且仅做一次访问。

即便是遍历操作我们仍需要递归去实现~

2.6.1 各种遍历的核心逻辑

如果N代表根节点，L代表根节点的 左子树，R代表根节点的右子树，则根据遍历根节点的先后次序有以下遍历方式：

  • 前序遍历(NLR)：遵循根节点->左子树->右子树的顺序去遍历
  • 中序遍历(LNR)：遵循左子树->根节点->右子树的顺序去遍历
  • 后序遍历(LRN)：遵循左子树->右子树->根节点的顺序去遍历
  • 层序遍历：这个是一个特殊遍历，是从上到下，从左往右依次遍历

我们如果以数组的思想的话，遍历一条线就终止了也就是说只能一直处理左子树，遇到右子树(分叉的不是一条线)的话，如果树不是完全二叉树，数组会有大量空位。插入或删除节点可能引起数组大量元素的移动（要保持数组连续性），时间复杂度高。所以前人在处理二叉树的很多操作时会选择递归，数组只有在少部分情况下才能发挥出来。

而递归是分为递和归两个概念的

递是从当前问题向更小规模的子问题深入不断调用自身，向"递归深处"前进直到遇到递归终止条件

归则是从最小子问题的解开始返回逐层向上回溯，将子问题的结果组合成原问题的解，回到最初的调用点。

以下遍历均使用下面这个二叉树演示：

2.6.2 前序遍历

在上面已经知道前序遍历是根-左子树-右子树的顺序遍历的，这里我们来画图演示一下递归过程

以上n指的是null，表示一个空节点~ 我们来看看前序遍历后打印的节点~

先从根出发，拿到A开始递左子树，然后递到B继续递左子树，拿到D继续递左子树,发现左子树为null,归一步回到D,然后递右子树发现为null,归到D,D的左右子树都遍历过,继续归到B,B的左子树D遍历完了直接遍历右子树拿到E再去右子树拿到H,然后H左右子树都是null继续归........后面就一直是这样子~最后拿到ABDEHCFG

上面就是递归的思路了,接下来开始尝试使用代码去实现~

java 复制代码 
public class day1_Tree {

    static class TreeNode {
        char val;//值
        TreeNode left;//左子树
        TreeNode right;//右子树

        public TreeNode(char val) {
            this.val = val;
        }
    }

    // 创建二叉树的方法
    public TreeNode createBinaryTree() {
        TreeNode A = new TreeNode('A');
        TreeNode B = new TreeNode('B');
        TreeNode C = new TreeNode('C');
        TreeNode D = new TreeNode('D');
        TreeNode E = new TreeNode('E');
        TreeNode F = new TreeNode('F');
        TreeNode G = new TreeNode('G');
        TreeNode H = new TreeNode('H');

        A.left = B;
        A.right = C;//A左树为B，右树为C
        B.left = D;
        B.right = E;//B左数为D，右树为E
        C.left = F;
        C.right = G;//C左数为F，右树为G
        E.right = H;

        return A;//返回根节点为了后面遍历等等操作
    }

    /**
     * 前序遍历
     * @param root 根节点
     */
    public void perOrder(TreeNode root) {
        //遇到空节点就归
        if (root == null) return;
        //根-左-右(根就打印)
        System.out.print(root.val + " ");
        //递归左右边
        perOrder(root.left);//根节点左边
        perOrder(root.right);//根节点右边
    }

    public static void main(String[] args) {
        day1_Tree tree = new day1_Tree();

        // 1. 创建二叉树
        TreeNode root = tree.createBinaryTree();

        //前序遍历
        System.out.print("前序遍历: ");
        tree.perOrder(root);
        System.out.println();
    }
}

以上就是递归版本的前序遍历实现了~ 主要需要看懂上面所画的递归图，也可以自己尝试画一下~

2.6.3 中序遍历

有了前序遍历的递归经验，前序是根-左-右，中序是左-根-右这个是前序遍历，根-左-右

那我们可以：

perOrder(root.left);-------------------左

System.out.print(root.val + " ");---根

perOrder(root.right);-----------------右

是不是就是前序转换成中序啦？当然，这样绝对没有问题，但是我们还是要按照正统来：去画图看看是怎么递归的！！！

上面就是递归的过程啦~接下来写代码吧~

java 复制代码 
public class day1_Tree {

    static class TreeNode {
        char val;//值
        TreeNode left;//左子树
        TreeNode right;//右子树

        public TreeNode(char val) {
            this.val = val;
        }
    }

    // 创建二叉树的方法
    public TreeNode createBinaryTree() {
        TreeNode A = new TreeNode('A');
        TreeNode B = new TreeNode('B');
        TreeNode C = new TreeNode('C');
        TreeNode D = new TreeNode('D');
        TreeNode E = new TreeNode('E');
        TreeNode F = new TreeNode('F');
        TreeNode G = new TreeNode('G');
        TreeNode H = new TreeNode('H');

        A.left = B;
        A.right = C;//A左树为B，右树为C
        B.left = D;
        B.right = E;//B左数为D，右树为E
        C.left = F;
        C.right = G;//C左数为F，右树为G
        E.right = H;

        return A;//返回根节点为了后面遍历等等操作
    }

    /**
     * 前序遍历
     * @param root 根节点
     */
    public void perOrder(TreeNode root) {
        //遇到空节点就归
        if (root == null) return;
        //根-左-右(根就打印)
        System.out.print(root.val + " ");
        //递归左右边
        perOrder(root.left);//根节点左边
        perOrder(root.right);//根节点右边
    }

    /**
     * 中序遍历
     * @param root
     */
    public void inOrder(TreeNode root){
        if(root == null) return;
        inOrder(root.left);
        System.out.print(root.val+" ");
        inOrder(root.right);
    }

    public static void main(String[] args) {
        day1_Tree tree = new day1_Tree();

        // 1. 创建二叉树
        TreeNode root = tree.createBinaryTree();

        //前序遍历
        System.out.print("前序遍历: ");
        tree.perOrder(root);
        System.out.println();

        //中序遍历
        System.out.print("中序遍历：");
        tree.inOrder(root);
        System.out.println();
    }
}

2.6.4 后序遍历

根据前面的中序遍历的代码：

perOrder(root.left);-------------------左

System.out.print(root.val + " ");---根

perOrder(root.right);-----------------右

转为后序的左-右-根就是：

perOrder(root.left);-------------------左

perOrder(root.right);-----------------右

System.out.print(root.val + " ");---根

我们来看看具体的遍历过程~

java 复制代码 
public class day1_Tree {

    static class TreeNode {
        char val;//值
        TreeNode left;//左子树
        TreeNode right;//右子树

        public TreeNode(char val) {
            this.val = val;
        }
    }

    // 创建二叉树的方法
    public TreeNode createBinaryTree() {
        TreeNode A = new TreeNode('A');
        TreeNode B = new TreeNode('B');
        TreeNode C = new TreeNode('C');
        TreeNode D = new TreeNode('D');
        TreeNode E = new TreeNode('E');
        TreeNode F = new TreeNode('F');
        TreeNode G = new TreeNode('G');
        TreeNode H = new TreeNode('H');

        A.left = B;
        A.right = C;//A左树为B，右树为C
        B.left = D;
        B.right = E;//B左数为D，右树为E
        C.left = F;
        C.right = G;//C左数为F，右树为G
        E.right = H;

        return A;//返回根节点为了后面遍历等等操作
    }

    /**
     * 前序遍历
     * @param root 根节点
     */
    public void perOrder(TreeNode root) {
        //遇到空节点就归
        if (root == null) return;
        //根-左-右(根就打印)
        System.out.print(root.val + " ");
        //递归左右边
        perOrder(root.left);//根节点左边
        perOrder(root.right);//根节点右边
    }

    /**
     * 中序遍历
     * @param root
     */
    public void inOrder(TreeNode root){
        if(root == null) return;
        inOrder(root.left);
        System.out.print(root.val+" ");
        inOrder(root.right);
    }

    /**
     *
     * @param root
     */
    public void postOrder(TreeNode root){
        if(root == null) return;
        postOrder(root.left);
        postOrder(root.right);
        System.out.print(root.val+" ");
    }


    public static void main(String[] args) {
        day1_Tree tree = new day1_Tree();

        // 1. 创建二叉树
        TreeNode root = tree.createBinaryTree();

        //前序遍历
        System.out.print("前序遍历: ");
        tree.perOrder(root);
        System.out.println();

        //中序遍历
        System.out.print("中序遍历：");
        tree.inOrder(root);
        System.out.println();

        //后序遍历
        System.out.print("后序遍历：");
        tree.postOrder(root);
        System.out.println();
    }
}

2.6.5 层序遍历

层序遍历就比较特殊了~不能从上面的递归直接套换，层序遍历是从上到下从左到右去遍历的，也就是每一层去打印~

这里我们联合到之前讲过的队列知识（队列元素是先进后出），与我们现在遇到的层序遍历的情况很相似，可以直接使用队列来解决这个问题~

来上代码感受一下~

java 复制代码 
import com.sun.source.tree.Tree;

import java.util.LinkedList;
import java.util.Queue;

public class day1_Tree {

    static class TreeNode {
        char val;//值
        TreeNode left;//左子树
        TreeNode right;//右子树

        public TreeNode(char val) {
            this.val = val;
        }
    }

    // 创建二叉树的方法
    public TreeNode createBinaryTree() {
        TreeNode A = new TreeNode('A');
        TreeNode B = new TreeNode('B');
        TreeNode C = new TreeNode('C');
        TreeNode D = new TreeNode('D');
        TreeNode E = new TreeNode('E');
        TreeNode F = new TreeNode('F');
        TreeNode G = new TreeNode('G');
        TreeNode H = new TreeNode('H');

        A.left = B;
        A.right = C;//A左树为B，右树为C
        B.left = D;
        B.right = E;//B左数为D，右树为E
        C.left = F;
        C.right = G;//C左数为F，右树为G
        E.right = H;

        return A;//返回根节点为了后面遍历等等操作
    }

    /**
     * 前序遍历
     * @param root 根节点
     */
    public void perOrder(TreeNode root) {
        //遇到空节点就归
        if (root == null) return;
        //根-左-右(根就打印)
        System.out.print(root.val + " ");
        //递归左右边
        perOrder(root.left);//根节点左边
        perOrder(root.right);//根节点右边
    }

    /**
     * 中序遍历
     * @param root
     */
    public void inOrder(TreeNode root){
        if(root == null) return;
        inOrder(root.left);
        System.out.print(root.val+" ");
        inOrder(root.right);
    }

    /**
     *后序遍历
     * @param root
     */
    public void postOrder(TreeNode root){
        if(root == null) return;
        postOrder(root.left);
        postOrder(root.right);
        System.out.print(root.val+" ");
    }

    /**
     * 层序遍历
     * @param root
     */
    public void levelOrder(TreeNode root){
        if(root == null) return;
        Queue<TreeNode> qu = new LinkedList<>();
        qu.offer(root);//根入栈
        while (!qu.isEmpty()){//队列不为空时
            TreeNode cur = qu.poll();//出栈给到cur并且打印
            System.out.print(cur.val+" ");
            if(cur.left!=null){
                //只要cur的左子树不为空就入队列
                qu.offer(cur.left);
            }
            if(cur.right!=null){
                qu.offer(cur.right);
            }
        }
    }

    public static void main(String[] args) {
        day1_Tree tree = new day1_Tree();

        // 1. 创建二叉树
        TreeNode root = tree.createBinaryTree();

        //前序遍历
        System.out.print("前序遍历: ");
        tree.perOrder(root);
        System.out.println();

        //中序遍历
        System.out.print("中序遍历：");
        tree.inOrder(root);
        System.out.println();

        //后序遍历
        System.out.print("后序遍历：");
        tree.postOrder(root);
        System.out.println();

        //层序遍历
        System.out.print("层序遍历：");
        tree.levelOrder(root);
        System.out.println();
    }
}

以上就是二叉树的基础知识啦~~如果有什么疑问或者上述有什么不对的地方欢迎评论区交流交流~

点点关注~以后会有更多干货分享~

相关推荐
CodeByV2 小时前
【算法题】前缀和
算法
高洁012 小时前
知识图谱构建
人工智能·深度学习·算法·机器学习·知识图谱
郝亚军2 小时前
顺序栈C语言版本
c语言·开发语言·算法
青衫码上行2 小时前
【JavaWeb学习 | 第23篇】监听器、RBAC权限模型
java·学习·servlet·jsp
Cowboy hat2 小时前
数据结构基础（二）：线性数据结构
数据结构
AndrewHZ2 小时前
【图像处理基石】什么是神经渲染？
图像处理·人工智能·神经网络·算法·cnn·计算机图形学·神经渲染
2401_841495642 小时前
【LeetCode刷题】爬楼梯
数据结构·python·算法·leetcode·动态规划·滑动窗口·斐波那契数列
宋情写2 小时前
Springboot基础篇01-创建一个SpringBoot项目
java·spring boot·后端
byzh_rc2 小时前
[模式识别-从入门到入土] 组合分类器
人工智能·算法·机器学习·支持向量机·概率论
热门推荐
01GitHub 镜像站点02从快手“12·22”直播攻击事件看：一次教科书式的业务层饱和攻击033D 圣诞树网页代码04UV安装并设置国内源05Linux下V2Ray安装配置指南06Gemini3 生成的基于手势控制3D粒子圣诞树07在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）08解决 WSL Ubuntu 中 /etc/resolv.conf 自动重置问题09开源分享 | 超浪漫 3D 圣诞树立体动画（附零基础使用教程）10GLM-4.7 vs MiniMax-M2.1：代码工程理解