二叉树系统刷题1

最新推荐文章于 2024-11-12 21:14:07 发布
最新推荐文章于 2024-11-12 21:14:07 发布
阅读量479 收藏
点赞数
分类专栏： leetcode 文章标签： java 算法 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42836388/article/details/129691086
版权
本文介绍了多种二叉树的操作，包括层序遍历、按之字形顺序打印、计算最大深度、判断是否为二叉搜索树、完全二叉树、平衡二叉树，寻找二叉搜索树的最近公共祖先，合并二叉树，以及序列化和重建二叉树的方法。这些操作主要通过递归和队列遍历实现。
摘要由CSDN通过智能技术生成

文章目录

BM26 求二叉树的层序遍历

请添加图片描述

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     *
     * @param root TreeNode类
     * @return int整型ArrayList<ArrayList<>>
     */
    public ArrayList<ArrayList<Integer>> levelOrder (TreeNode root) {
        // write code here
        ArrayList<ArrayList<Integer>> res = new ArrayList();
        if (root == null) return res;
        //使用队列存储，进行层序遍历
        Queue<TreeNode> q = new ArrayDeque<TreeNode>();
        q.add(root);//将root插入到队列的末尾
        while (!q.isEmpty()) {
            //记录二叉树的某一行
            ArrayList<Integer> row = new ArrayList();
            int n = q.size();
            //因先进入队列的是根节点，故每层节点多少，队列大小就是多少
            for (int i = 0; i < n; i++) {
                TreeNode cur = q.poll(); //出，同时记录cur节点
                row.add(cur.val);
                //若左右孩子存在，则存入左右孩子作为下一次层次
                if (cur.left != null) q.add(cur.left);
                if (cur.right != null) q.add(cur.right);
            }
            //每一层加入
            res.add(row);
        }
        return res;
    }
}

BM27 按之字形顺序打印二叉树

请添加图片描述

import java.util.ArrayList;
import java.util.Queue;
import java.util.ArrayDeque;
import java.util.Collections;
/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

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

    }

}
*/
public class Solution {
    public ArrayList<ArrayList<Integer>> Print(TreeNode pRoot) {
        ArrayList<ArrayList<Integer>> res = new ArrayList<>();
        if (pRoot == null) return res;
        //使用队列存储，进行层序遍历
        Queue<TreeNode> q = new ArrayDeque<TreeNode>();

        q.add(pRoot);//先将头节点放入
        boolean flag = false;
        while (!q.isEmpty()) {
            ArrayList<Integer> row = new ArrayList<>();
            int n = q.size();

            for (int i = 0; i < n; i++) {
                TreeNode cur = q.poll();//弹出q，并记录
                row.add(cur.val);//存入值

                //看是否有左右还在
                if (cur.left != null) q.add(cur.left);
                if (cur.right != null) q.add(cur.right);
            }
            //要实现奇数层从左到由，偶数层从右到左,即偶数时要逆序q队列
            if (flag) Collections.reverse(row);
            flag = !flag;
            res.add(row);
        }
        return res;
    }

}

BM28 二叉树的最大深度

在这里插入图片描述

层序法 空间复杂度O(1),时间复杂度 O*(*n)

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     *
     * @param root TreeNode类
     * @return int整型
     */
    public int maxDepth (TreeNode root) {
        // write code here

        if (root == null) return 0;
        //使用队列存储，进行层序遍历
        Queue<TreeNode> q = new ArrayDeque<TreeNode>();
        q.add(root);//将root插入到队列的末尾
        int h = 0;
        while (!q.isEmpty()) {
            //记录二叉树的某一行
            ArrayList<Integer> row = new ArrayList();
            int n = q.size();
            //因先进入队列的是根节点，故每层节点多少，队列大小就是多少
            for (int i = 0; i < n; i++) {
                TreeNode cur = q.poll(); //出，同时记录cur节点
                row.add(cur.val);
                //若左右孩子存在，则存入左右孩子作为下一次层次
                if (cur.left != null) q.add(cur.left);
                if (cur.right != null) q.add(cur.right);
            }
            h++;
        }
        return h;
    }
}

递归法 O(2^h)

  public int maxDepth (TreeNode root) {
        //使用递归法则需要，分别计算左右子数中最高的值
        if (root == null) return 0;
        int leftH =  maxDepth(root.left);
        int rightH = maxDepth(root.right);
        return leftH > rightH ? (leftH + 1) : (rightH + 1);
    }

BM29 二叉树中和为某一值的路径(一)

在这里插入图片描述

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     *
     * @param root TreeNode类
     * @param sum int整型
     * @return bool布尔型
     */
    public boolean hasPathSum (TreeNode root, int sum) {
        // write code here
        // //执行思路，使用dfs遍历每个，同时变化sum，找到满足的值就返回真
        // if(root == null) return false;
        // //叶子路径，且路径和为sum
        // if(root.left==null&&root.right==null&&sum-root.val == 0){
        //     return true;
        // }
        // //递归进去子节点
        // return hasPathSum(root.left,sum-root.val)||hasPathSum(root.right,sum-root.val);
        if (root == null) return false;
        return dfs(root, sum, 0);// 深度优先遍历
    }

    private boolean dfs(TreeNode root, int sum, int res) {
        if (root == null) return false;
        //迭代目标值
        res += root.val;
        // 当当前节点为叶子节点并且目标路径存在时，返回 true
        if (res == sum && root.left == null && root.right == null) {
            return true;
        }
        // 对左右分支进行 dfs
        return dfs(root.left, sum, res) || dfs(root.right, sum, res);
    }
}

BM30 二叉搜索树与双向链表

在这里插入图片描述

二叉搜索树是一种特殊的二叉树，它的每个节点值大于它的左子节点，且大于全部左子树的节点值，小于它右子节点，且小于全部右子树的节点值。因此二叉搜索树一定程度上算是一种排序结构。

思路：

二叉搜索树最左端的元素一定最小，最右端的元素一定最大，符合“左中右”的特性，因此二叉搜索树的中序遍历就是一个递增序列，我们只要对它中序遍历就可以组装称为递增双向链表。

具体做法：

  • step 1：创建两个指针，一个指向题目中要求的链表头（head），一个指向当前遍历的前一节点（pre)。
  • step 2：首先递归到最左，初始化head与pre。
  • step 3：然后处理中间根节点，依次连接pre与当前节点，连接后更新pre为当前节点。
  • step 4：最后递归进入右子树，继续处理。
  • step 5：递归出口即是节点为空则返回。

在这里插入图片描述

/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

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

    }

}
*/
public class Solution {
    //返回第一个指针，即最小值，先定为null
    public TreeNode head = null;
    //中序遍历当前值的上一位，初值为最小值，先定为null
    public TreeNode pre = null;
    public TreeNode Convert(TreeNode pRootOfTree) {
        if (pRootOfTree == null) {
            //中序递归，叶子为空则返回
            return null;
        }
        //首先递归到最左最小值
        Convert(pRootOfTree.left); //左

        //中
        //找到最小值，初始化head和pre;
        if (pre == null) {
            head = pRootOfTree;
            pre = pRootOfTree;
        } else {
            //当前节点与上一结点建立连接，将pre设置为当前值
            pre.right = pRootOfTree;
            pRootOfTree.left = pre;
            pre = pRootOfTree;
        }

        Convert(pRootOfTree.right); //右
        return head;

    }
}

BM31 对称的二叉树

思路：

前序遍历的时候我们采用的是“根左右”的遍历次序，如果这棵二叉树是对称的，即相应的左右节点交换位置完全没有问题，那我们是不是可以尝试“根右左”遍历，按照轴对称图像的性质，这两种次序的遍历结果应该是一样的。

不同的方式遍历两次，将结果拿出来比较看起来是一种可行的方法，但也仅仅可行，太过于麻烦。我们不如在遍历的过程就结果比较了。而遍历方式依据前序递归可以使用递归：

  • 终止条件： 当进入子问题的两个节点都为空，说明都到了叶子节点，且是同步的，因此结束本次子问题，返回true；当进入子问题的两个节点只有一个为空，或是元素值不相等，说明这里的对称不匹配，同样结束本次子问题，返回false。
  • 返回值： 每一级将子问题是否匹配的结果往上传递。
  • 本级任务： 每个子问题，需要按照上述思路，“根左右”走左边的时候“根右左”走右边，“根左右”走右边的时候“根右左”走左边，一起进入子问题，需要两边都是匹配才能对称。

具体做法：

  • step 1：两种方向的前序遍历，同步过程中的当前两个节点，同为空，属于对称的范畴。
  • step 2：当前两个节点只有一个为空或者节点值不相等，已经不是对称的二叉树了。
  • step 3：第一个节点的左子树与第二个节点的右子树同步递归对比，第一个节点的右子树与第二个节点的左子树同步递归比较。

在这里插入图片描述

/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

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

    }

}
*/
public class Solution {
    boolean isSymmetrical(TreeNode pRoot) {
        return recursion(pRoot, pRoot);
    } 
    public boolean recursion(TreeNode root1, TreeNode root2) {
        //可以两个都为空
        if (root1 == null && root2 == null)
            return true;
        //只有一个为空或者节点值不同，必定不对称
        if (root1 == null || root2 == null || root1.val != root2.val)
            return false;
        //每层对应的节点进入递归比较
        return recursion(root1.left, root2.right) && recursion(root1.right, root2.left);
    }
}

BM32 合并二叉树

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     *
     * @param t1 TreeNode类
     * @param t2 TreeNode类
     * @return TreeNode类
     */
    public TreeNode mergeTrees (TreeNode t1, TreeNode t2) {
        // write code here
        //思路：同时遍历左右，相同就加上，为空就指向
        if (t1 == null) return t2;
        if (t2 == null) return t1;
        //根左右遍历
        TreeNode head = new TreeNode(t1.val + t2.val);
        head.left = mergeTrees(t1.left, t2.left);
        head.right = mergeTrees(t1.right, t2.right);
        return head;
    }
}

BM34 判断是不是二叉搜索树

思路：

二叉搜索树的特性就是中序遍历是递增序。既然是判断是否是二叉搜索树，那我们可以使用中序递归遍历。只要之前的节点是二叉树搜索树，那么如果当前的节点小于上一个节点值那么就可以向下判断。只不过在过程中我们要求反退出。比如一个链表1->2->3->4，只要for循环遍历如果中间有不是递增的直接返回false即可。

if(root.val < pre)
    return false;

具体做法：

  • step 1：首先递归到最左，初始化maxLeft与pre。
  • step 2：然后往后遍历整棵树，依次连接pre与当前节点，并更新pre。
  • step 3：左子树如果不是二叉搜索树返回false。
  • step 4：判断当前节点是不是小于前置节点，更新前置节点。
  • step 5：最后由右子树的后面节点决定。
import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 *   public TreeNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    int pre = Integer.MIN_VALUE;
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return bool布尔型
     */
    public boolean isValidBST (TreeNode root) {
        // write code here
        //中序遍历
        if(root ==  null) return true;
        //先进入左子树
        if(!isValidBST(root.left)){
            return false;
        }
        if(root.val<pre){
            return false;
        }
        //更新最值
        pre = root.val;
        //在进入右子树
        return isValidBST(root.right);
        
    }
}

BM35 判断是不是完全二叉树

思路：

对完全二叉树最重要的定义就是叶子节点只能出现在最下层和次下层，所以我们想到可以使用队列辅助进行层次遍历——从上到下遍历所有层，每层从左到右，只有次下层和最下层才有叶子节点，其他层出现叶子节点就意味着不是完全二叉树。

具体做法：

  • step 1：先判断空树一定是完全二叉树。
  • step 2：初始化一个队列辅助层次遍历，将根节点加入。
  • step 3：逐渐从队列中弹出元素访问节点，如果遇到某个节点为空，进行标记，代表到了完全二叉树的最下层，若是后续还有访问，则说明提前出现了叶子节点，不符合完全二叉树的性质。
  • step 4：否则，继续加入左右子节点进入队列排队，等待访问。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PlMO085A-1679386637750)(C:\Users\jquery\Desktop\国密算法\八股文\assets\07986E476EB2CECD3C5F81D0BCADBE12.gif)]

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 *   public TreeNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return bool布尔型
     */
    public boolean isCompleteTree (TreeNode root) {
        // write code here
        //左右都为null
        
        //空树一定为完全二叉树
        if(root == null) return true;
        //辅助队列
        Queue<TreeNode> q = new LinkedList<>();
        q.add(root);

        //定义一个首次出现的标记位
        boolean notComplete = false;
        while(!q.isEmpty()){
            TreeNode cur = q.poll();
            if(cur == null){
                //标记第一次遇到空节点
                notComplete = true;
                continue;
            }
            //后续访问以及已经遇到空节点了，说明经过了叶子
            if(notComplete) return false;
            q.add(cur.left);
            q.add(cur.right);
        }
        return true;
    }
}

BM36 判断是不是平衡二叉树

在这里插入图片描述

public class Solution {
    public boolean IsBalanced_Solution(TreeNode root) {
        //空树为平衡树
        if (root == null) return true;
        int left = deep(root.left);
        int right = deep(root.right);
        //左子树深度减去右子树相差绝对值大于1
        if (left - right > 1 || left - right < -1) {
            return false;
        }
        //同时左右子树还必须是平衡的
        return IsBalanced_Solution(root.left) && IsBalanced_Solution(root.right);
    }

    private int deep(TreeNode root) {
        //空节点深度为0
        if (root == null) return 0;

        //递归计算左右子树的深度
        int left = deep(root.left);
        int right = deep(root.right);

        //子树最大深度加上自己
        return (left > right) ? left + 1 : right + 1;
    }
}

BM37 二叉搜索树的最近公共祖先

思路：

二叉搜索树没有相同值的节点，因此分别从根节点往下利用二叉搜索树较大的数在右子树，较小的数在左子树，可以轻松找到p、q：

//节点值都不同，可以直接用值比较
while(node.val != target) { 
    path.add(node.val);
    //小的在左子树
    if(target < node.val) 
        node = node.left;
    //大的在右子树
    else 
        node = node.right;
}

直接得到从根节点到两个目标节点的路径，这样我们利用路径比较就可以找到最近公共祖先。

具体做法：

  • step 1：根据二叉搜索树的性质，从根节点开始查找目标节点，当前节点比目标小则进入右子树，当前节点比目标大则进入左子树，直到找到目标节点。这个过程成用数组记录遇到的元素。
  • step 2：分别在搜索二叉树中找到p和q两个点，并记录各自的路径为数组。
  • step 3：同时遍历两个数组，比较元素值，最后一个相等的元素就是最近的公共祖先。

在这里插入图片描述

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 *   public TreeNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param root TreeNode类
     * @param p int整型
     * @param q int整型
     * @return int整型
     */
    public int lowestCommonAncestor (TreeNode root, int p, int q) {
        // write code here
        //求根节点到两个节点的路径
        ArrayList<Integer> path_p = getPasth(root, p);
        ArrayList<Integer> path_q = getPasth(root, q);

        int res = 0;
        //比较元素值，最后一个相等的元素就是最近的公共祖先。
        for (int i = 0; i < path_p.size() && i < path_q.size(); i++) {
            int x = path_p.get(i);
            int y = path_q.get(i);
            //最后一个相同的节点就是最近公共祖先
            if (x == y) {
                res = path_p.get(i);
            } else {
                break;
            }

        }
        return res;
    }

    //求得根节点到目标节点的路径
    public ArrayList<Integer> getPasth(TreeNode root, int target) {
        ArrayList<Integer> path = new ArrayList<Integer>();
        TreeNode node = root;
        //节点值都不同，可以直接比较
        while (node.val != target) {
            path.add(node.val);
            //小的在左子树
            if (target < node.val) {
                node = node.left;
            } else {
                //大的在右子树
                node = node.right;
            }

        }
        path.add(node.val);
        return path;
    }
}

BM38 在二叉树中找到两个节点的最近公共祖先

在这里插入图片描述

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     *
     * @param root TreeNode类
     * @param o1 int整型
     * @param o2 int整型
     * @return int整型
     */
    public int lowestCommonAncestor (TreeNode root, int o1, int o2) {
        // write code here
        ArrayList<Integer> path1 = new ArrayList<>();
        ArrayList<Integer> path2 = new ArrayList<>();
        //求根节点到两个节点的路径
        dfs(root,path1,o1);
        //重置
        flag = false;
        dfs(root,path2,o2);
        int res=0;
        //比较两个路径，找到第一个不同的点
        for(int i=0;i<path1.size()&&i<path2.size();i++){
            int x = path1.get(i);
            int y = path2.get(i);
            if(x==y){
                //最后一个相同的节点就是最近公共祖先
                res = x;
            }else{
                break;
            }
        }
        return res;
    }
    //记录是否找到到o的路径
    public boolean flag = false;
    //求得根节点到目标节点的路径
    public void dfs(TreeNode root, ArrayList<Integer> path, int o) {
        if (flag || root == null) {
            return;
        }
        path.add(root.val);
        //节点不同值都不同，可以直接用值比较
        if (root.val == o) {
            flag = true;
            return;
        }
        //dfs 遍历查找
        dfs(root.left, path, o);
        dfs(root.right, path, o);
        if (flag) return;
        path.remove(path.size() - 1);
    }
}

BM39 序列化二叉树

/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

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

    }

}
*/

import java.util.*;

public class Solution {
    String SEP = ",";
    String NULL = "#";
    String Serialize(TreeNode root) {
        StringBuilder sb = new StringBuilder();
        serialize(root, sb);
        return sb.toString();
    }
    //辅助函数，将二叉树存入StringBuilder中
    void serialize(TreeNode root, StringBuilder sb) {
        if(root == null){
            sb.append(NULL).append(SEP);
            return;
        }
        //前序遍历位置
        sb.append(root.val).append(SEP);

        serialize(root.left,sb);
        serialize(root.right,sb);
    }

    TreeNode Deserialize(String str) {
        //将字符串转成列表
        LinkedList<String> nodes = new LinkedList<>();
        for(String s:str.split(SEP)){
            nodes.addLast(s);
        }
        return deserialize(nodes);

    }

    TreeNode deserialize( LinkedList<String> nodes){
        if(nodes.isEmpty()) return null;
        //前序遍历位置,列表最左侧就是和根节点
        String first = nodes.removeFirst();
        if(first.equals(NULL)) return null;
        TreeNode root = new TreeNode(Integer.parseInt(first));
        root.left = deserialize(nodes);
        root.right =deserialize(nodes);

        return root;
    }
}

BM40 重建二叉树

在这里插入图片描述

import java.util.*;
/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public TreeNode reConstructBinaryTree(int [] pre, int [] vin) {
        int n = pre.length;
        int m = vin.length;
        //每个遍历都不能为0
        if (n == 0 || m == 0) {
            return null;
        }
        //构建根节点 根节点必定在pre中选
        TreeNode root = new TreeNode(pre[0]);
        for (int i = 0; i < n; i++) {
            //找到中序遍历中的前序第一个元素,依据它划分左右子树
            if (pre[0] == vin[i]) {
                //构建左子树
                root.left = reConstructBinaryTree(Arrays.copyOfRange(pre,1,i+1),Arrays.copyOfRange(vin,0,i));
                //构建右子树
                root.right = reConstructBinaryTree(Arrays.copyOfRange(pre,i+1,pre.length),Arrays.copyOfRange(vin,i+1,vin.length));
                break;
            }
        }
        return root;
    }
}

BM41 输出二叉树的右视图

在这里插入图片描述

思路：

首先根据前序遍历和中序遍历生成二叉树

然后使用层序遍历得到每一层的一个数组

针对每一层的数组，取最后一个数，即可完成

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 求二叉树的右视图
     * @param xianxu int整型一维数组 先序遍历
     * @param zhongxu int整型一维数组 中序遍历
     * @return int整型一维数组
     */

    public int[] solve (int[] xianxu, int[] zhongxu) {
        TreeNode root = reConstructBinaryTree(xianxu, zhongxu);
        ArrayList<ArrayList<Integer>> res = getLevelList(root);
        ArrayList<Integer> list = new ArrayList<>();
        //将二叉树 层次便利的 每层的额最后一个 值存入新的 ArrayList 中 转化为 数组
        for (int i = 0; i < res.size(); i++) {
            list.add(res.get(i).get(res.get(i).size() - 1));
        }
        // int arr[] = new int[list.size()];
        // for (int i = 0; i < list.size(); i++) {
        //     arr[i] = list.get(i);
        // }
        int arr[] = list.stream().mapToInt(Integer::valueOf).toArray();
        return arr;
    }

    public TreeNode reConstructBinaryTree(int[] pre, int[] vin) {
        int n = pre.length;
        int m = vin.length;
        //每个遍历都不能为0
        if (n == 0 || m == 0) return null;

        //构建根节点，根节点必定在pre中选\
        TreeNode root = new TreeNode(pre[0]);
        for (int i = 0; i < n; i++) {
            //找到中序遍历中的前序第一个元素，依据它划分左右子树
            if (pre[0] == vin[i]) {
                //构建左子树
                root.left = reConstructBinaryTree(Arrays.copyOfRange(pre, 1, i + 1),
                                                  Arrays.copyOfRange(vin, 0, i));
                //构建右子树
                root.right = reConstructBinaryTree(Arrays.copyOfRange(pre, i + 1, pre.length),
                                                   Arrays.copyOfRange(vin, i + 1, vin.length));
                break;
            }
        }
        return root;
    }

    //此方法用来 二叉树的 层次遍历到 ArrayList<ArrayList<Integer>>中
    private  ArrayList<ArrayList<Integer>> getLevelList(TreeNode root) {
        ArrayList<ArrayList<Integer>> result = new ArrayList<>();
        Queue<TreeNode> q = new LinkedList<>();
        q.add(root);
        while (!q.isEmpty()) {
            ArrayList<Integer> row = new ArrayList<>();
            int n = q.size();
            for (int i = 0; i < n; i++) {
                TreeNode cur = q.poll();
                row.add(cur.val);
                if (cur.left != null) q.add(cur.left); //是cur，不是root
                if (cur.right != null) q.add(cur.right);//是cur，不是root
            }
            result.add(row);
        }
        return result;
    }

    
}
扶我起来继续学习
关注
专栏目录
二叉树力扣刷题（递归法）
2301_79368422的博客
04-25 852
递归法是二叉树算法题中一种很常见的解法，由于二叉树的特殊结构，用递归法解题时往往会比迭代法省时省力很多。先来明确一下递归通用的三步法：确定递归函数的参数和返回值确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。确定终止条件写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。
二叉树刷题，bfs刷题
小泽爱刷题的博客
08-06 1053
实例方法使用self来访问和修改实例属性和方法。类方法使用cls来访问类属性和方法。静态方法不需要self或cls参数，因为它们不访问类或实例的任何属性或方法。访问实例方法需要使用self，这并不是类方法的特性，而是实例方法的特性。类方法和静态方法不使用self，类方法使用cls，静态方法不使用任何特殊的类或实例引用实例方法： 实例方法可以访问实例属性和类属性。它们主要用于操作实例数据。python复制代码class MyClass:类方法： 类方法只能访问类属性，不能直接访问实例属性。
tag二叉树-刷题预备知识-1. 深入浅出深度优先遍历(DFS)和广度优先遍历(BFS) + lt. 102. 二叉树的层序遍历 1
菜菜的大数据开发の路
03-21 695
零, BFS, DFS 基本知识扫盲 Java实现图的深度优先遍历(DFS)和广度优先遍历(BFS) 一, BFS和DFS的比较 DFS（深度优先搜索）和 BFS（广度优先搜索）就像孪生兄弟，提到一个总是想起另一个。然而在实际使用中，我们用 DFS 的时候远远多于 BFS。那么，是不是 BFS 就没有什么用呢？ 如果我们使用 DFS/BFS 只是为了遍历一棵树、一张图上的所有结点的话，那么 DFS 和 BFS 的能力没什么差别，我们当然更倾向于更方便写、空间复杂度更低的 DFS 遍历。不过，某些使用场景是
[力扣刷题总结]（二叉树篇）
weixin_38800498的博客
12-29 1565
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录二叉树理论基础篇1.二叉树的种类2.二叉树的存储方式3.二叉树的遍历方式4.二叉树的定义////////////二叉树的遍历方式///////////////二叉树的递归遍历二叉树的迭代遍历1. 迭代法中序遍历2.迭代法前序遍历3.迭代法后序遍历144. 二叉树的前序遍历解法1：递归遍历解法2：迭代遍历二叉树的层序遍历////////////二叉树的属性///////////////////////////二叉树的修改与改造////
【刷题笔记】二叉树
weixin_42761454的博客
01-21 1570
二叉树 Binary Tree 常见种类 刷题时的常见二叉树：满二叉树和完全二叉树 满二叉树 如果一棵二叉树只有度为 0 的结点和度为 2 的结点，并且度为 0 的结点在同一层上，则这棵二叉树为满二叉树。 深度为k，有2^k-1个节点。 完全二叉树 除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含1~2^h - 1个节点。 优先级队列其实是一个堆，堆是一棵完全二叉树，同时保证父子节点的顺序关系。 二叉搜索树 BST
二叉树刷题小结
qq_61597023的博客
03-12 637
if(!***********逻辑代码*************if(pre)pre = root;if(root)***********逻辑代码*************if(pre)pre = root;if(!***********逻辑代码*************if(pre)pre = root;
leetcode——二叉树刷题笔记【更新中】
qq_50714222的博客
10-30 303
​ 跟着代码随想录博主在leetcode上刷题并学习二叉树相关知识点，二叉树的类型和相关的操作比较多，所以这部分需要做的题也比较多，后面会随着做题的进度更新该篇文章，如果有该博主不涉及的题目但和二叉树是相关的，也会加入到这篇文章中。秉持着【学有留痕】的学习方法，所以通过博客的方式来进行记录。与诸君共享并祝学有所成！ ​
刷题2--二叉树
zhaojiazb的博客
05-04 188
二叉树相关力扣刷题
Leetcode刷题总结——二叉树
weixin_47883447的博客
04-06 504
二叉树节点的定义： 1、二叉树的遍历 前序遍历（中左右）、中序遍历（左中右）、后序遍历（左右中） 递归三要素： 1）确定递归函数的参数和返回值：确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。 2）确定终止条件：写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。 3）.
程序员面试算法准备：从二叉树到LeetCode刷题
"本文档主要介绍了如何准备面试中的算法，特别是针对程序员。文章提到了五个步骤，包括...准备面试中的算法部分，需要系统地学习和练习，从基础到高级，理论结合实践，才能在面试中展现出扎实的技能和解决问题的能力。
leetcode中国-My-LeetCode:力扣刷题笔记，暂时只刷了二叉树、字典树、数组、链表，后续会继续刷题
06-29
1. **二叉树**：二叉树是一种基本的数据结构，每个节点最多有两个子节点。常见的二叉树问题包括遍历（前序、中序、后序）、查找、插入和删除操作。二叉树的应用广泛，如二叉搜索树、平衡树（AVL树、红黑树）等。 2....
Labuladong二叉树递归课程与刷题资源
labuladong的刷题笔记V5.2是一份针对数据结构和算法的学习资料，特别强调了在线网站提供的数据结构精品课程，其中重点是二叉树递归专题。这份笔记涵盖了丰富的编程题目，适合Java初学者和进阶者提升技能，包括但不...
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 213
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
1112--接口
最新发布
kequanrrr的博客
11-12 233
interface + 接口名{ }。。。。implements 接口名{ }接口：接口中的抽象方法可以省略 abstract 关键字使用：要实现接口中的所有 抽象方法隐含三个修饰符：public+static+final2.单继承 多接口。
JAVA-01-变量
LJH_laura_li的博客
11-08 483
在方法、构造函数或块内部定义的变量。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 330
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
JAVA学习接口案例实例
shangan_3的博客
11-08 226
【代码】JAVA学习接口案例实例。
Java基于小程序公考学习平台的设计与实现（附源码，文档）
chusheng1840的博客
11-09 1244
Java基于小程序公考学习平台的设计与实现，小程序公考学习平台使用Java语言进行编码，使用Mysql创建数据表保存本系统产生的数据。系统可以提供信息显示和相应服务，其管理小程序公考学习平台信息，查看小程序公考学习平台信息，管理小程序公考学习平台。总之，小程序公考学习平台集中管理信息，有着保密性强，效率高，存储空间大，成本低等诸多优点。它可以降低信息管理成本，实现信息管理计算机化。关键词：小程序公考学习平台；Java语言；Mysql。
ArkTS--应用状态
qq_63946637的博客
11-10 614
本文旨在帮助大家学习鸿蒙中的LocalStorage和AppStorage
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值