Leetcode题解——二叉树

最新推荐文章于 2022-05-28 01:35:25 发布
最新推荐文章于 2022-05-28 01:35:25 发布
阅读量320 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hitzijiyingcai/article/details/107907955
版权

 

目录

112. 路径总和

113. 路径总和 II 

437. 路径总和 III

 124. 二叉树中的最大路径和

99. 恢复二叉搜索树

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

102. 二叉树的层序遍历

96. 不同的二叉搜索树

95. 不同的二叉搜索树 II

98. 验证二叉搜索树

101. 对称二叉树

 104. 二叉树的最大深度

114. 二叉树展开为链表

208. 实现 Trie (前缀树)

具体：

112. 路径总和

DFS

首先是 DFS 解法，该解法的想法是一直向下找到叶子节点，如果到叶子节点时sum == 0，说明找到了一条符合要求的路径。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def hasPathSum(self, root: TreeNode, sum: int) -> bool:
        if not root:
            return False
        if sum == root.val and not root.left and not root.right:
            return True
        left = self.hasPathSum(root.left, sum - root.val)
        right = self.hasPathSum(root.right, sum - root.val)
        return left or right

栈
除了上面的 队列 解法以外，也可以使用 栈，同时保存节点和到这个节点的路径和。但是这个解法已经不是 BFS。因为会优先访问 后进来 的节点，导致会把根节点的右子树访问结束之后，才访问左子树。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def hasPathSum(self, root, sum):
        """
        :type root: TreeNode
        :type sum: int
        :rtype: bool
        """
        if not root:
            return False
        stack = []
        stack.append((root, root.val))
        while stack:
            node, path = stack.pop()
            if not node.left and not node.right and path == sum:
                return True
            if node.left:
                stack.append((node.left, path + node.left.val))
            if node.right:
                stack.append((node.right, path + node.right.val))
        return False

113. 路径总和 II 

DFS

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def pathSum(self, root: TreeNode, sum: int) -> List[List[int]]:

        li = []
        
        if  root is None:
            return li
        def find(root,sum,path):
            sum-=root.val
            if root.left is None and root.right is None and sum==0:
                li.append(path+[root.val])
            if root.left:
                find(root.left,sum,path+[root.val])
            if root.right:
                find(root.right,sum,path+[root.val])
        find(root,sum,[])
        return li

437. 路径总和 III

 

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None


# 精简版，五行代码不解释
class Solution:
    def pathSum(self, root: TreeNode, sum: int) -> int:
        def dfs(root, sumlist):
            if root is None: return 0
            sumlist = [num + root.val for num in sumlist] + [root.val]
            return sumlist.count(sum) + dfs(root.left, sumlist) + dfs(root.right, sumlist)
        return dfs(root, [])



# 展开版，易理解
class Solution:
    def pathSum(self, root: TreeNode, sum: int) -> int:

        def dfs(root, sumlist):
            if root is None:
                return 0
            
            sumlist = [num+root.val for num in sumlist]
            sumlist.append(root.val)
            
            count = 0
            for num in sumlist:
                if num == sum:
                    count += 1
            # count = sumlist.count(sum)

            return count + dfs(root.left, sumlist) + dfs(root.right, sumlist)

        return dfs(root, [])

 124. 二叉树中的最大路径和

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def maxPathSum(self, root: TreeNode) -> int:
        self.sum = float("-inf")
        def dfs(node):
            if not node: return 0
            l = dfs(node.left)
            r = dfs(node.right)
            self.sum = max(self.sum,max(l,0)+max(r,0)+node.val)
            return max(0,l,r) + node.val
        dfs(root)
        return self.sum

99. 恢复二叉搜索树

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def recoverTree(self, root: TreeNode) -> None:
        """
        Do not return anything, modify root in-place instead.
        """
        nodes = []
        # 中序遍历二叉树，并将遍历的结果保存到list中        
        def dfs(root):
            if not root:
                return
            dfs(root.left)
            nodes.append(root)
            dfs(root.right)
        dfs(root)
        x = None
        y = None
        pre = nodes[0]
        # 扫面遍历的结果，找出可能存在错误交换的节点x和y
        for i in range(1,len(nodes)):
            if pre.val>nodes[i].val:
                y=nodes[i]
                if not x:
                    x = pre
            pre = nodes[i]
        # 如果x和y不为空，则交换这两个节点值，恢复二叉搜索树 
        if x and y:
            x.val,y.val = y.val,x.val

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

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def countNodes(self, root: TreeNode) -> int:

        if root == None:
            return 0
        if root.left is None and root.right is None:
            return 1
        return self.countNodes(root.left) + self.countNodes(root.right) + 1

102. 二叉树的层序遍历

 

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:

        if not root:
            return []
        res = []
        queue = [root]
        while queue:
			# 获取当前队列的长度，这个长度相当于 当前这一层的节点个数
            size = len(queue)
            tmp = []
			# 将队列中的元素都拿出来(也就是获取这一层的节点)，放到临时list中
			# 如果节点的左/右子树不为空，也放入队列中
            for _ in range(size):
                r = queue.pop(0)
                tmp.append(r.val)
                if r.left:
                    queue.append(r.left)
                if r.right:
                    queue.append(r.right)
			# 将临时list加入最终返回结果中
            res.append(tmp)
        return res

96. 不同的二叉搜索树

 代码：

class Solution:
    def numTrees(self, n):
        """
        :type n: int
        :rtype: int
        """
        G = [0]*(n+1)
        G[0], G[1] = 1, 1

        for i in range(2, n+1):
            for j in range(1, i+1):
                G[i] += G[j-1] * G[i-j]

        return G[n]
class Solution {
public:
    int numTrees(int n) {
        vector<int> G(n + 1, 0);
        G[0] = 1;
        G[1] = 1;

        for (int i = 2; i <= n; ++i) {
            for (int j = 1; j <= i; ++j) {
                G[i] += G[j - 1] * G[i - j];
            }
        }
        return G[n];
    }
};

95. 不同的二叉搜索树 II

递归： 

class Solution {
public:
    vector<TreeNode*> generateTrees(int start, int end) {
        if (start > end) {
            return { nullptr };
        }
        vector<TreeNode*> allTrees;
        // 枚举可行根节点
        for (int i = start; i <= end; i++) {
            // 获得所有可行的左子树集合
            vector<TreeNode*> leftTrees = generateTrees(start, i - 1);

            // 获得所有可行的右子树集合
            vector<TreeNode*> rightTrees = generateTrees(i + 1, end);

            // 从左子树集合中选出一棵左子树，从右子树集合中选出一棵右子树，拼接到根节点上
            for (auto& left : leftTrees) {
                for (auto& right : rightTrees) {
                    TreeNode* currTree = new TreeNode(i);
                    currTree->left = left;
                    currTree->right = right;
                    allTrees.emplace_back(currTree);
                }
            }
        }
        return allTrees;
    }

    vector<TreeNode*> generateTrees(int n) {
        if (!n) {
            return {};
        }
        return generateTrees(1, n);
    }
};

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def generateTrees(self, n: int) -> List[TreeNode]:
        if not n:
            return []
        memo = {}

        def generate(s, e):
            if s > e:
                return [None]
            if (s, e) in memo:
                return memo[(s, e)]
            res = []
            for i in range(s, e + 1):
                left = generate(s, i - 1)
                right = generate(i + 1, e)
                for l in left:
                    for r in right:
                        root = TreeNode(i)
                        root.left = l
                        root.right = r
                        res.append(root)
            memo[(s, e)] = res
            return res

        return generate(1, n)

98. 验证二叉搜索树

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def isValidBST(self, root: TreeNode) -> bool:
        stack, inorder = [], float('-inf')
        
        while stack or root:
            while root:
                stack.append(root)
                root = root.left
            root = stack.pop()
            # 如果中序遍历得到的节点的值小于等于前一个 inorder，说明不是二叉搜索树
            if root.val <= inorder:
                return False
            inorder = root.val
            root = root.right

        return True

 

class Solution {
public:
    bool isValidBST(TreeNode* root) {
        stack<TreeNode*> stack;
        long long inorder = (long long)INT_MIN - 1;

        while (!stack.empty() || root != nullptr) {
            while (root != nullptr) {
                stack.push(root);
                root = root -> left;
            }
            root = stack.top();
            stack.pop();
            // 如果中序遍历得到的节点的值小于等于前一个 inorder，说明不是二叉搜索树
            if (root -> val <= inorder) return false;
            inorder = root -> val;
            root = root -> right;
        }
        return true;
    }
};

101. 对称二叉树

同剑指offer 58题： 

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        return self.isSym(root, root)
        
    def isSym(self, tree1, tree2):
        if tree1 == None and tree2 == None:
            return True
        if tree1 == None or tree2 == None:
            return False
        if tree1.val != tree2.val:
            return False
        return self.isSym(tree1.left, tree2.right) and self.isSym(tree1.right, tree2.left)

 104. 二叉树的最大深度

同剑指offer  38题： 

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if root == None:
            return 0
        count = max(self.maxDepth(root.left), self.maxDepth(root.right)) + 1
        return count

114. 二叉树展开为链表

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def flatten(self, root: TreeNode) -> None:
        """
        Do not return anything, modify root in-place instead.
        """
        if not root:
            return
        
        stack = [root]
        prev = None
        
        while stack:
            curr = stack.pop()
            if prev:
                prev.left = None
                prev.right = curr
            left, right = curr.left, curr.right
            if right:
                stack.append(right)
            if left:
                stack.append(left)
            prev = curr
class Solution {
public:
    void flatten(TreeNode* root) {
        if (root == nullptr) {
            return;
        }
        auto stk = stack<TreeNode*>();
        stk.push(root);
        TreeNode *prev = nullptr;
        while (!stk.empty()) {
            TreeNode *curr = stk.top(); stk.pop();
            if (prev != nullptr) {
                prev->left = nullptr;
                prev->right = curr;
            }
            TreeNode *left = curr->left, *right = curr->right;
            if (right != nullptr) {
                stk.push(right);
            }
            if (left != nullptr) {
                stk.push(left);
            }
            prev = curr;
        }
    }
};

208. 实现 Trie (前缀树)

class TrieNode:
    def __init__(self):
        self.children = defaultdict(TrieNode)
        self.is_word = False


class Trie:

    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.root = TrieNode()


    def insert(self, word: str) -> None:
        """
        Inserts a word into the trie.
        """
        node = self.root
        for s in word:
            node = node.children[s]
        node.is_word = True


    def search(self, word: str) -> bool:
        """
        Returns if the word is in the trie.
        """
        node = self.root
        for s in word:
            if s in node.children:
                node = node.children[s]
            else:
                return False
        return node.is_word


    def startsWith(self, prefix: str) -> bool:
        """
        Returns if there is any word in the trie that starts with the given prefix.
        """
        node = self.root
        for s in prefix:
            if s in node.children:
                node = node.children[s]
            else:
                return False
        return True
        

# Your Trie object will be instantiated and called as such:
# obj = Trie()
# obj.insert(word)
# param_2 = obj.search(word)
# param_3 = obj.startsWith(prefix)

 

子季鹰才
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
python-leetcode面试题解之对称二叉树.zip
03-06
python python_leetcode面试题解之对称二叉树
第一遍做LeeCode：95. 不同的二叉搜索树 II
ssustung的博客
07-21 131
题目 不同的二叉搜索树 II 给定一个整数 n，生成所有由 1 … n 为节点所组成的 二叉搜索树 。 涉及的新知识 二叉搜索树关键的性质是根节点的值大于左子树所有节点的值，小于右子树所有节点的值，且左子树和右子树也同样为二叉搜索树。 关于二叉搜索树的一些操作 做法 我对这个“树”的操作很陌生，结果还是看题解的做法与思路。 首先是对[0，n]进行遍历，取其中的一个值 i 分左右，然后再迭代下去。 class Solution { public: vector<TreeNode*
leetcode刷题——算法（5）:分治
qq_37772475的博客
02-15 138
分治（2.15） 1. 给表达式加括号 一开始未做出 ※ 2. 不同的二叉搜索树 一开始未做出 ※ 1. 给表达式加括号 241. Different Ways to Add Parenthese...
leetcode 95. 不同的二叉搜索树 II 树的 dfs
Little_boy_z的博客
09-06 250
class Solution { public: vector<TreeNode*> generateTrees(int start, int end) { if (start > end) { return { nullptr }; } vector<TreeNode*> allTrees; // 枚举可行根节点 for (int i = start; i <...
LeetCode ：95/96 不同的二叉搜索树 (二叉搜索树组合的个数)
chengda321的专栏
02-28 190
参考力扣上官方的题解，采用动态规划法，关键点在于： 1、状态转移公式的推导； 2、边界的处理：dp[0]也初始化为1，因为+=的存在，dp除0,1之外，后面的都要初始化为0 class Solution { public: int numTrees(int n) { if(n <= 1) return n; vector<int&gt...
（每日一练c++）95. 不同的二叉搜索树 II
weixin_39827856的博客
05-28 142
95. 不同的二叉搜索树 II 给你一个整数 n ，请你生成并返回所有由 n 个节点组成且节点值从 1 到 n 互不相同的不同 二叉搜索树 。可以按 任意顺序 返回答案。 示例 1： 输入：n = 3 输出：[[1,null,2,null,3],[1,null,3,2],[2,1,3],[3,1,null,null,2],[3,2,null,1]] 示例 2： 输入：n = 1 输出：[[1]] 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/probl
leetcode分类-Leetcode:Leetcode题解
06-30
Leetcode代码题解 随缘刷题，选择性更新题解 LeetCode 94 144 145 二叉树的前中后序遍历： Leetcode 128 longest-consecutive-sequence 最长连续序列： Leetcode 155 Min Stack 最小栈： LeetCode 773 滑动谜题： .....
javascript-leetcode:LeetCode 题解仓库:meat_on_bone:
04-13
前端食堂的 LeetCode 题解仓库2021 年计划，这个仓库写满 100 篇 LeetCode 题解(JavaScript)。进度已经完成 52 道。数组链表树94. 二叉树的中序遍历144. 二叉树的前序遍历145. 二叉树的后序遍历100. 相同的树101. ...
leetcode分类-leetcode:leetcode题解收录
06-30
leetcode 分类 leetcode 题目分类 滑动窗口：480、1208、1456、643、424、1423、978、485、1004、1052 动态规划：509、70、53、121、200、322、198 分治： 回溯： 贪心： 二叉树： 链表：206
LeetCode：leetcode题解，记录自己的leetcode解题之路
02-14
leetcode题解，记录自己的leetcode解题之路 目录 [206。反转链表]（＃206。反转链表） [876。链表的中间结点]（＃876。链表的中间结点） [19。（＃19。删除链表的倒数第N个例程） [29。两数相除]（＃29。两数相除...
leetcode 95. 不同的二叉搜索树 II
j_thame_myhome的博客
07-21 117
给定一个整数 n，生成所有由 1 ... n 为节点所组成的 二叉搜索树 。 题解： 1.一个整数 n 2.由 1 ... n 为节点所组成的 二叉搜索树 3.注意返回所有树节点的组合，不是个数96. 不同的二叉搜索树 4.96返回数量，该题返回所有情况 示例： 输入：3 输出： [[1,null,3,2], [3,2,null,1], [3,1,null,null,2], [2,1,3], [1,null,2,null,3]] 解释： 以上的输出对...
for(auto &a :b) 循环的另一种用法
Warms的博客
02-04 1956
例子 int arr[10]; for(int i=0;i<10;i++) { arr[i]=i; } //与上面for循环输出相同 for(auto &a:arr) { std::cout << a; }
c++中的for(auto a:b)用法
热门推荐
qq_33651375的博客
08-29 3万+
for(auto a:b)中b为一个容器，效果是利用a遍历并获得b容器中的每一个值，但是a无法影响到b容器中的元素。 for(auto &a:b)中加了引用符号，可以对容器中的内容进行赋值，即可通过对a赋值来做到容器b的内容填充。 ...
数据结构之树问题汇总
carolineme的博客
11-03 364
一、二叉树的前序、中序、后序遍历 1.前序遍历 递归解法：根左右 class Solution { public: vector<int> preorderTraversal(TreeNode* root) { vector<int>res; preorder(root,res); return res; } void preorder(TreeNode *root,vector<int>&a
95. 不同的二叉搜索树 II
JamesHuang的博客
07-21 309
大家好，我是小黄呀 题目链接 题目大意 给定一个整数n，生成所有由1..n为节点所组成的二叉搜索树 二叉搜索树，基本的数据结构，性质：所有的左子树都比根节点小，所有的右子树都比根节点大。 思路分析（递归） 要求出1…n的所有可能，则从1开始遍历 以1为根节点，[空]为左子树，[2…n]的所有可能作为右子树 以2为根节点，[1]为左子树，[3…n]的所有可能作为右子树 以3为根节点,[1,2]的所有可能作为左子树，[4…n]的所有可能作为右子树。 直到n作为根节点的类似情况，其中将任一可能的左右子树与相应
递归_95.不同的二叉搜索树 II(20200721)
Alicepus的博客
07-21 143
// 1.思路对于一颗二叉搜索树以及每一颗子树，由基本性质 // 2.索引 1 ~ i-1 显然对应左子树， i+1 ~ n对应右子树 i 为根 // 3.先枚举每一个可行的根节点 // 4.按照 2 递归的找出每一颗子树的左子树和右子树 // 5.把递归出的左子树和右子树接到对应的根上 // 6.把得到的答案返回 /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *l
for(auto &i:s)和for(auto i:s)区别
EncodedStar的博客
06-27 4436
** 一、for(auto &i:s)和for(auto i:s)区别：** 代码1： #include<iostream> #include<string> using namespace std; string s = "hello"; for (auto &i : s ) //i是个引用 i到底引用的是什么？ i = toupper(i); //改变...
不同的二叉搜索树
baidu_39560330的博客
04-22 63
给定一个整数 n，生成所有由 1 … n 为节点所组成的 二叉搜索树 。 示例： 输入：3 输出： [ [1,null,3,2], [3,2,null,1], [3,1,null,null,2], [2,1,3], [1,null,2,null,3] ] 提示： 0 <= n <= 8 首先明白什么是二叉搜索树，对任意一个节点，左边的元素比其小，右边的元素比其大。然后看题。真是懵逼，这是啥啊？但其实还是有技巧的。用递归 + 回溯。一步一步缩小问题规模，从而解决问题。 /** * Defini
二叉树练习题题解
PERCENTILE__的博客
10-30 450
1.给前序中序来还原二叉树 求出深度 #include <stdio.h> #include <stdlib.h> char str1[51] ,str2[51]; int main() { int m; scanf("%d",&m); scanf("%s",str1); scanf("%s",str2); int re...
爬取leetcode题解中python3代码
最新发布
03-14
我可以为您提供一个爬取LeetCode题解中Python3代码的思路，您可以使用Python的requests库和BeautifulSoup库来实现。首先，您需要使用requests库发送HTTP请求获取LeetCode题解页面的HTML代码，然后使用BeautifulSoup...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值