大学计算机python考试题二叉树_【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