二叉树相关题目

一 相同的树

  LeetCode 100题(如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的)

  迭代解法

# 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
from collections import deque
class Solution:
    def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
        def check(p,q):
            if not p and not q:
                return True
            if not p or not q:
                return False
            if p.val != q.val:
                return False
            return True
        deq = deque([(p, q),])
        while deq:
            p, q = deq.popleft()
            if not check(p, q):
                return False
            
            if p or q:
                deq.append((p.left, q.left))
                deq.append((p.right, q.right))
                    
        return True
迭代
from collections import deque

#创建一个deque
d = deque()
#添加元素
d.append(1)
d.append(3)
d.append(5)
d.append(6)
d.append(6)
d.append(8)
print(d[0])
print(d[-1])
#两端都使用pop
d = deque('12345')
#.pop()抛出的是’5’,d.leftpop()抛出的是’1’，可见默认pop()抛出的是最后一个元素。
#限制deque的长度
d = deque(maxlen=20)
for i in range(30):

    d.append(str(i))

#此时d的值为d=deque(['10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '20', '21', '22', '23', '24', '25', '26', '27', '28', '29'], maxlen=20),可见当限制长度的deque增加超过限制数的项时，另一边的项会自动删除。
#添加list各项到deque中：

d=deque([1,2,3,4,5])

d.extend([0])

#那么此时d=deque([1,2,3,4,5,0])

d.extendleft([6,7,8])

#此时d=deque([8, 7, 6, 1, 2, 3, 4, 5, 0])
关于deque库的用法

 递归解法

# 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 isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
        if not p and not q:
            return True
        if not p or not q:
            return False
        if p.val != q.val:
            return False
        
        return self.isSameTree(p.left,q.left) and self.isSameTree(p.right,q.right)
递归解法一
# 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 isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
        if not p and not q:
            return True
        elif p and q:
            return p.val == q.val and self.isSameTree(p.left,q.left) and self.isSameTree(p.right,q.right)
        else:
            return False
递归解法二

使用前序遍历进行判断

# 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 isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
        def preorder(root):
            if not root:
                return [None]
            return [root.val] + preorder(root.left) + preorder(root.right)
        return preorder(p) == preorder(q)
View Code

 

二 遍历二叉树的所有路径

leetcode 257题

递归解法

思路:在递归遍历二叉树时,需要考虑当前节点是不是叶子节点,如果当前的节点不是叶子节点，则将该节点加入到路径的末尾,并递归遍历该节点的每一个孩子节点。如果当前的节点是叶子节点，则在当前的路径末尾添加该节点后，就得到了一条从根节点到叶子节点的路径，可以把该路径加入到答案中

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

class Solution:
    def binaryTreePaths(self, root: TreeNode) -> List[str]:
        res = []
        def helper(root,path):
            if not root:
                return
            path += str(root.val)
            if not root.left and not root.right:
                res.append(path)
            else:
                if root.left:
                    helper(root.left,path + "->")
                if root.right:
                    helper(root.right,path + "->")
        helper(root,"")
        return res
递归解法

 迭代解法

维护一个队列，存储节点以及根到该节点的路径。一开始这个队列里只有根节点。在每一步迭代中，我们取出队列中的首节点，如果它是一个叶子节点，则将它对应的路径加入到答案中。如果它不是一个叶子节点，则将它的所有孩子节点加入到队列的末尾。当队列为空时，迭代结束

 

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

class Solution:
    def binaryTreePaths(self, root: TreeNode) -> List[str]:
        if not root:
            return []
        paths= []
        stack = [(root,str(root.val))]
        while stack:
            node, path = stack.pop()
            if not node.left and not node.right:
                paths.append(path)
            else:
                if node.left:
                    stack.append((node.left,path + '->' + str(node.left.val)))
                if node.right:
                    stack.append((node.right,path + '->' + str(node.right.val)))
        return paths
迭代解法

 

三  路径总和II

leetcode 113题

递归解法

思路:在递归遍历二叉树时,需要考虑当前节点是不是叶子节点,若不是,则将该节点加入到路径中,并用当前目标总值减去当前节点的值,并递归遍历该节点的每一个孩子节点,若是叶子节点,则还需要判断当前目标总值减去该节点是否为0,若为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 pathSum(self, root: TreeNode, sum: int) -> List[List[int]]:
        res = []
        def helper(root,tmp,sum_):
            if not root:return []
            if not root.left and not root.right and sum_ - root.val == 0:
                tmp += [root.val]
                res.append(tmp)
            else:
                if root.left:
                    helper(root.left,tmp + [root.val],sum_ - root.val)
                if root.right:
                    helper(root.right,tmp + [root.val],sum_ - root.val)
        helper(root,[],sum)
        return res
递归解法

迭代解法

思路:维护一个列表,存储节点以及根到该节点的列表,判断该节点是不是叶子节点,若是,则需要判断根节点到该节点的和是否等于目标总值,若相等,咋将该列表加入到结果列表中,若不是叶子节点,则将该节点的孩子节点及根节点到该孩子节点的列表加入到队列中,并一直循环直到队列为空

# 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]]:
        if not root:return []
        stack = [([root.val],root)]
        res = []
        while stack:
            tmp, node = stack.pop()
            if not node.left and not node.right and sum(tmp) == sum_:
                res.append(tmp)
            else:
                if node.left:
                    stack.append((tmp + [node.left.val],node.left))
                if node.right:
                    stack.append((tmp + [node.right.val],node.right))
        return res
迭代解法

 

posted on 2020-07-27 22:18  rwwh  阅读(80)  评论(0)    收藏  举报

导航