[力扣]二叉树3—属性操作

已于 2022-05-10 21:29:58 修改
阅读量440 收藏
点赞数
分类专栏： 力扣刷题 文章标签： leetcode 算法 深度优先
于 2022-05-02 10:01:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51699336/article/details/124510829
版权
  • 好好体会递归思想

代码随想录[原文指路]

判断

1.对称二叉树[101]

  • 递归
class Solution {
    public boolean isSymmetric(TreeNode root) {
        if(root==null) return true;
        return compare(root.left,root.right);
    }
    public static boolean compare(TreeNode left,TreeNode right){
        if(left==null&&right==null) return true;
        if(left==null&&right!=null || left!=null&&right==null || left.val!=right.val) return false;
        //比较外侧
        boolean res1 = compare(left.left,right.right);
        //比较内侧
        boolean res2 = compare(left.right,right.left);
        //若内外侧都相等返回true
        return res1&&res2;
    }
}
  • 双端队列
class Solution {
    public boolean isSymmetric(TreeNode root){
        Deque<TreeNode> deque = new LinkedList<>();
        deque.offerFirst(root.left);
        deque.offerLast(root.right);
        while(!deque.isEmpty()){
            TreeNode leftNode = deque.pollFirst();
            TreeNode rightNode = deque.pollLast();
            if(leftNode==null && rightNode==null) {
                continue;
            }
            if(leftNode==null || rightNode==null || leftNode.val!=rightNode.val) {
                return false;
            }
            deque.offerFirst(leftNode.left);
            deque.offerFirst(leftNode.right);
            deque.offerLast(rightNode.right);
            deque.offerLast(rightNode.left);
        }
        return true;
    }
}
  • 普通队列
class Solution {
    public boolean isSymmetric(TreeNode root){
        Deque<TreeNode> deque = new LinkedList<>();
        deque.offer(root.left);
        deque.offer(root.right);
        while(!deque.isEmpty()){
            TreeNode leftNode = deque.poll();
            TreeNode rightNode = deque.poll();
            if(leftNode==null && rightNode==null) {
                continue;
            }
            if(leftNode==null || rightNode==null || leftNode.val!=rightNode.val) {
                return false;
            }
            deque.offer(leftNode.left);
            deque.offer(rightNode.right);
            deque.offer(leftNode.right);
            deque.offer(rightNode.left);
        }
        return true;
    }
}

2.相同的树[100]

class Solution {
    public boolean isSameTree(TreeNode p, TreeNode q) {
        if(p==null && q==null) return true;
        if(p==null || q==null || p.val!=q.val) return false;
        
        boolean bool1 = isSameTree(p.left,q.left);
        boolean bool2 = isSameTree(p.right,q.right);
        return bool1&&bool2;
    }
}

3.另一棵树的子树[572]

class Solution {
    //遍历root的每一个子节点作为开始节点与subRoot结构比较
    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
        if(root==null) return false;
		return isSameTree(root, subRoot) || isSubtree(root.left, subRoot) || isSubtree(root.right, subRoot);
    }
    //比较pq是否相同
    public static boolean isSameTree(TreeNode p, TreeNode q) {
    	if(p==null && q==null) return true;
        if(p==null || q==null || p.val!=q.val) return false;
        
        boolean bool1 = isSameTree(p.left,q.left);
        boolean bool2 = isSameTree(p.right,q.right);
        return bool1&&bool2;
    }
}

深度

1.二叉树的最大深度[104]

  • 递归
class Solution {
    public int maxDepth(TreeNode root) {
        if(root==null) return 0;

        int len1 = maxDepth(root.left);
        int len2 = maxDepth(root.right);
        return Math.max(len1,len2)+1;
    }
}
  • 迭代(层序)
class Solution {
    public int maxDepth(TreeNode root) {
        int res = 0;
        if(root==null) return res;

        Queue<TreeNode> queue = new LinkedList();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            for(int i=0;i<size;i++){
                TreeNode node = queue.poll();
                if(node.left!=null) queue.offer(node.left);
                if(node.right!=null) queue.offer(node.right);
            }
            res++;
        }
        return res;
    }
}

2.N 叉树的最大深度[559]

  • 递归
class Solution {
    public int maxDepth(Node root) {
        int res = 0;
        if(root==null) return res;

        for(Node node:root.children){
            int len = maxDepth(node);
            res = Math.max(len,res);
        }
        return res+1;
    }
}
  • 迭代(层序)
class Solution {
    public int maxDepth(Node root) {
        int res = 0;
        if(root==null) return res;

        Queue<Node> queue = new LinkedList();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            for(int i=0;i<size;i++){
                Node node = queue.poll();
                for(Node node1:node.children){
                    queue.offer(node1);
                }
            }
            res++;
        }
        return res;
    }
}

3.二叉树的最小深度[111]

  • 递归
class Solution {
    public int minDepth(TreeNode root) {
        if(root==null) return 0;

        int len1 = minDepth(root.left);
        int len2 = minDepth(root.right);
        
        if(root.left==null) return len2+1;
        if(root.right==null) return len1+1;
        return Math.min(len1,len2)+1;
    }
}
  • 迭代(层序)
class Solution {
    public int minDepth(TreeNode root) {
        int res = 0;
        if(root==null) return res;

        Queue<TreeNode> queue = new LinkedList();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            res++;
            for(int i=0;i<size;i++){
                TreeNode node = queue.poll();
                if(node.left!=null) queue.offer(node.left);
                if(node.right!=null) queue.offer(node.right);
                if(node.left==null&&node.right==null){
                    return res;
                }
            }
        }
        return res;
    }
}

平衡二叉树[110]

  • 递归：涉及判断与深度
class Solution {
    public boolean isBalanced(TreeNode root) {
        return getHeight(root)!=-1;
    }

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

        int count1 = getHeight(root.left);
        if(count1==-1) return -1;
        int count2 = getHeight(root.right);
        if(count2==-1) return -1;
        int height = Math.max(count1,count2);
        return Math.abs(count1-count2)>1?-1:height+1;
    }
}

路径

1.二叉树的所有路径[257]

  • 递归+回溯
class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        List<String> ress = new ArrayList();
        if(root == null) return ress;
        preOrder(root,ress,"");
        return ress;
    }

    public static void preOrder(TreeNode root,List<String> ress,String res){
        if(res!=null && !res.equals("")) res+="->";
        res+=root.val;

        if(root.left!=null) preOrder(root.left,ress,res);
        if(root.right!=null) preOrder(root.right,ress,res);
        //此处到达叶子节点
        if(root.left==null && root.right==null){
            ress.add(res);
        }
    }
}

2.路径总和[112]

  • 递归使用
1.如果需要搜索整棵二叉树且不用处理递归返回值，递归函数就不要返回值
2.如果需要搜索整棵二叉树且需要处理递归返回值，递归函数就需要返回值
3.如果要搜索其中一条符合条件的路径，那么递归一定需要返回值，因为遇到符合条件的路径了就要及时返回
  • 递归
class Solution {
    public boolean hasPathSum(TreeNode root, int targetSum) {
        if(root==null) return false;
        //使用累加较麻烦，此处使用累减，每次让targetSum-root.val,若到叶子节点且targetSum=0则找到
        //此题只需要找到一条满足条件的路径就返回，所以此处返回值为Boolean型标记有没有找到满足条件的路径
        targetSum -= root.val;
        if(targetSum==0&&root.left==null&&root.right==null) return true;

        boolean bool1 = hasPathSum(root.left,targetSum);
        boolean bool2 = hasPathSum(root.right,targetSum);

        return bool1||bool2;
    }
}
  • 栈迭代
class Solution {
    public boolean hasPathSum(TreeNode root, int targetSum) {
        if(root==null) return false;
        //栈里一个元素不仅要记录该节点指针，还要记录从头结点到该节点的路径数值总和
        Stack<TreeNode> stack1 = new Stack();
        Stack<Integer> stack2 = new Stack();
        stack1.push(root);
        stack2.push(root.val);
        while(!stack1.isEmpty()){
            int size = stack1.size();
            while(size-->0){
                TreeNode node = stack1.pop();
                int sum=stack2.pop();
                //如果该节点是叶子节点，同时该节点的路径数值等于sum，那么就返回true
                if(node.left==null && node.right==null && sum==targetSum)return true;
                //左节点，压进去一个节点的时候，将该节点的路径数值也记录下来
                if(node.left!=null){
                    stack1.push(node.left);
                    stack2.push(sum+node.left.val);
                }
                //右节点，压进去一个节点的时候，将该节点的路径数值也记录下来
                if(node.right!=null){
                    stack1.push(node.right);
                    stack2.push(sum+node.right.val);
                }
            }
        }
        return false;
    }
}

3.路径总和 II[113]

  • 递归
class Solution {
    public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
        List<List<Integer>> ress = new ArrayList();
        if(root==null) return ress;
        List<Integer> res = new ArrayList();
        getpathSum(root,targetSum,res,ress);
        return ress;
    }

    public void getpathSum(TreeNode root, int targetSum,List<Integer> res,List<List<Integer>> ress) {
        //使用累加较麻烦，此处使用累减，每次让targetSum-root.val,若到叶子节点且targetSum=0则找到
        //此题需要找到所有满足条件的路径就返回，此处不用返回值  
        res.add(root.val);
        targetSum -= root.val;
        if(root.left==null && root.right==null){
        	//注意此处res的改变直接影响ress,所以此处new
            if(targetSum==0) ress.add(new ArrayList<>(res));
            return ;
        }
        if(root.left!=null){
            getpathSum(root.left,targetSum,res,ress);
            res.remove(res.size()-1);//回溯
        }
        if(root.right!=null){
            getpathSum(root.right,targetSum,res,ress);
            res.remove(res.size()-1);//回溯
        }
    }
}

结果和

1.完全二叉树的节点个数[222]

  • 递归
class Solution {
    public int countNodes(TreeNode root) {
        if(root==null) return 0;

        int count1 = countNodes(root.left);
        int count2 = countNodes(root.right);
        return count1+count2+1;
    }
}
  • 迭代
class Solution {
    public int countNodes(TreeNode root) {
        int count = 0;
        if(root==null) return count;

        Queue<TreeNode> queue = new LinkedList();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            count +=size;
            for(int i=0;i<size;i++){
                TreeNode node = queue.poll();
                if(node.left!=null) queue.offer(node.left);
                if(node.right!=null) queue.offer(node.right);
            }
        }
        return count;
    }
}
  • 利用完全二叉树特性递归
完全二叉树只有两种情况
	1.满二叉树：2^数深度-1
	2.最后一层叶子节点没有满：分别递归左右孩子，直到左右孩子为满二叉树，依然按情况1处理
class Solution {
    public int countNodes(TreeNode root) {
        if(root==null) return 0;
        int leftHeight = 0,rightHeight = 0;
        TreeNode left = root.left;
        TreeNode right = root.right;
        //求左子树最左节点深度
        while(left!=null){
            left = left.left;
            leftHeight++;
        }
        //求右子树最右节点深度
        while(right!=null){
            right = right.right;
            rightHeight++;
        }
        if(leftHeight == rightHeight){//这是一颗满二叉树
            return (2<<leftHeight)-1;
        }
        return countNodes(root.left)+countNodes(root.right)+1;
    }
}

2.左叶子之和[404]

  • 递归
class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        //直接通过当前节点是无法判断是否是叶子节点的
        //如果该节点的左节点不为空，该节点的左节点的左节点为空，该节点的左节点的右节点为空，则找到了一个左叶子
        if(root==null) return 0;
        int sum=0;
        if(root.left!=null&&root.left.left==null&&root.left.right==null) {
            sum += root.left.val;
        }
        
        int leftsum = sumOfLeftLeaves(root.left);
        int rightsum = sumOfLeftLeaves(root.right);
        return leftsum+rightsum+sum;
    }
}
  • 栈迭代
class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        //直接通过当前节点是无法判断是否是叶子节点的
        //如果该节点的左节点不为空，该节点的左节点的左节点为空，该节点的左节点的右节点为空，则找到了一个左叶子
        if(root==null) return 0;
        int sum=0;
        Stack<TreeNode> stack = new Stack();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node = stack.pop();
            if(node.left!=null && node.left.left==null && node.left.right==null){
                sum += node.left.val;
            }
            if(node.left!=null) stack.push(node.left);
            if(node.right!=null) stack.push(node.right);
        }
        return sum;
    }
}
  • 队列迭代(层序)
class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        //直接通过当前节点是无法判断是否是叶子节点的
        //如果该节点的左节点不为空，该节点的左节点的左节点为空，该节点的左节点的右节点为空，则找到了一个左叶子
        if(root==null) return 0;
        int sum=0;
        Queue<TreeNode> queue = new LinkedList();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            while(size-->0){
                TreeNode node = queue.poll();
                if(node.left!=null){
                    if(node.left.left==null&&node.left.right==null){
                        sum += node.left.val;
                    }else{
                        queue.offer(node.left);
                    }
                }
                if(node.right!=null) queue.offer(node.right);
            }
        }
        return sum;
    }
}

找树左下角的值[513]

  • 递归
class Solution {
    //最大深度
    private int maxheight = -1;
    //最左节点的值
    private int value = 0;

    public int findBottomLeftValue(TreeNode root) {
        if(root==null) return 0;
        //本题要求求最深的叶子节点，所以不采取从下向上递归(返回值)，而采取从上往下递归(传参)
        findLeftValue(root,0);
        return value;
    }

    private void findLeftValue(TreeNode root,int deep){
        //deep当前深度
        if(root.left==null && root.right==null) {
            if(deep>maxheight){
                value=root.val;
                maxheight=deep;
            }
        }
        if(root.left!=null) findLeftValue(root.left,deep+1);
        if(root.right!=null) findLeftValue(root.right,deep+1);
    }
}
  • 队列迭代(层序)
class Solution {
    public int findBottomLeftValue(TreeNode root) {
        if(root==null) return 0;

        int leftOrder = 0;
        Queue<TreeNode> queue = new LinkedList();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            leftOrder = queue.peek().val;
            while(size-->0){
                TreeNode node = queue.poll();
                if(node.left!=null) queue.offer(node.left);
                if(node.right!=null) queue.offer(node.right);
            }
        }
        return leftOrder;
    }
}
ChenJieYaYa
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
力扣刷题 | 二叉树
12-20
文章目录总述基本概念二叉树性质二叉树遍历94 二叉树的中序遍历95 不同的二叉搜索树296 不同的二叉搜索树98 验证二叉搜索树100 相同的树101 对称二叉树102 二叉树的层序遍历103 二叉树的锯齿形层次遍历104 二叉树的...
[力扣]144. 二叉树的前序遍历java
12-21
二叉树遍历是针对二叉树进行操作的一种基本算法，主要有三种类型：前序遍历、中序遍历和后序遍历。本问题主要关注的是前序遍历，它是二叉树遍历的一种常见方式。 **前序遍历**的顺序是：先访问根节点，然后递归地...
力扣二叉树题目专题解析
weixin_43757333的博客
03-27 684
刚刚我们说过了二叉树有两种存储方式顺序存储，和链式存储，顺序存储就是用数组来存，这个定义没啥可说的，我们来看看链式存储的二叉树节点的定义方式。int val;大家会发现二叉树的定义 和链表是差不多的，相对于链表 ，二叉树的节点里多了一个指针， 有两个指针，指向左右孩子。144.二叉树的前序遍历(opens new window)94.二叉树的中序遍历(opens new window)145.二叉树的后序遍历(opens new window)
力扣二叉树专题Ⅰ
BlingBling_An_的博客
08-08 183
二叉树基础理论 满二叉树 只有度数为零和度数为二的结点，且度数为零的结点在同一层上。 深度为k，有2^k-1个结点的二叉树 完全二叉树 从满二叉树而来，从右下角水平向左去掉结点而形成的树。 若最底层为第h层，则该层包含[1, 2^h-1]个结点。 用完全二叉树实现优先队列（堆排序）—— 把优先值最大的元素(根结点)出列，可分为如下步骤： 1.交换首尾两个元素的位置，这样尾元素将会成为根结点，堆有序被打破； 2.剪掉被交换到末尾的原根元素； 3.把交换到根结点的元素下沉到合适位置，重新调整为大顶堆；.
力扣二叉树专题Ⅱ
BlingBling_An_的博客
08-13 114
来吧~继续奔跑！从左叶子之和开始。（本篇建议读完上篇力扣二叉树专题Ⅰ后服用） 二叉树属性 左叶子之和 LC 第404题 迭代法 class Solution { public: int sumOfLeftLeaves(TreeNode* root) { stack<TreeNode*> st; int sum = 0; if(!root) return sum; st.push(root); while(!.
力扣二叉树题目记录
weixin_43937698的博客
12-12 121
二叉树相关题目1.剑指 Offer 55 - I. 二叉树的深度（简单） 在学习二叉树相关代码的过程中，发现了一个博客写的很好，记录一下：https://www.cnblogs.com/anzhengyu/p/11083568.html 1.剑指 Offer 55 - I. 二叉树的深度（简单） 题目描述： 输入一棵二叉树的根节点，求该树的深度。从根节点到叶节点依次经过的节点（含根、叶节点）形成树的一条路径，最长路径的长度为树的深度。 示例： 给定二叉树 [3,9,20,null,null,15,7]，
力扣python实现-二叉树合集
莫听穿林打叶声，何妨吟啸且徐行。
06-16 303
力扣python实现-二叉树合集
[力扣]二叉树5—总结
weixin_51699336的博客
05-10 268
代码随想录[原文指路]
力扣--二叉树知识点
华辰烟雨的博客
07-20 1079
一、理论基础 1、二叉树的种类 （1）满二叉树 满二叉树：如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。 这棵二叉树为满二叉树，也可以说深度为k，有2^k-1个节点的二叉树。 （2）完全二叉树 完全二叉树：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。，若最底层为第h层，则该层包含1~2^h-1个节点。 （3）二叉搜索树 前面的树都没有数...
[力扣刷题总结]（二叉树篇）
weixin_38800498的博客
12-29 1378
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录二叉树理论基础篇1.二叉树的种类2.二叉树的存储方式3.二叉树的遍历方式4.二叉树的定义////////////二叉树的遍历方式///////////////二叉树的递归遍历二叉树的迭代遍历1. 迭代法中序遍历2.迭代法前序遍历3.迭代法后序遍历144. 二叉树的前序遍历解法1：递归遍历解法2：迭代遍历二叉树的层序遍历////////////二叉树的属性///////////////////////////二叉树的修改与改造////
力扣LeetBook＜二叉树＞学习笔记
lisz的博客
10-30 722
二叉树 文章目录概述树的遍历1.二叉树的前序遍历2.二叉树的中序遍历3.二叉树的后序遍历4.二叉树的层序遍历运用递归解决问题1.二叉树的最大深度2.对称二叉树3.路径总和总结1.从中序和后序遍历序列构造二叉树2.从前序和中序遍历序列构造二叉树3.填充每个节点的下一个右侧节点指针4.填充每个节点的下一个右侧节点指针Ⅱ5.二叉树的最近公共祖先6.二叉树的序列化和反序列化 概述 从图的观点：树是一个拥有N个结点和N-1条边的有向无环图。 二叉树：每个节点最多有两个子树。 树的遍历 前序：根-左-右 中序：左-根
Python算法题源代码-LeetCode(力扣)-二叉树中的最大路径和
02-21
力扣热题Python源代码 题目：124. 二叉树中的最大路径和 二叉树中的 路径 被定义为一条节点序列，序列中每对相邻节点之间都存在一条边。同一个节点在一条路径序列中 至多出现一次 。该路径 至少包含一个 节点，且不...
二叉树模版
01-19
3. **线索二叉树(in_thread_binary_tree)**：线索二叉树是在普通二叉树的基础上，为了解决二叉树的中序遍历问题而引入的。在二叉链表的每个结点中增设两个线索，分别指向其前驱和后继，使得在非递归情况下也能方便地...
js代码-二叉树前序遍历
07-16
二叉树的遍历是对其进行操作的基础，其中包括前序遍历、中序遍历和后序遍历。本文将详细讲解二叉树的前序遍历，并结合提供的`main.js`文件中的代码进行解析。 **前序遍历** 是二叉树遍历的一种方法，其顺序为：访问...
stack(leetcode练习题,牛客)
2301_81692739的博客
07-19 428
最开始写的，总会有一些样例过不了，没考虑全，后来看题解上的方法，将下标压入栈中，用右括号的下标减去栈顶下标，就是有效长度。不然只顾着最长，反而无法得到正确的有效长度。一个完整的括号，要么是1，要么里边包含其他括号，进行了 *2。所以，可以每遇到一个右括号，进行一次运算，第一次为 1，以后每次乘二，累加到栈顶。遇到左括号，就向栈压入0，重新运算，当遇到右括号，再弹出.如果数字比栈顶小就压入，否则，将栈顶删除直到，比栈顶小或这栈为空。关于stack的知识，可以看点击查看上面的博客，以下题目全在。
Java | Leetcode Java题解之第273题整数转换英文表示
最新发布
m0_57195758的博客
07-22 266
Java | Leetcode Java题解之第273题整数转换英文表示
【LeetCode】分隔链表
qq_26521261的博客
07-20 412
给你一个链表的头节点 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 188题： 买卖股票的最佳时机IV优化（原创）
it_fly的专栏
07-21 250
算法思路：1.买了j次的最大获利值等于：昨天买了j次，和昨天卖了j-1次，今天再买的最大值；2.卖了j次的最大获利值等于：昨天卖了j次，和昨天买了j次，今天再卖掉的最大值
力扣平衡二叉树c语言
09-30
力扣平衡二叉树C语言解法如下： ```c // 求二叉树的最大深度（高度） int maxDepth(struct TreeNode* root) { if (root == NULL) { return 0; } int leftHeight = maxDepth(root->left); int rightHeight = ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值