Leetcode 98. 验证二叉树

给定一个二叉树，判断其是否是一个有效的二叉搜索树。
假设一个二叉搜索树具有如下特征：
节点的左子树只包含小于当前节点的数。
节点的右子树只包含大于当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。
示例 1:
输入:
2
/
1 3
输出: true

解题思路：自顶向下，确定每个节点的取值范围，然后递归。

class Solution(object):
    def isValidBST(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        return self.bfs(root, -float('inf'), float('inf'))
    def bfs(self, root, mini, maxi):
        if root == None:
            return True
        if root.val < mini or root.val > maxi:
            return False
        return self.bfs(root.left, mini, root.val-1) and self.bfs(root.right, root.val+1, maxi)

Leetcode 101. 对称二叉树

给定一个二叉树，检查它是否是镜像对称的。
例如，二叉树 [1,2,2,3,4,4,3] 是对称的。
1
/
2 2
/ \ /
3 4 4 3
但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:
1
/
2 2
\
3 3
说明:
如果你可以运用递归和迭代两种方法解决这个问题，会很加分。

解题思路：要判断两棵树是不是对称树，需要：1.根节点相同，2. 左边的左子树和右边的右子树相同，3. 左边的右子树和右边的左子树相同。

图片.png

class Solution(object):
    def isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        if root ==None:
            return True
        return self.dfs(root.left, root.right)

    def dfs(self, p, q):
        if p == None or q ==None:
            return not p and not q
        return p.val == q.val and self.dfs(p.left, q.right) and self.dfs(p.right, q.left)

Leetcode 94. 二叉树的中序遍历（迭代法）

给定一个二叉树，返回它的中序 遍历。
示例:
输入: [1,null,2,3]
1

2
/
3
输出: [1,3,2]
进阶: 递归算法很简单，你可以通过迭代算法完成吗？

解题思路：

图片.png

class Solution(object):
    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        res = []
        stack = []
        p = root
        
        while p or len(stack) != 0:
            while p:
                stack.append(p)
                p = p.left
            p = stack[-1]
            stack = stack[:-1]
            res.append(p.val)
            p = p.right
        return res

Leetcode 105. 从前序遍历和中序遍历构造二叉树

根据一棵树的前序遍历与中序遍历构造二叉树。
注意:
你可以假设树中没有重复的元素。
例如，给出
前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]
返回如下的二叉树：
3
/
9 20
/
15 7

class Solution(object):
    def buildTree(self, preorder, inorder):
        """
        :type preorder: List[int]
        :type inorder: List[int]
        :rtype: TreeNode
        """
        if len(preorder) == 0:
            return None
        head = TreeNode(preorder[0])
        mid = inorder.index(head.val)
        head.left = self.buildTree(preorder[1 : mid + 1], inorder[0 : mid])
        head.right = self.buildTree(preorder[mid + 1 :], inorder[mid + 1 :])
        return head

Leetcode 102. 二叉树的层次遍历

给定一个二叉树，返回其按层次遍历的节点值。 （即逐层地，从左到右访问所有节点）。
例如:
给定二叉树: [3,9,20,null,null,15,7],
3
/
9 20
/
15 7
返回其层次遍历结果：
[
[3],
[9,20],
[15,7]
]

class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:
            return None
        queue = [root]
        result = []
        
        while queue:
            temp_list = []
            length = len(queue)
            for i in range(length):
                temp = queue.pop(0)
                temp_list.append(temp.val)
                if temp.left:
                    queue.append(temp.left)
                if temp.right:
                    queue.append(temp.right)
            result.append(temp_list)
        return result

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

class Solution(object):
    def lowestCommonAncestor(self, root, p, q):
        """
        :type root: TreeNode
        :type p: TreeNode
        :type q: TreeNode
        :rtype: TreeNode
        """
        if root == None or p == root or q == root:
            return root
        left = self.lowestCommonAncestor(root.left, p, q)
        right = self.lowestCommonAncestor(root.right, p, q)
        
        if left and right:
            return root
        if not left:
            return right
        if not right:
            return left
        return None