【数据结构】二叉树

最新推荐文章于 2024-07-04 15:52:39 发布
最新推荐文章于 2024-07-04 15:52:39 发布
阅读量249 收藏
点赞数
分类专栏： 数据结构和算法 文章标签： 数据结构 java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/green1997/article/details/125467211
版权

文章目录

1 相同的树

在这里插入图片描述

public class Code02_SameTree {

    public static class TreeNode {
        public int val;
        public TreeNode left;
        public TreeNode right;
    }

    public static boolean isSameTree(TreeNode p, TreeNode q) {
        // 一个为空 一个不为空
        if (p == null ^ q == null) {
            return false;
        }
        
        // 都为空
        if (p == null) {
            return true;
        }

        // 值相同且左右子树都相同
        return p.val == q.val && isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
    }
}

2 对称二叉树

在这里插入图片描述

public class Code03_SymmetricTree {
    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode() {}
        TreeNode(int val) { this.val = val; }
        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }

    public static boolean isSymmetric(TreeNode root) {
        return isMirror(root, root);
    }

    private static boolean isMirror(TreeNode p, TreeNode q) {
        if (p == null ^ q == null) {
            return false;
        }

        if (p == null) {
            return true;
        }

        return p.val == q.val && isMirror(p.left, q.right) && isMirror(p.right, q.left);
    }
}

3 二叉树的最大深度

在这里插入图片描述

public class Code04_MaximumDepthOfBinaryTree {
    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode() {}
        TreeNode(int val) { this.val = val; }
        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }

    public static int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }

        return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
    }
}

4 从前序与中序遍历序列构造二叉树

在这里插入图片描述

public class Code05_ConstructBinaryTreeFromPreorderAndInorderTraversal {

    public static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

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

    public static TreeNode buildTree(int[] preorder, int[] inorder) {
        if (preorder == null || inorder == null || preorder.length != inorder.length) {
            return null;
        }

        Map<Integer, Integer> inMap = new HashMap<>(inorder.length);
        for (int i = 0; i < inorder.length; i++) {
            inMap.put(inorder[i], i);
        }

        return buildTree(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1, inMap);
    }

    public static TreeNode buildTree(int[] preorder, int pL, int pR,
                                     int[] inorder, int iL, int iR, Map<Integer, Integer> inMap) {
        if (pL > pR) {
            return null;
        }

        // 只有一个值
        TreeNode head = new TreeNode(preorder[pL]);
        if (pL == pR) {
            return head;
        }

        // 中序遍历的根节点索引
        Integer iRoot = inMap.get(preorder[pL]);
        head.left = buildTree(preorder, pL + 1, pL + iRoot - iL, inorder, iL, iRoot - 1, inMap);
        head.right = buildTree(preorder, pL + iRoot - iL + 1, pR, inorder, iRoot + 1, iR, inMap);

        return head;
    }
}

5 二叉树的层序遍历

在这里插入图片描述

public class Code02_BalancedBinaryTree {
    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode() {}
        TreeNode(int val) { this.val = val; }
        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }

    public static class Info {
        /**
         * 高度.
         */
        private int height;

        /**
         * 是否平衡.
         */
        private boolean isBalanced;

        public Info(int height, boolean isBalanced) {
            this.height = height;
            this.isBalanced = isBalanced;
        }
    }

    public static boolean isBalanced(TreeNode root) {
        return process(root).isBalanced;
    }

    /**
     * 返回 node 节点的平衡信息和高度信息.
     */
    public static Info process(TreeNode node) {
        if (node == null) {
            return new Info(0, true);
        }

        // 左右子树的平衡信息
        Info lInfo = process(node.left);
        Info rInfo = process(node.right);

        // 当前节点高度信息
        int height = Math.max(lInfo.height, rInfo.height) + 1;
        // 当前节点平衡信息
        boolean isBalanced = lInfo.isBalanced && rInfo.isBalanced && Math.abs(lInfo.height - rInfo.height) < 2;

        return new Info(height, isBalanced);
    }
}

6 是否是平衡二叉树

在这里插入图片描述

public class Code02_BalancedBinaryTree {
    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode() {}
        TreeNode(int val) { this.val = val; }
        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }

    public static class Info {
        /**
         * 高度.
         */
        private int height;

        /**
         * 是否平衡.
         */
        private boolean isBalanced;

        public Info(int height, boolean isBalanced) {
            this.height = height;
            this.isBalanced = isBalanced;
        }
    }

    public static boolean isBalanced(TreeNode root) {
        return process(root).isBalanced;
    }

    /**
     * 返回 node 节点的平衡信息和高度信息.
     */
    public static Info process(TreeNode node) {
        if (node == null) {
            return new Info(0, true);
        }

        // 左右子树的平衡信息
        Info lInfo = process(node.left);
        Info rInfo = process(node.right);

        // 当前节点高度信息
        int height = Math.max(lInfo.height, rInfo.height) + 1;
        // 当前节点平衡信息
        boolean isBalanced = lInfo.isBalanced && rInfo.isBalanced && Math.abs(lInfo.height - rInfo.height) < 2;

        return new Info(height, isBalanced);
    }
}

7 路径总和

在这里插入图片描述

public class Code03_PathSum {

    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode() {}
        TreeNode(int val) { this.val = val; }
        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }

    public static boolean isSum;

    public static boolean hasPathSum(TreeNode root, int targetSum) {
        if (root == null) {
            return false;
        }

        isSum = false;
        process(root, 0, targetSum);
        return isSum;
    }

    /**
     * 方法1 
     */
    public static void process(TreeNode node, int preSum, int targetSum) {
        // 叶子节点
        if (node.left == null && node.right == null) {
            if (preSum + node.val == targetSum) {
                isSum = true;
            }
            // 叶子返回
            return;
        }

        // 路径和
        preSum += node.val;
        if (node.left != null) {
            process(node.left, preSum, targetSum);
        }
        if (node.right != null) {
            process(node.right, preSum, targetSum);
        }
    }

    /**
     * 方法2 
     */
    public static boolean process(TreeNode node, int sum) {
        // 叶子节点
        if (node.left == null && node.right == null) {
            return node.val == sum;
        }

        // 非叶子节点
        boolean ans = node.left != null && process(node.left, sum - node.val);
        ans |= (node.right != null && process(node.right, sum - node.val));
        return ans;
    }
}

8 路径总和 II

在这里插入图片描述

public class Code04_PathSumII {

    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode() {}
        TreeNode(int val) { this.val = val; }
        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }

    public static List<List<Integer>> pathSum(TreeNode root, int targetSum) {
        List<List<Integer>> ans = new ArrayList<>();
        if (root == null) {
            return ans;
        }

        process(root, new ArrayList<>(), 0, targetSum, ans);
        return ans;
    }

    public static void process(TreeNode node, List<Integer> path,
                               int preSum, int targetSum, List<List<Integer>> ans) {
        // 叶子节点
        if (node.left == null && node.right == null) {
            if (node.val + preSum == targetSum) {
                path.add(node.val);
                ans.add(new ArrayList<>(path));
                // 恢复路径
                path.remove(path.size() - 1);
            }
            return;
        }

        // 非叶子节点
        path.add(node.val);
        preSum += node.val;
        if (node.left != null) {
            process(node.left, path, preSum, targetSum, ans);
        }
        if (node.right != null) {
            process(node.right, path, preSum, targetSum, ans);
        }
        // 恢复路径
        path.remove(path.size() - 1);
    }
}

9 是否是二叉搜索树

在这里插入图片描述

public class Code05_IsBinarySearchTree {

    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode() {
        }

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

        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }

    public static class Info {
        private boolean isBST;
        private int max;
        private int min;

        public Info(boolean isBST, int max, int min) {
            this.isBST = isBST;
            this.max = max;
            this.min = min;
        }
    }

    public static boolean isValidBST(TreeNode node) {
        if (node == null) {
            return true;
        }

        return process(node).isBST;
    }

    public static Info process(TreeNode node) {
        if (node == null) {
            return null;
        }

        Info lInfo = process(node.left);
        Info rInfo = process(node.right);

        // 当前节点的最大最小值
        int max = node.val;
        int min = node.val;
        if (lInfo != null) {
            max = Math.max(lInfo.max, max);
            min = Math.min(lInfo.min, min);
        }
        if (rInfo != null) {
            max = Math.max(rInfo.max, max);
            min = Math.min(rInfo.min, min);
        }


        boolean isLeftBST = lInfo == null || lInfo.isBST;
        boolean isRightBSt = rInfo == null || rInfo.isBST;
        boolean isLeftMaxLess = lInfo == null || lInfo.max < node.val;
        boolean isRightMinMore = rInfo == null || rInfo.min > node.val;

        boolean isBST = isLeftBST && isRightBSt && isLeftMaxLess && isRightMinMore;

        return new Info(isBST, max, min);
    }
}
movYou521
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
正弦定理的博客
12-09 35万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：3 2 2 3 8 6 5 4 中序遍历：2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 三种遍历不同之处在，输出数据放在不同之处 三、代码展示： #include<stdio.h> #include<stdlib.h> typedef struct Tree{ int
【数据结构】——二叉树详解
热门推荐
atwdy的博客
07-28 4万+
二叉树(Binary Tree)是由n个结点构成的有限集(n≥0)，n=0时为空树，n>0时为非空树。对于非空树TTT有且仅有一个根结点；除根结点外的其余结点又可分为两个不相交的子集TLT_LTL​和TRT_RTR​，分别称为TTT的左子树和右子树，且TLT_LTL​和TRT_RTR​本身又都是二叉树。很明显该定义属于递归定义，所以有关二叉树的操作使用递归往往更容易理解和实现。从定义也可以看出二叉树与一般树的区别主要是两点，一是每个结点的度最多为2；
数据结构之二叉树
qq_37080455的博客
06-27 5934
1、基本概念：树就是一种类似现实生活中的树的数据结构（倒置的树）。任何一颗非空树只有一个根节点。2、一棵树具有以下特点：3、树的形状如下图所示： 4、区别： 层数：从根节点开始算，为第一层。 高度：从最下面的叶子节点开始算，且从0开始计数。 深度：从根节点开始算，从0开始计数。树的基本名词解释：二叉树（Binary tree）是每个节点最多只有两个分支（即不存在分支度大于 2 的节点）的树结构。二叉树 的分支通常被称作“左子树”或“右子树”。并且，二叉树 的分支具有
数据结构二叉树功能展示
06-02
数据结构二叉树功能展示包括以完全前序序列创建二叉树"; cout以前序和中序序列创建二叉树"; cout前序遍历二叉树"; cout中序遍历二叉树"; cout后序遍历二叉树"; cout广度优先遍历二叉树"; cout求某结点的双亲";...
头歌数据结构二叉树的顺序存储及基本操作
05-18
头歌数据结构二叉树的顺序存储及基本操作 第1关树和二叉树基本概念 第2关二叉树的顺序存储及基本操作 在计算机科学中，二叉树是每个节点最多只有两个分支的树结构，即每个节点的分支度不大于2。通常分支被称作左...
数据结构 二叉树
03-20
数据结构题目和答案，数据结构 二叉树，内有题目以及答案
c++数据结构二叉树
01-06
数据结构课程设计 1. 创建二叉树的链表存储结构； 2． 实现二叉链表的初始化算法、二叉树空的判断算法； 3． 实现二叉树的先序遍历算法、中序遍历算法和后序遍历算法； 4． 利用某遍历算法实现计算二叉树中叶子结点...
数据结构二叉树家谱
12-17
数据结构二叉树家谱：文件操作功能，家谱操作功能
数据结构(3.3)——栈的链式存储结构
m0_65240792的博客
06-30 232
采用链式存储的栈成为链栈的优点是便于多个栈共享存储空间和提高其效率，且。通常采用单链表实现。
数据结构-线性表的应用
pyc68的博客
07-02 893
本篇文章介绍线性表的应用，分别使用顺序表和单链表实现有序表的合并，最后介绍如何使用单链表实现两个稀疏多项式的相加和相乘。
【数据结构之B树的讲解】
cz88888888666的博客
07-01 394
它的广泛应用于数据库和文件系统中，可以加快数据的访问速度，并且能够适应频繁的数据更新操作。🚀B树是一个多路搜索树，每个节点可以拥有多个子节点。其中，根节点至少有两个子节点，除了根节点和叶节点之外的其他节点至少有。🚀B树通过自平衡操作来保持树的平衡性，保证每个节点存储的键的数量在一定范围内。🚀每个节点中的数据项按照键的排序顺序存储，并且每个数据项都包含一个指向其子节点的指针。🚀B树的所有叶节点都在同一层级，叶节点之间没有指针相连，通常通过根节点进行访问。是一个预先给定的正整数，称为B树的阶。
6-24 数据结构考题 - 顺序查找
Virgo_616的博客
07-01 251
6-24 数据结构考题 - 顺序查找
数据结构之二叉树概念
my_air的博客
07-01 596
主要解释二叉树，B-树的概念
数据结构第07节：队列
hummhumm的专栏
07-04 333
在计算机科学中，队列是一种抽象数据类型，它遵循先进先出（FIFO）原则，即最先加入队列的元素将是最先被移除的。在学生成绩管理系统中，队列可以用于管理等待处理的成绩更新请求，或者用于存储等待查询成绩的学生ID列表。请注意，这个实现假设所有学生ID都是整数，并且队列的大小是固定的。这个队列将用于管理学生的ID，模拟学生成绩管理系统中可能用到的队列操作。下面，我将以一个简单的学生成绩管理系统中的队列应用为例，用表格形式来详细讲解队列的操作和状态变化。类，它包含书籍的基本信息，例如书名、作者和ISBN号。
数据结构和顺序表
2302_79180171的博客
07-01 258
数据结构是相互之间存在一种或多种特定关系的数据元素的集合。线性表是具有相同数据类型的n(n>=0)个数据元素的有限序列。其中唯一的第一个数据元素称为表头元素唯一的最后一个元素称为表尾元素，除第一个元素外，每个元素有且仅有一个直接前驱，除最后一个元素外，每个元素有且仅有一个直接后继。
【高阶数据结构】B-数、B+树、B*树的原理
最新发布
稻草人敲代码的博客
07-04 393
B树：有序数组+平衡多叉树B+树：有序数组链表+平衡多叉树B*树：一棵更丰满的，空间利用率更高的B+树。
数据结构--顺序表
LH__1314的博客
06-30 1726
当我们想要使⽤大量使⽤同⼀类型的数据时，通过⼿动定义⼤量的独立的变量对于程序来说，可读性非常差，我们可以借助数组这样的数据结构将⼤量的数据组织在⼀起，结构也可以理解为组织数据的方式。在使用完顺序表后，就要销毁顺序表，因为动态顺序表内存是动态开辟的，所以需要对动态内存进行释放，并将有效数据和空间容量个数置为0；到这里，顺序表的知识就完成了，学完这些，我们也要写顺序表的实践，就是通讯录——在下一篇进行实现。求数组的长度，求数组的有效数据个数，向下标为数据有效个数的位置插入数据（注意：这里是。
数据结构二叉树优选ppt资料.ppt
12-01
"数据结构二叉树优选ppt资料.ppt" 这份资料主要涵盖了数据结构中的核心概念——二叉树。二叉树是数据结构中的一个重要组成部分，它是一种特殊的树形结构，每个节点最多有两个子节点，通常称为左子节点和右子节点。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值