leetcode——二叉树问题汇总

已于 2024-05-03 11:18:50 修改
阅读量1k 收藏 6
点赞数 19
分类专栏： leetcode专题汇总 文章标签： leetcode 算法 二叉树
于 2024-03-12 11:23:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61028090/article/details/136127059
版权
文章介绍了LeetCode中涉及的各种二叉树遍历方法（前序、中序、后序和层序），以及如何使用递归和迭代实现这些遍历，还包括了翻转二叉树、对称性判断、最大深度计算、最小深度、节点计数、不同二叉搜索树构建和最近公共祖先等问题的解决方案。
摘要由CSDN通过智能技术生成

目录

leetcode 144. 二叉树的前序遍历

 ①递归法：

②迭代法：

leetcode 94. 二叉树的中序遍历

  ①递归法：

②迭代法： 

leetcode 145. 二叉树的后序遍历

  ①递归法：

leetcode 102. 二叉树的层序遍历

队列迭代法：

leetcode 226. 翻转二叉树

leetcode 101. 对称二叉树

leetcode 104. 二叉树的最大深度

leetcode 111. 二叉树的最小深度

leetcode 222. 完全二叉树的节点个数

leetcode 96. 不同的二叉搜索树

leetcode 105. 从前序与中序遍历序列构造二叉树 （⭐）

leetcode 236. 二叉树的最近公共祖先（⭐）

leetcode 144. 二叉树的前序遍历

 ①递归法：

/**
 * 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 void traversal(TreeNode cur, List<Integer> ans){
        if(cur == null) return;
        ans.add(cur.val);
        traversal(cur.left,ans);
        traversal(cur.right,ans);
    }
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> ans = new ArrayList<>();
        traversal(root,ans);
        return ans;
    }
}

②迭代法：

/**
 * 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 List<Integer> preorderTraversal(TreeNode root) {
        LinkedList<TreeNode> stack = new LinkedList<>();
        List<Integer> ans = new ArrayList<>();
        if(root == null) return ans;
        stack.push(root);
        while(stack.size() != 0){
            TreeNode node = stack.pop();
            ans.add(node.val);
            if(node.right != null) stack.push(node.right);
            if(node.left != null) stack.push(node.left);
        }
        return ans;
    }
}

        LinkedList可以用于模拟栈和队列， push和pop可以用于模拟栈，add()和remove()可以用于模拟队列。

leetcode 94. 二叉树的中序遍历

 

  ①递归法：

/**
 * 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 void traversal(TreeNode cur, List<Integer> ans){
        if(cur == null) return;
        traversal(cur.left,ans);
        ans.add(cur.val);
        traversal(cur.right,ans);
    }
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> ans = new ArrayList<>();
        traversal(root,ans);
        return ans;
    }
}

②迭代法： 

/**
 * 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 List<Integer> inorderTraversal(TreeNode root) {
        LinkedList<TreeNode> stack = new LinkedList<>();
        List<Integer> ans = new ArrayList<>();
        TreeNode cur = root;
        while(cur != null || stack.size() != 0){
            if(cur != null){
                stack.push(cur);
                cur = cur.left;//左
            }
            else{
                cur = stack.pop();
                ans.add(cur.val);//中
                cur = cur.right;//右
            }
        }
        return ans;
    }
}

leetcode 145. 二叉树的后序遍历

  ①递归法：

/**
 * 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 void traversal(TreeNode cur, List<Integer> ans){
        if(cur == null) return;
        traversal(cur.left,ans);
        traversal(cur.right,ans);
        ans.add(cur.val);
    }
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> ans = new ArrayList<>();
        traversal(root,ans);
        return ans;
    }
}

leetcode 102. 二叉树的层序遍历

队列迭代法：

/**
 * 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 List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> ans = new ArrayList<>();
        LinkedList<TreeNode> queue = new LinkedList<>();
        if(root != null) queue.add(root);
        while(queue.size() != 0){
            int size = queue.size();
            List<Integer> list = new ArrayList<>();
            for(int i=0; i<size; i++){
                TreeNode node = queue.remove();
                list.add(node.val);
                if(node.left != null) queue.add(node.left);
                if(node.right != null) queue.add(node.right);
            }
            ans.add(list);
        }
        return ans;
    }
}

leetcode 226. 翻转二叉树

        在层序遍历的代码上添加交换左右节点的逻辑即可： 

/**
 * 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 invertTree(TreeNode root) {
        LinkedList<TreeNode> queue = new LinkedList<>();
        if(root != null) queue.add(root);
        while(queue.size() != 0){
            int size = queue.size();
            for(int i=0; i<size; i++){
                TreeNode node = queue.pop();
                //交换左右孩子节点
                TreeNode temp = node.left;
                node.left = node.right;
                node.right = temp;

                if(node.left != null) queue.add(node.left);
                if(node.right != null) queue.add(node.right);
            }
        }
        return root;
    }
}

leetcode 101. 对称二叉树

/**
 * 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 boolean isSymmetric(TreeNode root) {
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.add(root.left);
        queue.add(root.right);
        while(queue.size() != 0){
            TreeNode leftNode = queue.remove();
            TreeNode rightNode = queue.remove();
            if(leftNode == null && rightNode == null) continue;
            if(leftNode == null || rightNode == null || leftNode.val != rightNode.val) return false;
            queue.add(leftNode.left);
            queue.add(rightNode.right);
            queue.add(leftNode.right);
            queue.add(rightNode.left);
        }
        return true;
    }
}

leetcode 104. 二叉树的最大深度

        本题在层序遍历的代码上修改即可，每一层代表深度+1：

/**
 * 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 int maxDepth(TreeNode root) {
        if(root == null) return 0;
        LinkedList<TreeNode> queue = new LinkedList<>();
        int ans = 0;
        queue.add(root);
        while(queue.size() != 0){
            int size = queue.size();
            ans++;
            for(int i=0; i<size; i++){
                TreeNode node = queue.remove();
                if(node.left != null) queue.add(node.left);
                if(node.right != null) queue.add(node.right);
            }
        }
        return ans;
    }
}

leetcode 111. 二叉树的最小深度

        大致思路和求二叉树最大深度类似，在内层while循环中加一句判断：当当前节点的左右节点都为空时，直接返回当前深度，此时也就是二叉树的最小深度。

/**
 * 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 int minDepth(TreeNode root) {
        if(root == null) return 0;
        int ans = 0;
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while(queue.size() != 0){
            int size = queue.size();
            ans++;
            for(int i=0; i<size; i++){
                TreeNode node = queue.remove();
                if(node.left == null && node.right == null) return ans;

                if(node.left != null) queue.add(node.left);
                if(node.right != null) queue.add(node.right);
            }
        }
        return ans;
    }
}

leetcode 222. 完全二叉树的节点个数

        用层序遍历的逻辑做即可：

/**
 * 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 int countNodes(TreeNode root) {
        int ans = 0;
        if(root == null) return 0;
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while(queue.size() != 0){
            int size = queue.size();
            for(int i=0; i<size; i++){
                ans++;
                TreeNode node = queue.remove();
                if(node.left != null) queue.add(node.left);
                if(node.right != null) queue.add(node.right);
            }
        }
        return ans;
    }
}

leetcode 96. 不同的二叉搜索树

         本题利用动态规划来做，分析当n=3的情况：

  • 当1作为根节点，此时左子树有0个节点，右子树有2两个节点，此时的二叉树种数应该有dp[0]*dp[2]种。
  • 当2作为根节点，此时左右子树各有一个节点，种数都是dp[1]，此时的二叉树种数应该有dp[1]*dp[1]种。
  • 当3作为根节点，此时情况和第一种情况类似，只是左右子树交换了。
class Solution {
    public int numTrees(int n) {
        int[] dp = new int[n+1];
        dp[0] = 1;
        dp[1] = 1;
        for(int i=2; i<=n; i++){
            for(int j=0; j<i; j++){
                dp[i] += dp[j] * dp[i-j-1];
            }
        }
        return dp[n];
    }
}

leetcode 105. 从前序与中序遍历序列构造二叉树 （⭐）

        本体关键是需要把分割点seg求出来，然后通过seg将中序数组和先序数组分割成两个数组。代码如下：

/**
 * 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) {
        if(preorder.length == 0) return null;
        int rootValue = preorder[0];
        TreeNode root = new TreeNode(rootValue);
        if(preorder.length == 1){
            return root;
        }
        int seg = 0;
        for(int i=0; i<inorder.length; i++){
            if(inorder[i] == rootValue){
                seg = i;
                break;
            }
        }
        int[] in_left = Arrays.copyOfRange(inorder,0,seg);
        int[] in_right = Arrays.copyOfRange(inorder,seg+1,inorder.length);
        int[] pre_left = Arrays.copyOfRange(preorder,1,in_left.length+1);
        int[] pre_right = Arrays.copyOfRange(preorder,in_left.length+1,preorder.length);

        root.left = buildTree(pre_left,in_left);
        root.right = buildTree(pre_right,in_right);
        
        return root;
    }
}

leetcode 236. 二叉树的最近公共祖先（⭐）

        首先确定终止条件。如果根节点为空，或者其中一个节点是根节点本身（即 p == root 或 q == root），那么根节点就是它们的最低共同祖先，因此我们直接返回根节点 root。 

        接下来，递归调用 lowestCommonAncestor 方法来查找左子树和右子树中 是否存在p、q节点，若存在则返回相应节点。

        最后，根据左子树和右子树中返回的结果来确定最终的最低共同祖先。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root==p || root==q || root==null){
            return root;
        }
        TreeNode left = lowestCommonAncestor(root.left,p,q);
        TreeNode right = lowestCommonAncestor(root.right,p,q);
        if(left!=null && right!=null){
            return root;
        }
        return left==null? right : left;
    }
}

我真的很帅阿
关注
  • 19
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode二叉树面试题目集锦
xiangxianghehe的博客
08-18 6908
struct BinaryTreeNode { int value; BinaryTreeNode* left; BinaryTreeNode* right; BinaryTreeNode(int x) : value(x), left(NULL), right(NULL) {} }; 初始化 BinaryTreeNode *root = new ...
LeetCode题目——二叉树篇
Pcl2001的博客
03-07 1530
LeetCode题目——二叉树篇前言一、二叉树的前、中、后序遍历1.前序遍历递归实现迭代法2.中序遍历递归迭代法3.后序遍历递归迭代二、二叉树的层次遍历三、二叉树的右视图四、二叉树的层平均值五、N叉树的层序遍历六、在每个树行中找最大值七、填充每个节点的下一个右侧节点指针（完全二叉树）八、填充每个节点的下一个右侧节点指针（普通二叉树）九、完全二叉树的节点个数![在这里插入图片描述](https://img-blog.csdnimg.cn/4ecfb9528fd44f388c1126f89885dd36.png
【LeetCode】107. Binary Tree Level Order Traversal II 解题报告
crazy_jack
05-26 9707
转载请注明出处：http://blog.csdn.net/crazy1235/article/details/51477967Subject 出处：https://leetcode.com/problems/binary-tree-level-order-traversal-ii/ Given a binary tree, return the bottom-up level order tra
LeetCode 二叉树问题总结
weixin_38170137的博客
08-17 403
导言： LeetCode 上面的二叉树问题一般可以看成是简单的深度优先搜索问题，一般的实现方式是使用递归，也会有非递归的实现方法，这边文章主要介绍一下解决二叉树问题的几个常规方法和思路，然后会给一个从递归转换到非递归的小技巧 两个通用方法和思路 拿到一道二叉树的问题，多半是需要你遍历这个树，只不过是在遍历的过程中，不同的题目要求你做的计算不一样。这里有两个遍历方法，自顶向下的递归遍历，以及自...
Leetcode中二叉树问题汇总（一）
wolvvi的博客
08-29 1330
最近陆陆续续在刷树结构这类的问题，非线性结构的问题一直是软肋，尤其是这类问题大量使用递归，对于我这种混了好几年的小白来说不容易理解，因此针对Leetcode中树这一类问题进行了下总结，温故而知新嘛（之前学的都还给老师了…），同时也希望各位大神批评指正。 篇幅有限，本文先写二叉树的一些基本操作。 二叉树的概念 二叉树的基本概念具体可以参考：度娘带你走进二叉树 抽取其中主要的做个简单的介绍...
leetcode专题训练——二叉树题目汇总
zyc12321的博客
03-05 305
1、给定一个二叉树，找出其最大深度。（104题） 递归，求左右子树的最大值。 2、给定一个二叉树，判断它是否是高度平衡的二叉树。（110题） 在上一题的基础上加了个判断，如果左右子树差超过1，全局变量变为0. 3、给你一个二叉树，请你返回其按层序遍历得到的节点值。 （即逐层地，从左到右访问所有节点）。（102题） 队列。关键：每一层记录当前队列的长度。 4、给定一个二叉树，返回其节点值自底向上的层序遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）(107题)..
leetcode总结——树篇
weixin_45680007的博客
02-17 271
自上而下： 路径和sum 最短路径 镜像树 层次遍历 树化链表 完全二叉树的节点个数： 路径和sum： 给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。 说明: 叶子节点是指没有子节点的节点。 示例: 给定如下二叉树，以及目标和 sum = 22， 5 / \ 4 8 ...
LeetCode——两数之和
01-20
一.个人探索 二.网上优秀编程 三....一....1.暴力解法 答题思路：两个循环来遍历列表中的所有组合可能来获取答案值。...优点：简单易懂，比较容易想到的一种嵌套循环进行遍历的思想。...缺点：使用嵌套循环遍历整个数据，耗费...
LeetCode——001 Two Sum
01-07
Description Given an array of integers, return indices of the two numbers such that they add up to a specific target. You may assume that each input would have exactly one solution, and you may not ...
leetcode——-解数独(回溯法)
01-20
回溯法的思想就是：对于一个问题有多个选择方式，先选择一个方式执行下去，若在执行过程中，发现不符合规则，则回退，回到选择方式的步骤，进而选择其他方式，继续试。 重要：对于回溯法，一定会有个[规则]，这个...
LeetCode 算法题库【94】——二叉树的中序遍历
12-21
总的来说，理解和掌握二叉树的中序遍历对于解决LeetCode等算法题库中的相关问题至关重要。递归和迭代都是有效的实现方式，选择哪种方法取决于个人喜好、代码可读性以及对时间和空间复杂度的考量。熟练运用这些技巧，...
leetcode中的二叉树经典问题
weixin_51143430的博客
12-15 556
Num100-判断两树是否相同 代码实现： //判断两棵树是否相同， public boolean isSameTree(treeNode p, treeNode q) { //都是空树 if (p == null && q == null) { return true; } //p和q有一个为空 if (p == nul
leetcode hot100 （面试复习用）
大厂小码农的博客
07-20 486
给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值 target，返回 [-1, -1]。你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。输入：nums = [5,7,7,8,8,10], target = 8输出：[3,4]// 继续向左查找} else {// 查找目标值在数组中的结束位置// 继续向右查找} else {
【LeetCode】分隔链表
最新发布
qq_26521261的博客
07-20 218
给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。简单粗暴的做法：遍历原链表，当前节点新建一个，遇到小的，放到小的链表中，遇到大的，放到大的链表中，最后合并一下。输入：head = [1,4,3,2,5,2], x = 3。你应当 保留 两个分区中每个节点的初始相对位置。输入：head = [2,1], x = 2。链表中节点的数目在范围 [0, 200] 内。输出：[1,2,2,4,3,5]
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 239
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
1. LeetCode-数组和字符串
weixin_43149506的博客
07-18 902
数组和字符串介绍以及相关例题
LeetCode --- 2138. Divide a String Into Groups of Size k 解题报告
杨鑫newlife的专栏
07-16 3247
A string can be partitioned into groups of size using the following procedure:Note that the partition is done so that after removing the character from the last group (if it exists) and concatenating all the groups in order, the resultant string should
Leetcode热题100 Day2
KGthe3的博客
07-19 97
但是即使这样我在写的时候还是花了很多时间，一个是边界条件的处理（尤其是连续有相同值的处理）以及我发现了leetcode的编译器和本地的编译器不一样：本地没有进行越界检查，但是leetcode是开启了的。首先需要对原先的区间进行排序，排序的原则是先按照左端从小到大，左端相同则看右端。这样的话，用两个指针表示当前的已合并区间的左端和右端，不断判断这个右端是否大于下一个区间的左端，如果大于，则合并。窗口的特性是窗口内所有字母的出现次数，因为是异位值，所以只要出现次数相同即可，并不需要考虑出现的顺序。
每日一题，力扣leetcode Hot100之283. 移动零
u013373155的博客
07-19 153
首先，两个指针都指向同一个位置，i=j=0，如果移动指针i的位置不为0则进行交换，固定指针+1，如果为0的话，固定指针不变，移动指针往后面移一直找。这样的话固定指针就会指在0的位置，相当于移动指针遇到非0就和0进行交换。对于当前数组进行调整，不使用额外空间，那么既用双指针。
leetcode 二叉树
09-16
在LeetCode上，二叉树问题是常见的算法题型，我们需要实现各种操作，如合并树、找出深度、遍历等。 在引用中，给出了一个合并二叉树的解法。该解法使用递归的方式将两棵二叉树合并为一棵新的二叉树。首先判断两棵树...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值