Fork me on GitHub

【python刷题】二叉树-相关题目

计算二叉树有多少个节点

def count(root):
    if not root:
        return 0
   return 1 + count(root.left) + count(root.right)   

计算二叉树的深度

def count_depth(root):
    if not root:
        return 0
    return max(count_depth(root.left), count_depth(root.right)) + 1

226. 翻转二叉树

class Solution:
    def invertTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return None
        root.left, root.right = root.right, root.left
        self.invertTree(root.left)
        self.invertTree(root.right)
        return root

114. 二叉树展开为链表

class Solution:
    def flatten(self, root: TreeNode) -> None:
        """
        Do not return anything, modify root in-place instead.
        """
        if not root:
            return None
        self.flatten(root.left)
        self.flatten(root.right)
        left = root.left
        right = root.right
        root.left = None
        root.right = left
        p = root
        while p.right:
            p = p.right
            
        p.right = right
        return root

116. 填充每个节点的下一个右侧节点指针

class Solution:
    def connect(self, root: 'Node') -> 'Node':
        if not root:
            return None
        self.connectTwoNode(root.left, root.right)
        return root
    def connectTwoNode(self, node1, node2):
        if (not node1) or (not node2):
            return
        node1.next = node2
        self.connectTwoNode(node1.left, node1.right)
        self.connectTwoNode(node2.left, node2.right)
        self.connectTwoNode(node1.right, node1.left)

654. 最大二叉树

class Solution:
    def constructMaximumBinaryTree(self, nums: List[int]) -> TreeNode:
        m = max(nums)
        ind = nums.index(m)
        l = nums[:ind]
        r = nums[ind+1:]
        t = TreeNode(m)
        t.left = self.constructMaximumBinaryTree(l) if l else None
        t.right = self.constructMaximumBinaryTree(r) if r else None
        return t

105. 从前序与中序遍历序列构造二叉树

class Solution(object):
    def buildTree(self, preorder, inorder):
        """
        :type preorder: List[int]
        :type inorder: List[int]
        :rtype: TreeNode
        """
        #先序遍历的列表为[根,左,右],中序遍历的列表为[左,根,右],则中序遍历中根的下标为先序遍历中左的边界
        if not preorder:
            return None
        root = TreeNode(preorder[0])
        #找到根节点在中序遍历中的下标
        n = inorder.index(root.val)
        root.left = self.buildTree(preorder[1:n+1],inorder[:n])
        root.right = self.buildTree(preorder[n+1:],inorder[n+1:])
        return root 

106. 从中序与后序遍历序列构造二叉树

class Solution:
    def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode:
        if not postorder:
            return None
        root = TreeNode(postorder[-1])
        n = inorder.index(root.val)
        root.left = self.buildTree(inorder[:n],postorder[:n])
        root.right = self.buildTree(inorder[n+1:],postorder[n:-1])
        return root

652. 寻找重复的子树

class Solution:
    def findDuplicateSubtrees(self, root: TreeNode) -> List[TreeNode]:
        res = []
        from collections import defaultdict
        memo = defaultdict(int)
        def traverse(root):
            if not root:
                return "#"
            left = traverse(root.left)
            right = traverse(root.right)
            subTree = "{},{},{}".format(left, right, root.val)
            memo[subTree] += 1
            if memo[subTree] == 2:
                res.append(root)
            return subTree
        traverse(root)
        return res

236. 二叉树的最近公共祖先

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        if not root:
            return None
        if root == p or root == q:
            return root
        left = self.lowestCommonAncestor(root.left, p, q)
        right = self.lowestCommonAncestor(root.right, p, q)
        if left is not None and right is not None:
            return root
        if left is None and right is None:
            return None
        return right if left is None else left

110. 平衡二叉树

#自顶向下:
class Solution:
    def isBalanced(self, root: TreeNode) -> bool:
        def height(root: TreeNode) -> int:
            if not root:
                return 0
            return max(height(root.left), height(root.right)) + 1

        if not root:
            return True
        return abs(height(root.left) - height(root.right)) <= 1 and self.isBalanced(root.left) and self.isBalanced(root.right)
#自底向上
class Solution:
    def isBalanced(self, root: TreeNode) -> bool:
        def height(root):
            if not root:
                return 0
            left = height(root.left)
            right = height(root.right)
            if left == -1 or right == -1 or abs(left - right) >= 2:
                return -1
            else:
                return max(left, right) + 1
        res = height(root)
        return res >=0 

589. N叉树的前序遍历

class Solution:
    def __init__(self):
        self.res = []
    def preorder(self, root: 'Node') -> List[int]:
        if not root:
            return []
        self.res.append(root.val)
        for child in root.children:
            self.preorder(child)
        return self.res

897. 递增顺序查找树

class Solution:
    def increasingBST(self, root: TreeNode) -> TreeNode:
        self.x = ans = TreeNode(0)
        def traverse(root):
            if root:
                traverse(root.left)
                t = TreeNode(root.val)
                self.x.right = t
                self.x = t
                traverse(root.right)
        traverse(root)
        return ans.right

112. 路径总和

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

1022. 从根到叶的二进制数之和

class Solution:
    def __init__(self):
        self.res = 0
    def sumRootToLeaf(self, root: TreeNode) -> int:
        def traverse(root, s):
            if not root:
                return 0
            s = s * 2 + root.val
            if not root.left and not root.right:
                self.res += s
            traverse(root.left, s)
            traverse(root.right, s)
        traverse(root, 0)
        return self.res

617. 合并二叉树

class Solution:
    def mergeTrees(self, t1: TreeNode, t2: TreeNode) -> TreeNode:
        if not t1:
            return t2
        if not t2:
            return t1
        if not t1 and not t2:
            return None
        root = TreeNode(t1.val + t2.val)
        root.left = self.mergeTrees(t1.left, t2.left)
        root.right = self.mergeTrees(t1.right, t2.right)
        return root

107. 二叉树的层序遍历 II

class Solution:
    def levelOrderBottom(self, root: TreeNode) -> List[List[int]]:
        res = [[]]
        def traverse(root, lev):
            if not root:
                return 
            res[lev-1].append(root.val)
            if len(res) == lev:
                res.append([])
            traverse(root.left, lev+1)
            traverse(root.right, lev+1)            
        traverse(root, 1)
        return res[:-1][::-1]

100. 相同的树

class Solution:
    def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
        if q is None and p is not None:
            return False
        if p is None and q is not None:
            return False
        if p is None and q is None:
            return True
        return p.val == q.val and self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)

404. 左叶子之和

class Solution:
    def sumOfLeftLeaves(self, root: TreeNode) -> int:
        if not root:
            return 0
        if root.left is None:
           return self.sumOfLeftLeaves(root.right)
        if root.left.left is None and root.left.right is None:
            return root.left.val + self.sumOfLeftLeaves(root.right)
        return self.sumOfLeftLeaves(root.left) + self.sumOfLeftLeaves(root.right)

965. 单值二叉树

class Solution:
    def isUnivalTree(self, root: TreeNode) -> bool:
        left = not root.left or root.val == root.left.val and self.isUnivalTree(root.left)
        right = not root.right or root.val == root.right.val and self.isUnivalTree(root.right)
        return left and right

669. 修剪二叉搜索树

class Solution:
    def trimBST(self, root: TreeNode, low: int, high: int) -> TreeNode:
        def traverse(root, low ,high):
            if not root:
                return None
            elif root.val < low:
                return self.trimBST(root.right, low, high)
            elif root.val > high:
                return self.trimBST(root.left, low ,high)
            else:
                root.left = traverse(root.left, low ,high)
                root.right = traverse(root.right, low, high)
                return root
        return traverse(root, low, high)

993. 二叉树的堂兄弟节点

class Solution:
    def isCousins(self, root: TreeNode, x: int, y: int) -> bool:
        def traverse(root, parent, target, depth):
            if not root:
                return (-1, parent)
            if root.val == target:
                return (depth, parent)
            l = traverse(root.left, root, target, depth + 1)
            r = traverse(root.right, root, target, depth + 1)
            if l[0] != -1:
                return l
            return r
        dx, px = traverse(root, None, x, 0)
        dy, py = traverse(root, None, y, 0)
        if dx == dy and px != py:
            return True
        else:
            return False

653. 两数之和 IV - 输入 BST

class Solution:
    def findTarget(self, root: TreeNode, k: int) -> bool:
        def traverse(root, k, tmp):
            if not root:
                return False
            if k - root.val in tmp:
                return True
            tmp.add(root.val)
            return traverse(root.left, k, tmp) or traverse(root.right, k, tmp)
        tmp = set()
        return traverse(root, k, tmp)

543. 二叉树的直径

class Solution:
    def diameterOfBinaryTree(self, root: TreeNode) -> int:
        if not root:
            return 0
        res = float("-inf")
        def traverse(root):
            nonlocal res
            if not root:
                return 0
            left = traverse(root.left)
            right = traverse(root.right)
            res = max(left + right, res)
            return max(left, right) + 1 
        traverse(root)
        return res

树的子结构

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def HasSubtree(self, pRoot1, pRoot2):
        result = False
        if pRoot1 and pRoot2:
            if pRoot1.val == pRoot2.val:
                result = self.check_structure(pRoot1, pRoot2)
            if not result:
                result = self.HasSubtree(pRoot1.left, pRoot2)
            if not result:
                result = self.HasSubtree(pRoot1.right, pRoot2)
        return result
    def check_structure(self, root1, root2):
        if not root2:
            return True
        if not root1:
            return False
        if root1.val != root2.val:
            return False
        left_check = self.check_structure(root1.left, root2.left)
        right_check = self.check_structure(root1.right, root2.right)
        return left_check and right_check    
posted @ 2021-01-17 11:34  西西嘛呦  阅读(204)  评论(0编辑  收藏  举报