二叉树相关-递归

one_cai_bird

已于 2024-03-11 12:08:07 修改

阅读量262

点赞数 3

文章标签：深度优先算法

于 2024-03-10 16:54:06 首次发布

本文链接：https://blog.csdn.net/one_cai_bird/article/details/136604272

版权

101 对称二叉树

给你一个二叉树的根节点 root ，检查它是否轴对称。
思路：
在这里插入图片描述

/**
 * 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) {
        return root==null||dfs(root.left,root.right);
    }
    public boolean dfs(TreeNode left,TreeNode right){
        if(left==null&&right==null){
            return true;
        }
        if(left==null||right==null||left.val!=right.val){
            return false;
        }
        return dfs(left.left,right.right)&&dfs(left.right,right.left);
    }
}

100 相同的树

给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

思路：与对称二叉树判断条件类似，思路大体相同。

/**
 * 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 isSameTree(TreeNode p, TreeNode q) {
        if(p==null&&q==null){
            return true;
        }
        if(p==null||q==null||q.val!=p.val){
            return false;
        }
        return isSameTree(p.left,q.left)&&isSameTree(p.right,q.right);
    }
}

572 另一棵树的子树

给你两棵二叉树 root 和 subRoot 。检验 root 中是否包含和 subRoot 具有相同结构和节点值的子树。如果存在，返回 true ；否则，返回 false 。

二叉树 tree 的一棵子树包括 tree 的某个节点和这个节点的所有后代节点。tree 也可以看做它自身的一棵子树。

思路：首先定义递归函数判断两树是否相同，接着调用该函数，递归判断root树中是否有subRoot的子树。

/**
 * 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 isSubtree(TreeNode root, TreeNode subRoot) {
        if(root==null){
            return false;
        }
        if(subRoot==null){
            return true;
        }
        return isSubtree(root.left,subRoot)||isSubtree(root.right,subRoot)||isSameTree(root,subRoot);
    }
    public boolean isSameTree(TreeNode left,TreeNode right){
        if(left==null&&right==null){
            return true;
        }
        if(left==null||right==null||left.val!=right.val){
            return false;
        }
        return isSameTree(left.left,right.left)&&isSameTree(left.right,right.right);
    }
}

104 二叉树的最大深度

给定一个二叉树 root ，返回其最大深度。

二叉树的最大深度是指从根节点到最远叶子节点的最长路径上的节点数。

思路：二叉树的最大深度为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;
        }
        int leftMax = maxDepth(root.left);
        int rightMax = maxDepth(root.right);
        return Math.max(leftMax,rightMax) + 1;
    }
}

559 N叉树的最大深度

给定一个 N 叉树，找到其最大深度。

最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。

N 叉树输入按层序遍历序列化表示，每组子节点由空值分隔（请参见示例）。

思路：与二叉树的最大深度类似，要找出root节点下，所有子树的最大深度+1。

/*
// Definition for a Node.
class Node {
    public int val;
    public List<Node> children;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, List<Node> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
    public int maxDepth(Node root) {
        if(root==null) return 0;
        int res = 0;
        if(root.children.size()!=0){
            for(int i=0;i<root.children.size();i++){
                res = Math.max(res,maxDepth(root.children.get(i)));
            }
        }
        return res + 1;
    }
}

222 完全二叉树的节点个数

给你一棵完全二叉树的根节点 root ，求出该树的节点个数。

思路：使用dfs解决，返回1+dfs(l)+dfs®

/**
 * 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) {
        if(root==null){
            return 0;
        }
        return 1 + countNodes(root.left) + countNodes(root.right);
    }
}

110 平衡二叉树

给定一个二叉树，判断它是否是平衡二叉树。
平衡二叉树：是指该树所有节点的左右子树的深度相差不超过 1。

思路：定义一个获取树深度的函数getHeight，采用递归方式求得树的深度。在主函数中，递归判断左右子树的深度差值是否小于等于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 boolean isBalanced(TreeNode root) {
        if(root==null){
            return true;
        }
        return Math.abs(dfs(root.left)-dfs(root.right)) <= 1 && isBalanced(root.left) && isBalanced(root.right);
    }
    public int dfs(TreeNode root){
        if(root==null){
            return 0;
        }
        int leftMax = dfs(root.left);
        int rightMax = dfs(root.right);
        return 1 + Math.max(leftMax,rightMax);
    }
}

257 二叉树的所有路径

给你一个二叉树的根节点 root ，按任意顺序，返回所有从根节点到叶子节点的路径。

叶子节点是指没有子节点的节点。
示例1：

输入：root = [1,2,3,null,5]
输出：[“1->2->5”,“1->3”]
示例 2：

输入：root = [1]
输出：[“1”]

思路：定义递归函数，传入三个参数：节点、当前路径记录情况、最终结果集。当该节点不为空的时候，将val值记录在路径中，判断该节点是否是叶子节点，若是，则加入结果集；若不是，则对路径记录情况加入箭头，并递归左右子树。

/**
 * 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<String> binaryTreePaths(TreeNode root) {
        List<String> res = new ArrayList();
        dfs(root,"",res);
        return res;
    }
    public void dfs(TreeNode root, String path,List<String> res){
        if(root!=null){
            StringBuffer tmp = new StringBuffer(path);
            tmp.append(String.valueOf(root.val));
            if(root.left==null&&root.right==null){
                res.add(tmp.toString());
            }else{
                tmp.append("->");
                dfs(root.left,tmp.toString(),res);
                dfs(root.right,tmp.toString(),res);
            }
        }
    }
}

404 左叶子之和

给定二叉树的根节点 root ，返回所有左叶子之和。

思路：使用dfs解决，重点在如何判断节点为左叶子节点，需要通过父节点来判断：当如节点的left节点不为空且left节点不含左右孩子，则left节点为左节点，并将该值记录为val，否则值为0，继续遍历左右子树即可。

/**
 * 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 sumOfLeftLeaves(TreeNode root) {
        if(root==null){
            return 0;
        }
        int midVal = 0;
        if(root.left!=null&&root.left.left==null&&root.left.right==null){
            midVal = root.left.val;
        }
        return midVal+sumOfLeftLeaves(root.left)+sumOfLeftLeaves(root.right);
    }
}

515 找树左下角的值（非递归）

给定一个二叉树的根节点 root，请找出该二叉树的最底层最左边节点的值。

假设二叉树中至少有一个节点。

思路：层序遍历，记录每一层第一个值即可。

/**
 * 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 findBottomLeftValue(TreeNode root) {
        int res = Integer.MIN_VALUE;
        Queue<TreeNode> queue = new LinkedList();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            int flag = 0;
            while(size--!=0){
                TreeNode node = queue.poll();
                if(flag == 0){
                    res = node.val;
                    flag = 1;
                }
                if(node.left!=null){
                    queue.offer(node.left);
                }
                if(node.right!=null){
                    queue.offer(node.right);
                }
            }
        }
        return res;
    }
}

one_cai_bird

关注

3
点赞
踩
10

收藏

觉得还不错? 一键收藏
1
评论
二叉树相关-递归

当该节点不为空的时候，将val值记录在路径中，判断该节点是否是叶子节点，若是，则加入结果集；思路：使用dfs解决，重点在如何判断节点为左叶子节点，需要通过父节点来判断：当如节点的left节点不为空且left节点不含左右孩子，则left节点为左节点，并将该值记录为val，否则值为0，继续遍历左右子树即可。给你一个二叉树的根节点 root ，按任意顺序，返回所有从根节点到叶子节点的路径。给定一个二叉树的根节点 root，请找出该二叉树的最底层最左边节点的值。叶子节点是指没有子节点的节点。
复制链接

扫一扫