LeetCode刷题——树——递归

最新推荐文章于 2024-08-15 05:02:54 发布
最新推荐文章于 2024-08-15 05:02:54 发布
阅读量179 收藏
点赞数
分类专栏： leetcode刷题 文章标签： leetcode 树结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42589774/article/details/106729826
版权

LeetCode——树——递归

1、树的高度
T.104 Maximum Depth of Binary Tree (Easy)
在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int maxDepth(TreeNode* root) {
        if (!root)
        return 0;
        return max(maxDepth(root->left), maxDepth(root->right)) + 1;
        
    }
};

2、平衡树
T110 Balanced Binary Tree (Easy)
在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isBalanced(TreeNode* root) {
        if (!root)
        return true;
        if (abs(getDepth(root->left) - getDepth(root->right)) > 1)
        return false;
        return isBalanced(root->left) && isBalanced(root->right);
        
    }
        int getDepth(TreeNode* root){
        if (!root)
        return 0;
        return(max(getDepth(root->left), getDepth(root->right)) + 1);
    }
};

3、两节点的最长路径
T. 543 Diameter of Binary Tree (Easy)
在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int diameterOfBinaryTree(TreeNode* root) {
        int res = 0;
        depth(root, res);
        return res;
    }
    int depth(TreeNode* root, int& res){
        if(!root)
        return 0;
        int L = depth(root->left, res);
        int R = depth(root->right, res);
        res = max(res, L+R);
        return max(L, R)+1;
    }
    
};

4、翻转树
T.226 Invert Binary Tree (Easy)
在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(!root)
        return NULL;
        TreeNode* tmp = root->left;
        root->left = invertTree(root->right);
        root->right = invertTree(tmp);
        return root;

    }
};

5、归并两棵树
T.617 Merge Two Binary Trees (Easy)
在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
        if(!t1)
        return t2;
        if(!t2)
        return t1;
        TreeNode* t = new TreeNode(t1->val + t2->val);
        t->left = mergeTrees(t1->left, t2->left);
        t->right = mergeTrees(t1->right, t2->right);
        return t;
    }
};

6、判断路径和是否等于一个数
T.112 Path Sum (Easy)
在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool hasPathSum(TreeNode* root, int sum) {
        if(!root)
        return false;
        if(!root->left && !root->right && root->val == sum)
        return true;
        return hasPathSum(root->left, sum-root->val) || hasPathSum(root->right, sum-root->val);
        
    }
};

7、统计路径和等于一个数的路径数量
T.437 Path Sum III (Easy)
在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int pathSum(TreeNode* root, int sum) {
        if(!root)
        return 0;
        return sumUp(root, 0, sum) + pathSum(root->left, sum) + pathSum(root->right, sum);

    }
    int sumUp(TreeNode* root, int pre, int& sum){
        if(!root)
        return 0;
        int cur = pre + root->val;
        return (cur == sum) + sumUp(root->left, cur, sum) + sumUp(root->right, cur, sum);

    }
};

8、子树
T.572 Subtree of Another Tree (Easy)
在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isSubtree(TreeNode* s, TreeNode* t) {
        if(!s)
        return false;
        if(isSame(s, t))
        return true;
        return isSubtree(s->left, t) || isSubtree(s->right, t);
        
    }
    bool isSame(TreeNode* s, TreeNode* t){
        if(!s && !t)
        return true;
        if(!s || !t)
        return false;
        if(s->val != t->val)
        return false;
        return isSame(s->left, t->left) && isSame(s->right, t->right);
    }
};

9、树的对称
T.101 Symmetric Tree (Easy)
在这里插入图片描述
法一：递归

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if(!root)
        return true;
        return isSymmetric(root->left, root->right);
}
    bool isSymmetric(TreeNode* left, TreeNode* right){
        if (!left && !right) 
        return true;
        if (left && !right || !left && right || left->val != right->val) 
        return false;
        return isSymmetric(left->left, right->right) && isSymmetric(left->right, right->left);
        
    }
};

法二：迭代

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if(!root)
        return true;
        queue<TreeNode*> q1,q2;
        q1.push(root->left);
        q2.push(root->right);

        while(!q1.empty() && !q2.empty()){
            TreeNode* node1 = q1.front();
            q1.pop();
            TreeNode* node2 = q2.front();
            q2.pop();
            if(!node1 && !node2)
            continue;
            if(!node1 && node2)
            return false;
            if(node1 && !node2)
            return false;
            if(node1->val != node2->val)
            return false;
            q1.push(node1->left);
            q1.push(node1->right);
            q2.push(node2->right);
            q2.push(node2->left);
        }
        return true;

        
    }
};

10、最小路径
T.111 Minimum Depth of Binary Tree (Easy)
在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int minDepth(TreeNode* root) {
        if(!root)
        return 0;
        if(!root->left)
        return 1 + minDepth(root->right);
        if(!root->right)
        return 1 + minDepth(root->left);
        return 1 + min(minDepth(root->left), minDepth(root->right));
    }

};

11、统计左叶子节点的和
T.404 Sum of Left Leaves (Easy)
在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int sumOfLeftLeaves(TreeNode* root) {
        if(!root)
        return 0;
        if(root->left && !root->left->left && !root->left->right)
        return root->left->val + sumOfLeftLeaves(root->right);
        return sumOfLeftLeaves(root->left) + sumOfLeftLeaves(root->right);

    }
};

12、相同节点值的最大路径长度
T.687 Longest Univalue Path (Easy)
在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int longestUnivaluePath(TreeNode* root) {
        int res = 0;
        UnivaluePath(root, res);
        return res;
    }
    int UnivaluePath(TreeNode* node, int& res) {
        if (!node) return 0;
        int l = UnivaluePath(node->left, res);
        int r = UnivaluePath(node->right, res);
        int pl = 0;
        int pr = 0;
        if(node->left && node->val == node->left->val) 
        pl = l + 1;
        if(node->right && node->val == node->right->val) 
        pr = r + 1;
        res = max(res, pl + pr);
        return max(pl, pr);
    }

};

13、间隔遍历
T.337 House Robber III (Medium)
在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int rob(TreeNode* root) {
        vector<int> res = dfs(root);
        return max(res[0], res[1]);

    }
    vector<int> dfs(TreeNode* root){
        if(!root)
        return vector<int> (2,0);
        vector<int> left = dfs(root->left);
        vector<int> right = dfs(root->right);
        vector<int> res(2,0);
        res[0] = max(left[0], left[1]) + max(right[0], right[1]);
        res[1] = left[0] + right[0] + root->val;
        return res;


    }
};

14、找出二叉树中第二小的节点
T.671 Second Minimum Node In a Binary Tree (Easy)
在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int findSecondMinimumValue(TreeNode* root) {
        return helper(root, root->val);
    }
    int helper(TreeNode* node, int first) {
        if (!node) 
        return -1;
        if (node->val != first) 
        return node->val;
        int left = helper(node->left, first), right = helper(node->right, first);
        return (left == -1 || right == -1) ? max(left, right) : min(left, right);
    
    }
};
purple 桐
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode刷题笔记——#70. 爬楼梯
12-22
  一般做斐波那契数列我们会用递归的方式，然而不知道为什么，这道题用递归会超时，所以还是稳着点写。 ###### leetcode 代码主体 ###### class Solution: def climbStairs(self, n: int) -> int: a, b = 1, 2 ...
LeetCode刷题笔记——#21. 合并两个有序链表
12-22
LeetCode 的第 21 题要求合并两个已排序的链表。这道题目属于数据结构中的链表问题，难度被标记为简单。目标是将两个有序链表（升序排列）合并成一个新的有序链表，并返回这个新链表的头节点。 【解题思路】 解决这...
LeetCode——树：递归
努力努力再努力L
02-15 353
LeetCode——树：递归 目录 概述 树的高度（LeetCode104） 平衡树（LeetCode110） 两节点的最长路径（LeetCode543） 翻转树（LeetCode226） 归并两棵树（LeetCode617） 判断路径和是否等于一个数（LeetCode112） 统计路径和等于一个数的路径数量（LeetCode437） 子树（LeetCode572） 树的对称（LeetCode...
leetCode 树专题 递归
一名路过的小码农啊
02-22 128
104. 二叉树的最大深度 给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明:叶子节点是指没有子节点的节点。 示例： 给定二叉树 [3,9,20,null,null,15,7]， 3 / \ 9 20 / \ 15 7 返回它的最大深度3 。 public int maxDepth(TreeN...
leetcode，树，递归算法，Binary Tree Paths
weixin_44052726的博客
12-24 103
题目： Given a binary tree, return all root-to-leaf paths. Note: A leaf is a node with no children. Example: Input: 1 / \ 2 3 \ 5 Output: [&quot;1-&amp;gt;2-&amp;gt;5&quot;, &quot;1-&amp;gt;3&quot;] Ex
leetcode_树递归
黑铁程序员的打怪升级之路
05-15 161
未完待续。。。 1.leetcode 671 1.1题目描述 1.2代码 利用根节点是最小值的这个特点 /* 注意： 1）最小值一定是根节点 2）求出左右子树中的最小值就是第二小的值， 且这个值不能等于 root.val（最小值），并且注意样例 [2,2,2] 3）添加 flag 标志位，确保 min 被修改（存在比最小值小的数）已知。 */ public
leetcode刷题之 树(8)-递归:子树
qq_40320556的博客
06-19 138
[LeetCode] Subtree of Another Tree 另一个树的子树 Given two non-empty binary treessandt, check whether treethas exactly the same structure and node values with a subtree ofs. A subtree ofsis a tr...
LeetCode刷题——91. 解码方法
12-20
【LeetCode刷题——91. 解码方法】 这道编程题目来自LeetCode，主要考察的是动态规划和递归解题技巧。问题的核心是给定一个仅由数字组成的非空字符串，我们需要计算出该字符串有多少种不同的解码方法，这里的解码是...
LeetCode刷题——62. 不同路径
12-20
【LeetCode刷题——62. 不同路径】这道题目是经典的动态规划问题，主要考察的是算法设计和实现能力。题目描述了一个机器人在m x n的网格中，从左上角开始，每次只能向下或向右移动一步，目标是到达右下角。求解从...
LeetCode刷题笔记——19. 删除链表的倒数第N个节点
12-21
【LeetCode刷题笔记——19. 删除链表的倒数第N个节点】 这道LeetCode中的题目属于中等难度，主要考察的是对链表数据结构的理解以及算法设计能力。问题的核心是找到链表中倒数第N个节点，并将其删除。与《剑指Offer...
二叉搜索树的后序遍历序列:递归中不要过早return f(左)&&f(右)
学无止境
03-15 359
题目描述 输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。 总结：递归中不要过早return f(左)&&f(右) ，一般情况没有这么完备，还要分段考虑，这题左子树可能为空，右子树也可能为空，所以不要一想到二叉树递归就是 return f(左)&&f(右) class
二叉树的存储结构
Here_的博客
10-09 236
二叉树的顺序存储 完全二叉树 这个是在完全二叉树中，什么是完全二叉树呢？简单就是结点的编号要和满二叉树的编号一一对应。 非完全二叉树： 补成完全二叉树，然后在补入的结点位置放入0； 二叉树的链式存储 data存入数据，再声明两个指针 ...
二叉树的专题
Alicepus的博客
07-05 130
1.数据结构： class TreeNode{ int val; //左孩子 TreeNode left; //右孩子 TreeNode right; } 2.二叉树的最大深度 int maxDeath(TreeNode node){ if(node==null){ return 0; } int left = maxDeath(node.left); int right = maxDeath(node.right);
二分查找基本框架 （返回target，返回left，返回right）
qq_34318333的博客
09-18 2441
/*返回target所在的位置 intbinary_search(vector<int>nums,inttarget) { intleft=0; intright=nums.size(); while(left<=right) { intmid=left+(right-left)/2; if(nums[m...
PAT甲级——1102 Invert a Binary Tree (层序遍历+中序遍历)
小熊猫的博客
05-26 202
1102Invert a Binary Tree(25分) The following is from Max Howell @twitter: Google: 90% of our engineers use the software you wrote (Homebrew), but you can't invert a binary tree on a whiteboard so...
LeetCode算法题解——二叉树的递归求解
qq_41214610的博客
05-02 472
LeetCode 树递归直接递归104. 二叉树的最大深度思路代码226. 翻转二叉树思路代码617. 合并二叉树思路代码子函数中递归二级目录 因为树天生是一种递归结构，所以很多树的问题可以使用递归来进行处理。递归算法的特点，是子问题和原问题具有相同的解结构，并且原问题的解依赖于子问题的解。递归算法主要关注两个问题：第一是如果到达递归边界怎么办；第二是如果没有到达递归边界怎么办。 直接递归 104...
树(4)——翻转二叉树(T.226)
Lyang-Never
06-11 134
题目描述 题解 题解1： # 递归 class Solution: def invertTree(self, root: TreeNode) -> TreeNode: if not root:return None if root.left: node_left = self.invertTree(root.left) else: node_left = None if root
C语言 | Leetcode C语言题解之第337题打家劫舍III
最新发布
m0_59237910的博客
08-15 257
C语言 | Leetcode C语言题解之第337题打家劫舍III
Java | Leetcode Java题解之第337题打家劫舍III
m0_57195758的博客
08-15 318
Java | Leetcode Java题解之第337题打家劫舍III
AcWing暑期LeetCode刷题班-树专题：判断BST
"AcWing夏季LeetCode刷题活动介绍及树相关题目解析" 在AcWing的暑期LeetCode刷题活动中，参与者将面临一系列精选的高频率算法题目，总计80道，涵盖了各种数据结构和算法主题。活动分为8周进行，每周会有10道题目，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值