Leetcode 刷题第18天 | 654,617,700

最新推荐文章于 2024-07-14 11:23:58 发布

一只AI学习小朋友

最新推荐文章于 2024-07-14 11:23:58 发布

阅读量27

点赞数

分类专栏： Leetcode刷题文章标签： leetcode 算法 python

本文链接：https://blog.csdn.net/m0_46690443/article/details/132780708

版权

Leetcode刷题专栏收录该内容

23 篇文章 0 订阅

订阅专栏

Leetcode 654 最大二叉树

题目：

给定一个不重复的整数数组 nums 。最大二叉树可以用下面的算法从 nums 递归地构建:
创建一个根节点，其值为 nums 中的最大值。
递归地在最大值左边的子数组前缀上构建左子树。
递归地在最大值右边的子数组后缀上构建右子树。
返回 nums 构建的最大二叉树。
示例 1：
示例1
输入：nums = [3,2,1,6,0,5]
输出：[6,3,5,null,2,0,null,null,1]
解释：递归调用如下所示：

[3,2,1,6,0,5] 中的最大值是 6 ，左边部分是 [3,2,1] ，右边部分是 [0,5] 。
- [3,2,1] 中的最大值是 3 ，左边部分是 [] ，右边部分是 [2,1] 。
  - 空数组，无子节点。
  - [2,1] 中的最大值是 2 ，左边部分是 [] ，右边部分是 [1] 。
    - 空数组，无子节点。
    - 只有一个元素，所以子节点是一个值为 1 的节点。
- [0,5] 中的最大值是 5 ，左边部分是 [0] ，右边部分是 [] 。
  - 只有一个元素，所以子节点是一个值为 0 的节点。
  - 空数组，无子节点。

示例 2：
示例2
输入：nums = [3,2,1]
输出：[3,null,2,null,1]
提示：

1 <= nums.length <= 1000
0 <= nums[i] <= 1000
nums 中的所有整数互不相同

算法思想：

本题根据提示使用递归法。
递归参数：数组（包含二叉树中所有元素）
递归结束条件：当当前数组没有元素时，说明遍历到空节点，返回None，当当前数组只有一个元素时，返回当前节点构成的二叉树。
一次递归逻辑：递归遍历左数组；递归遍历右数组

代码实现：

递归法：

# 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 constructMaximumBinaryTree(self, nums: List[int]) -> Optional[TreeNode]:
        if len(nums) == 0:
            return None
        if len(nums) == 1:
            return TreeNode(val=nums[0])
        node = TreeNode(val=None)


        maxValue = max(nums)
        maxValueIndex = nums.index(maxValue)
        node.val = maxValue
        node.left = self.constructMaximumBinaryTree(nums[:maxValueIndex])
        node.right = self.constructMaximumBinaryTree(nums[maxValueIndex+1:])
        return node

Leetcode 617 合并二叉树

题目：

给你两棵二叉树： root1 和 root2 。
想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为 null 的节点将直接作为新二叉树的节点。
返回合并后的二叉树。
注意: 合并过程必须从两个树的根节点开始。
示例 1：
示例1
输入：root1 = [1,3,2,5], root2 = [2,1,3,null,4,null,7]
输出：[3,4,5,5,4,null,7]
示例 2：
输入：root1 = [1], root2 = [1,2]
输出：[2,2]
提示：

两棵树中的节点数目在范围 [0, 2000] 内
- $10^4$ <= Node.val <= $10^4$

算法思想：

递归法
要明确一点，本题前中后序遍历都是可以的，因为处理处理“中”节点并不涉及先后顺序。
递归参数：两棵二叉树，root1和root2
递归结束条件：如果当前root1为空，返回root2；如果当前root2为空，返回root1；
一次递归逻辑：（处理中节点，即root1和root2的当前值加和，这步放在后序遍历也行，放在中序遍历也行）递归遍历root1和root2的左子树；递归遍历root1和root2的右子树。
迭代法
本题要明确的是，双向队列和栈都可以解决问题。如果root1为空，返回root2；如果root2为空，返回root1。如果当前栈/队列不空，出栈或队列；如果root1.left 和root2.left均不空，入栈或队列；如果root1.right和root2.right均不空，入栈或队列；如果root1.left为空同时root2.left不为空，将root2.left给root1.left；右侧同理。此时假设的是将改变后的值作用到root1上。同理可做用到root2上或重新申请空间保存合并后的二叉树。

代码实现：

递归法：

# 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 mergeTrees(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> Optional[TreeNode]:
        if root1 is None:
            return root2
        if root2 is None:
            return root1
        '''
        本题先序遍历后续遍历和中序遍历都可以
        '''
        root1.val = root1.val + root2.val
        root1.left = self.mergeTrees(root1.left, root2.left)
        root1.right = self.mergeTrees(root1.right, root2.right)

        return root1

迭代法：

# 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

import collections
class Solution:
    def mergeTrees(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> Optional[TreeNode]:
        if root1 is None:
            return root2
        if root2 is None:
            return root1
        # st = collections.deque([(root1, root2)])
        st = [(root1, root2)]
        while st:
            cur1, cur2 = st.pop()
            cur1.val = cur1.val + cur2.val
            '''
                下列代码会造成问题，就是会将移动过来的元素执行两次。
                怎么避免这个问题？
            '''
            # if cur1.left and cur2.left:
            #     st.append((cur1.left, cur2.left))
            # elif cur1.left is None:
            #     cur1.left = cur2.left
            
            # if cur1.right and cur2.right:
            #     st.append((cur1.right, cur2.right))
            # elif cur1.right is None:
            #     cur1.right = cur2.right
            if cur1.left is not None and cur2.left is not None:
                st.append((cur1.left, cur2.left))
            if cur1.right is not None and cur2.right is not None:
                st.append((cur1.right, cur2.right))
            if cur1.left is None and cur2.left is not None:
                cur1.left = cur2.left

            if cur1.right is None and cur2.right is not None:
                cur1.right = cur2.right
        return root1

[Leetcode 700 二叉搜索树中的搜索

](https://leetcode.cn/problems/search-in-a-binary-search-tree/)

题目：

给定二叉搜索树（BST）的根节点 root 和一个整数值 val。
你需要在 BST 中找到节点值等于 val 的节点。返回以该节点为根的子树。如果节点不存在，则返回 null 。
示例 1:
示例1
输入：root = [4,2,7,1,3], val = 2
输出：[2,1,3]
示例 2:
示例2
输入：root = [4,2,7,1,3], val = 5
输出：[]
提示：

树中节点数在 [1, 5000] 范围内
1 <= Node.val <= $10^7$
root 是二叉搜索树
1 <= val <= $10^7$

算法思想：

什么是二叉搜索树：

二叉搜索树是一个有序树：
若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
它的左、右子树也分别为二叉搜索树

思想：通常情况下，如果用到递归方法，通常要考虑递归遍历的顺序；在二叉搜索树中，就不用强调遍历顺序了，因为二叉搜索树自带顺序。

递归法：
递归参数：二叉树根节点，待搜索的值val
递归结束条件：如果根节点为None，返回None；如果根节点的值就是val，返回root
一次递归逻辑：如果当前值节点的值大于val，向左子树走；如果当前节点的值小于val，向右子树走。
迭代法：用双向队列一次遍历元素。

代码实现：

递归法：

# 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 searchBST(self, root, val: int):
        if root is None:
            return None
        if root.val == val:
            return root
        
        result = None
        if val < root.val:
            result = self.searchBST(root.left, val)
        if val > root.val:
            result = self.searchBST(root.right, val)
        return result

迭代法：

# 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
import collections
class Solution:
    def searchBST(self, root, val: int):
        # 迭代法
        if root is None:
            return None
        st = deque([root])
        
        while st:
            cur = st.popleft()
            if cur.val > val and cur.left:
                st.append(cur.left)
            elif cur.val < val and cur.right:   
                st.append(cur.right)
            elif cur.val == val:
                return cur
        return None
        
import unittest

class TestSolution(unittest.TestCase):
    def test_searchBST(self):
        # 构建测试用例
        # # 测试用例1：根节点为空
        # root1 = None
        # val1 = 5
        # self.assertIsNone(Solution().searchBST(root1, val1))

        # 测试用例2：根节点为目标值
        root2 = TreeNode(5)
        val2 = 5
        self.assertEqual(Solution().searchBST(root2, val2), root2)

        # # 测试用例3：根节点的左子节点为目标值
        # root3 = TreeNode(5)
        # root3.left = TreeNode(3)
        # val3 = 3
        # self.assertEqual(Solution().searchBST(root3, val3), root3.left)

        # # 测试用例4：根节点的右子节点为目标值
        # root4 = TreeNode(5)
        # root4.right = TreeNode(7)
        # val4 = 7
        # self.assertEqual(Solution().searchBST(root4, val4), root4.right)

        # # 测试用例5：目标值在树的深层节点
        # root5 = TreeNode(5)
        # root5.left = TreeNode(3)
        # root5.right = TreeNode(7)
        # root5.left.left = TreeNode(2)
        # root5.left.right = TreeNode(4)
        # root5.right.left = TreeNode(6)
        # root5.right.right = TreeNode(8)
        # val5 = 4
        # self.assertEqual(Solution().searchBST(root5, val5), root5.left.right)

if __name__ == '__main__':
    unittest.main()

一只AI学习小朋友

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Leetcode 刷题第18天 | 654,617,700

合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为 null 的节点将直接作为新二叉树的节点。递归结束条件：当当前数组没有元素时，说明遍历到空节点，返回None，当当前数组只有一个元素时，返回当前节点构成的二叉树。输入：root1 = [1,3,2,5], root2 = [2,1,3,null,4,null,7]输出：[6,3,5,null,2,0,null,null,1]输入：nums = [3,2,1,6,0,5]输出：[3,4,5,5,4,null,7]
复制链接

扫一扫