算法通关村——轻松搞定二叉树的深度优先经典问题

1.青铜挑战——二叉树的经典算法题

1.二叉树里的双指针

1.1判断两棵树是否相同

LeetCode100：给你两颗二叉树的根节点p和q，编写一个函数来检验这两颗树是否相同。如果两个树在结构上相同，并且节点具有相同的值，则认为他们是相同的。

class Node:
    def __init__(self, val=-1, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

class Tree:
    def __init__(self, root=None):
        self.root = root
    def init_tree(self):
        node_9 = Node(9)
        node_15 = Node(15)
        node_7 = Node(7)
        node_20 = Node(20, node_15, node_7)
        root = Node(3, node_9, node_20)
        return root

    def init_tree2(self):
        node_9 = Node(9)
        node_15 = Node(15)
        node_7 = Node(7)
        node_20 = Node(20, node_15, node_7)
        root = Node(3, node_9, node_20)
        return root


class IsSameTree:
    def isSameTree(self, p, q):
        if not p and not q:
            return True
        elif not p or not q:
            return False
        elif p.val != q.val:
            return False
        else:
            return self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)


if __name__ == "__main__":
    tree = Tree()
    p = tree.init_tree()
    q = tree.init_tree2()
    isSameTree = IsSameTree()
    res = isSameTree.isSameTree(q, p)
    print(res)

1.2对称二叉树

LeetCode101：给定一个二叉树，检查它是否是镜像对称的。

1.比较二叉树外侧是否对称：传入的是左节点的左孩子，右节点的右孩子

2.比较内测是否对称，传入左节点的右孩子，右节点的左孩子

3.如果左右都对称就返回true，有一侧不对称就返回false

class Node:
    def __init__(self, val=-1, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

class Tree:
    def __init__(self, root=None):
        self.root = root
    def init_tree_for_symmetric(self):
        node_5 = Node(5)
        node_6 = Node(6)
        node_3 = Node(3, node_5, node_6)
        node_4 = Node(4)
        node_2 = Node(2, node_3, node_4)

        node_55 = Node(5)
        node_66 = Node(6)
        node_33 = Node(3, node_66, node_55)
        node_44 = Node(4)
        node_22 = Node(2, node_44, node_33)

        root = Node(1, node_2, node_22)
        return root


class IsSymmetric:
    def isSymmetric(self, root):
        if not root:
            return True
        def dfs(left, right):
            if not(left or right):
                return True
            if not(left and right):
                return False
            if left.val != right.val:
                return False
            return dfs(left.left, right.right) and dfs(left.right, right.left)
        return dfs(root.left, root.right)


if __name__ == "__main__":
    tree = Tree()
    root = tree.init_tree_for_symmetric()
    isSymmetric = IsSymmetric()
    res = isSymmetric.isSymmetric(root)
    print(res)

1.3合并二叉树

LeetCode617：给定两个二叉树，想象当你将他们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为Null的节点将直接作为新二叉树的节点。

class Node:
    def __init__(self, val=-1, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

class Tree:
    def __init__(self, root=None):
        self.root = root

    def init_tree_for_merge1(self):
        node_5 = Node(5)
        node_3 = Node(3, node_5)
        node_2 = Node(2)
        root = Node(1, node_3, node_2)
        return root

    def init_tree_for_merge2(self):
        node_4 = Node(4)
        node_7 = Node(7)
        node_1 = Node(1, None, node_4)
        node_3 = Node(3, None, node_7)
        root = Node(2, node_1, node_3)
        return root

class MergeTrees:
    def mergeTrees(self, t1, t2):
        if not t1:
            return t2
        if not t2:
            return t1
        merged = Node(t1.val + t2.val)
        merged.left = self.mergeTrees(t1.left, t2.left)
        merged.right = self.mergeTrees(t1.right, t2.right)
        return merged

if __name__ == "__main__":
    tree = Tree()
    t1 = tree.init_tree_for_merge1()
    t2 = tree.init_tree_for_merge2()
    mergeTrees = MergeTrees()
    res = mergeTrees.mergeTrees(t1, t2)
    print(res)

2.路径专题

2.1二叉树的所有路径（#####）

LeetCode257：给你一个二叉树的根节点root，按任意顺序，返回所有从根节点到叶子节点的路径。

class Node:
    def __init__(self, val=-1, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

class Tree:
    def __init__(self, root=None):
        self.root = root

    def init_tree_for_path(self):
        node_5 = Node(5)
        node_2 = Node(2, None, node_5)
        node_3 = Node(3)
        root = Node(1, node_2, node_3)
        return root

class BinaryTreePaths:
    def binaryTreePaths(self, root):
        def construct_paths(root, path):
            if root:
                path += str(root.val)
                if not root.left and not root.right:
                    paths.append(path)
                else:
                    path += '->'
                    construct_paths(root.left, path)
                    construct_paths(root.right, path)

        paths = []
        construct_paths(root, '')
        return paths

if __name__ == "__main__":
    tree = Tree()
    root = tree.init_tree_for_path()
    binaryTreePaths = BinaryTreePaths()
    res = binaryTreePaths.binaryTreePaths(root)
    print(res)

2.2路径总和

LeetCode112：给你二叉树的根节点root和一个表示目标和的整数targetSum,判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和targetSum.

class Node:
    def __init__(self, val=-1, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

class Tree:
    def __init__(self, root=None):
        self.root = root

    def init_tree_for_path_sum(self):
        node_7 = Node(7)
        node_2 = Node(2)
        node_11 = Node(11, node_7, node_2)
        node_1 = Node(1)
        node_4 = Node(4, None, node_1)
        node_13 = Node(13)
        node_8 = Node(8, node_13, node_4)
        node_44 = Node(4, node_11)
        root = Node(5, node_44, node_8)
        return root

class HasPathSum:
    def hasPathSum(self, root, sum):
        if not root:
            return False
        if not root.left and not root.right:
            return sum == root.val
        return self.hasPathSum(root.left, sum - root.val) or self.hasPathSum(root.right, sum - root.val)

if __name__ == "__main__":
    tree = Tree()
    root = tree.init_tree_for_path_sum()
    hasPathSum = HasPathSum()
    res = hasPathSum.hasPathSum(root, 22)
    print(res)

3.翻转的妙用

想要翻转树，就是把每一个节点的左右孩子交换一下。关键在于遍历顺序。遍历的过程中去翻转每一个节点的左右孩子就可以达到整体翻转的效果。注意只要把每一个节点的左右孩子翻转一下，就可以达到整体翻转的效果。

class Node:
    def __init__(self, val=-1, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

class Tree:
    def __init__(self, root=None):
        self.root = root

    def init_tree_for_invert(self):
        node_1 = Node(1)
        node_3 = Node(3)
        node_2 = Node(2, node_1, node_3)
        node_6 = Node(6)
        node_9 = Node(9)
        node_7 = Node(7, node_6, node_9)
        root = Node(4, node_2, node_7)
        return root

class InvertTree:
    # 基于前序遍历方式
    def invertTree1(self, root):
        if not root:
            return None
        root.left, root.right = root.right, root.left
        self.invertTree1(root.left)
        self.invertTree1(root.right)
        return root

    # 基于后序遍历方式
    def invertTree2(self, root):
        if not root:
            return root
        left = self.invertTree2(root.left)
        right = self.invertTree1(root.right)
        root.left, root.right = right, left
        return root

    # 基于层次遍历方式
    def invertTree3(self, root):
        if not root:
            return None
        queue = [root]
        while queue:
            tmp = queue.pop(0)
            tmp.left, tmp.right = tmp.right, tmp.left
            if tmp.left:
                queue.append(tmp.left)
            if tmp.right:
                queue.append(tmp.right)
        return root

if __name__ == "__main__":
    tree = Tree()
    root = tree.init_tree_for_invert()
    invertTree = InvertTree()
    res = invertTree.invertTree1(root)
    print(res)