Leetcode-二叉树刷题汇总

最新推荐文章于 2025-03-07 09:48:43 发布
最新推荐文章于 2025-03-07 09:48:43 发布
阅读量385 收藏
点赞数
文章标签： leetcode 深度优先 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/xz_4321/article/details/126175664
版权

二叉数-前序遍历


使用迭代与递归完成 

import java.util.*;

/**
 * @auther SQ
 */
public class TreeTestDemo {

    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.left.left = new TreeNode(3);
        root.right = new TreeNode(4);
        root.right.left = new TreeNode(5);
        root.right.right = new TreeNode(6);
        // 前序遍历
        List<Integer> preRes = perOrder(root);
        List<Integer> preDfsRes = perOrderDfs(root);
        System.out.println("迭代前序遍历"+preRes);
        System.out.println("dfs前序遍历"+preDfsRes);

        List<Integer> inRes = inOrder(root);
        List<Integer> inDfsRes = inOrderDfs(root);
        System.out.println("迭代中序遍历"+inRes);
        System.out.println("dfs中序遍历"+inDfsRes);

        List<Integer> postRes = postOrder(root);
        List<Integer> postDfsRes = postOrderDfs(root);
        System.out.println("迭代中序遍历"+postRes);
        System.out.println("迭代后序遍历"+postDfsRes);
    }


    /**
     * 前序遍历
     *
     * @param root
     * @return
     */
    public static List<Integer> perOrder(TreeNode root) {
        if (root == null) {
            return null;
        }
        Stack<TreeNode> stack = new Stack<>();
        List<Integer> res = new ArrayList<>();
        while (stack.size() != 0 || root != null) {
            // 前序遍历的顺序 ： root - left - right
            if (root != null) {
                stack.push(root);
                res.add(root.val);
                root = root.left;
            } else {
                root = stack.pop();
                root = root.right;
            }
        }
        return res;
    }

    /**
     * 前序遍历 使用递归
     * root -> left -> right
     *
     * @param root
     * @return
     */
    public static List<Integer> perOrderDfs(TreeNode root) {
        if (root == null) {
            return null;
        }
        List<Integer> res = new ArrayList<>();
        perDfs(root, res);
        return res;
    }

    public static void perDfs(TreeNode root, List<Integer> res) {
        if (root == null) {
            return;
        }
        //root -> left -> right
        res.add(root.val);
        perDfs(root.left,res);
        perDfs(root.right,res);
    }

}

二叉数-中序遍历


使用迭代与递归完成 

 /**
     * 中序遍历
     *
     * @param root
     * @return
     */
    public static List<Integer> inOrder(TreeNode root) {
        if (root == null) {
            return null;
        }
        Stack<TreeNode> stack = new Stack<>();
        List<Integer> res = new ArrayList<>();
        while (stack.size() != 0 || root != null) {
            // 中序遍历: left - root - right
            if (root != null) {
                stack.push(root);
                root = root.left;
            } else {
                root = stack.pop();
                res.add(root.val);
                root = root.right;
            }
        }
        return res;
    }

    /**
     * 中序遍历 递归方式
     * @param root
     * @return
     */
    public static List<Integer> inOrderDfs(TreeNode root) {
        if(root == null){
            return null;
        }
        List<Integer> res = new ArrayList<>();
        inDfs(root,res);
        return res;
    }

    public static void inDfs(TreeNode root,List<Integer> res){
        if(root == null){
            return;
        }
        // 中序排序  left -> root -> right
        inDfs(root.left,res);
        res.add(root.val);
        inDfs(root.right,res);
    }

二叉数-后序遍历


使用迭代与递归完成 

    /**
     * 后序遍历  [3, 2, 5, 6, 4, 1]
     *
     * @param root
     * @return
     */
    public static List<Integer> postOrder(TreeNode root) {
        if (root == null) {
            return null;
        }
        Stack<TreeNode> stack = new Stack<>();
        List<Integer> res = new ArrayList<>();
        while (stack.size() != 0 || root != null) {
            // 后序遍历:   left - right - root
            // 思路 反正取数 先取root 在去右边  在去左边  最后在反转
            if (root != null) {
                res.add(root.val);
                stack.push(root);
                root = root.right;
            } else {
                root = stack.pop();
                root = root.left;
            }
        }
        Collections.reverse(res);
        return res;
    }

    /**
     * 后序遍历 递归方式
     * @param root
     * @return
     */
    public static List<Integer> postOrderDfs(TreeNode root) {
        if(root == null){
            return null;
        }
        List<Integer> res = new ArrayList<>();
        postDfs(root,res);
        return res;
    }

    public static void postDfs(TreeNode root,List<Integer> res){
        if(root == null){
            return;
        }
        // 后序排序  left  -> right -> root
        postDfs(root.left,res);
        postDfs(root.right,res);
        res.add(root.val);
    }

二叉数-leetcode98验证二叉搜索树

在这里插入图片描述

class Solution {
	/**
	*题意要求范围Integer.MIN_VALUE - Integer.MAX_VALUE范围内，所以选择long型
	* long范围 -2^64 ~ 2^64-1
	* int范围 -2^31 ~ 2^64-1
	**/
   public boolean isValidBST(TreeNode root) {
        return dfs(root,Long.MIN_VALUE,Long.MAX_VALUE);
    }

    public boolean dfs(TreeNode root,long lower,long upper) {
        if(root == null){
            return true;
        }
       	//结束条件 当前节点的值小于最小值或者大于最大值则返回false
        if(root.val <= lower || root.val >= upper){
            return false;
        }
        
        return dfs(root.left,lower,root.val) && dfs(root.right, root.val, upper);
       
    }
	//使用中序遍历
 	public boolean isValidBST01(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        List<Integer> res = new ArrayList<>();
        while (root != null || !stack.isEmpty() ) {
            if (root != null) {
                stack.push(root);
                root = root.left;
            } else {
                root = stack.pop();
                if(!res.isEmpty()){
                    if(root.val <= res.get(res.size()-1)){
                        return false;
                    }
                }
                res.add(root.val);
                root = root.right;
            }

        }
        return true;
    }

}

二叉数-leetcode102. 二叉树的层序遍历


在这里插入图片描述

BFS 遍历：BFS（广度优先搜索）「层序遍历」
BFS 遍历使用队列数据结构

class Solution {

    public List<List<Integer>> levelOrder(TreeNode root) {
        // 使用BFS 广度优先搜索
        // 使用队列
        List<List<Integer>> ans = new ArrayList<>();
        if(root == null){
            return ans;
        }
        Queue<TreeNode> queue = new ArrayDeque<>();
        queue.add(root);
        while (queue.size() != 0) {
            List<Integer> res = new ArrayList<>();
            int n = queue.size();
            for (int i = 0; i < n; i++) {
                TreeNode poll = queue.poll();
                res.add(poll.val);
                if (poll.left != null) {
                    queue.add(poll.left);
                }
                if (poll.right != null) {
                    queue.add(poll.right);
                }
            }
            ans.add(res);
        }

        return ans;
    }

}

二叉数-leetcode105. 前序遍历与中序遍历构造二叉树


在这里插入图片描述
需要对前序遍历与中序遍历熟悉，文字最先放置了二叉树三种遍历方式的代码。 

/**
 * Definition for a binary tree node.
 * 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;
 *     }
 * }
 */
class Solution {

public TreeNode buildTree(int[] preorder, int[] inorder) {
        return dfs(preorder, 0, preorder.length,
                inorder, 0, inorder.length);
    }

    public TreeNode dfs(int[] preorder, int p_start, int p_end, int[] inorder, int i_start, int i_end) {
        //1 根据前序(3,9,20,15,7)能确定根节点为3
        if (p_start == p_end) {
            return null;
        }
        // 找到根节点的值，构造root
        int root_val = preorder[p_start];
        TreeNode root = new TreeNode(root_val);

        // 使用root的val在inorder找到root节点
        // inorder中的root的左边就是left节点的个数
        int leftVal = -1;
        for (int i = i_start; i < i_end; i++) {
            if (inorder[i] == root_val) {
                leftVal = i;
                break;
            }
        }
        // 左子节点的个数
        int leftNum = leftVal - i_start;
        // 构造左子节点
        TreeNode leftNode = dfs(preorder, p_start + 1, p_start + 1 + leftNum, inorder, i_start, leftVal);
        root.left = leftNode;
        TreeNode rightNode = dfs(preorder, p_start + 1 + leftNum, p_end, inorder, leftVal + 1, i_end);
        root.right = rightNode;
        return root;
    }
}
xz_4321
关注
LeetCode总结二叉树类题目
Just Do It!
01-16 678
二叉树最大深度 题目：https://leetcode.com/problems/maximum-depth-of-binary-tree/ 武器：二叉树，不是BST。思路一样。既然是深度，利用BFS，因为广度优先搜索是每层扫描的。 结果：一次通过 有序数组构建平衡二叉树 题目：https://leetcode.com/problems/convert-sorted-array-to-b...
刷算法Leetcode---8（二叉树篇）（层序遍历）
m0_70220973的博客
07-01 844
Leetcode刷算法之二叉树篇（层序遍历）~
leetcode 二叉树题目总结
qq_41202486的博客
09-08 601
leetcode 二叉树题目总结一.基本问题遍历前序遍历后序遍历中序遍历莫里斯遍历：空间复杂度O(1)层次遍历由序列构造二叉树递归解决二叉树问题：将二叉树转换为其他结构 二叉树结构： struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode() : val(0), left(nullptr), right(nullptr) {} TreeNode(int x) : val(x), left
【Leetcode 二叉树题目合集】
最新发布
lbj12345678_的博客
03-07 232
处理层处理的始终是根节点（也就是当前节点），哪种遍历方式主要看处理函数放在哪一个子树的递归函数之后；前序是放在最前面，中序是放在中间，后序是放在最后；前序遍历的处理顺序为，因此处理层先处理根节点，然后递归调用左子树、右子树处理顺序为，先递归到左叶子节点，然后处理根节点，然后递归右子树处理顺序为，先递归到左叶子节点，然后递归右子树，最后处理根节点前序遍历递归，根节点处理函数：首先找到最后一层，即左右子树中深度最大的，前序递归；双指针从当前区间寻找最大值构造根节点，然后递归构造左右子节点。
LeetCode题目——二叉树篇
Pcl2001的博客
03-07 1636
LeetCode题目——二叉树篇前言一、二叉树的前、中、后序遍历1.前序遍历递归实现迭代法2.中序遍历递归迭代法3.后序遍历递归迭代二、二叉树的层次遍历三、二叉树的右视图四、二叉树的层平均值五、N叉树的层序遍历六、在每个树行中找最大值七、填充每个节点的下一个右侧节点指针（完全二叉树）八、填充每个节点的下一个右侧节点指针（普通二叉树）九、完全二叉树的节点个数![在这里插入图片描述](https://img-blog.csdnimg.cn/4ecfb9528fd44f388c1126f89885dd36.png
二叉树容易做混的几道题
AWhiteDongDong的博客
08-25 323
101. 对称二叉树 给定一个二叉树，检查它是否是镜像对称的。 # Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left # self.right = right class Solution: def isSymm
LeetCode中二叉树题目总结
weixin_30596023的博客
07-28 244
本文仅为博主个人总结，水平有限，欢迎大神指出不妥处。 关于二叉树的相关概念可以参见二叉树的百度百科，或binary tree Wiki。 二叉树结点类的常见定义为： 1 /* Definition for a binary tree node. */ 2 struct TreeNode 3 { 4 int val; 5 TreeNode *left...
leetcode答案-LeetCode-solution:LeetCode-解决方案
06-30
尝试着把每次写的题目都在这里汇总一下，但愿我能记得！ 2017/10/21 442，没仔细看题，自己写了个超慢的…… 2017/11/5 463,岛和水，一种数学规律 2017/11/6 496,题都没看懂，最后还是看了答案才React过来啥意思；...
leetcode分类-leetcode:leetcode刷题（中等难度分类）
06-30
《LeetCode刷题指南：中等难度篇》 在编程领域，LeetCode 是一个非常知名的在线平台，它提供了丰富的算法题目，旨在帮助开发者提升编程技能、理解和解决实际问题。本篇将聚焦于LeetCode中的中等难度题目，通过深入...
leetcode分类-leetcode-classify:leetcode分类刷题【总结每个类型下的题型】
06-30
《LeetCode分类刷题：深度剖析与总结》 在编程学习和面试准备的过程中，LeetCode作为一款备受推崇的在线编程挑战平台，对于提升算法技能、熟悉数据结构以及增强问题解决能力有着不可忽视的作用。本资料集“LeetCode...
leetcode过桥问题-leetcode-practice:Leetcode题，ACM题刷题汇总
07-01
leetcode过桥问题 Leetcode Learning 主要涉及到的算法思想： 回溯 递归 TopK最大 动态规划 归并 新增 python_algorithm 实现：主要基于python实现各种数据结构，常用算法 新增 Cplus_algorithm 实现：利用C++实现...
Leetcode 二叉树刷题合集
KKWriedy的博客
08-12 270
题目列表 Leetcode 100 相同的树（✩）： https://leetcode-cn.com/problems/same-tree/ Leetcode 108 将有序数组转换为二叉搜索树（✩✩）： https://leetcode-cn.com/problems/convert-sorted-array-to-binary-search-tree/ Leetcode 110 平衡二叉树（✩✩✩）： https://leetcode-cn.com/problems/balanced-binary-t
[LeetCode]二叉树题目总结
loveRooney的专栏
06-19 5207
【LeetCode】二叉树习题个人总结 近一个月来，刷了不少LeetCode题目。但是总还是感觉提高的不多，自己最初想的一边做一边总结的初衷也没有正常执行，今晚静下心来，总结一下和二叉树有关的题目。 基础题目： 【二叉树遍历】 Binary Tree Postorder Traversal Binary Tree Preorder Traversal Binary Tree Inord
【leetcode】二叉树常考题型总结
zhaohb2016的博客
08-21 304
对于二叉树的题型，多出在面试中，笔试相对较少，要多总结做到心中有数。尽量做到递归和迭代都熟悉。
leetcode专题训练——二叉树题目汇总
zyc12321的博客
03-05 425
1、给定一个二叉树，找出其最大深度。（104题） 递归，求左右子树的最大值。 2、给定一个二叉树，判断它是否是高度平衡的二叉树。（110题） 在上一题的基础上加了个判断，如果左右子树差超过1，全局变量变为0. 3、给你一个二叉树，请你返回其按层序遍历得到的节点值。 （即逐层地，从左到右访问所有节点）。（102题） 队列。关键：每一层记录当前队列的长度。 4、给定一个二叉树，返回其节点值自底向上的层序遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）(107题)..
LeetCode：二叉树的属性（13道经典题目）
一起加油~
04-07 857
本文带来与二叉树的属性有关的LeetCode经典题目，主要实现是C++。
【LeetCode】二叉树相关题解汇总
前端学习博客
09-06 336
这里是小飞侠Pan🥳，立志成为一名优秀的前端程序媛！！！本篇文章同时收录于我的github前端笔记仓库中，持续更新中，欢迎star~👉。
【LeetCode】二叉树题总结（持续更新）
karshey的博客
09-07 310
【LeetCode】二叉树题总结
Leetcode刷题——二叉树
weixin_47156261的博客
01-21 1359
Leetcode刷题——二叉树一、二叉树基础知识二叉树种类二叉树存储方式二叉树遍历方式二叉树c++定义 一、二叉树基础知识 二叉树种类 满二叉树：如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。 完全二叉树：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2^h -1 个节点。 二叉搜索树：只有二叉搜索树有数值。二叉搜索树为有序树。 若它的左
LeetCode刷题分类总结与leetcode-master文件解析
本资源汇总了LeetCode上的题库，并按照算法主题进行了分类整理，同时总结了刷题过程中的一些心得体会和解题策略，旨在帮助IT行业的从业者以及编程爱好者更高效地进行技能提升和面试准备。" ### LeetCode分类刷题...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值