Leetcode 算法面试冲刺 实战 十三（二叉树）（二十四）

69 · 二叉树的层次遍历

给出一棵二叉树，返回其节点值的层次遍历（逐层从左往右访问）


挑战
挑战1：只使用一个队列去实现它
挑战2：用BFS算法来做

"""
Definition of TreeNode:
class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left, self.right = None, None
"""
from collections import deque
class Solution:
    """
    @param root: A Tree
    @return: Level order a list of lists of integer
    """
    def levelOrder(self, root):
        # write your code here
        if not root: return []
        queue = deque()
        queue.append(root)
        res = []
        while queue:
            li = []
            for _ in range(len(queue)):
                node = queue.popleft()
                li.append(node.val)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            res.append(li)
        return res

85 · 在二叉查找树中插入节点

给定一棵二叉查找树和一个新的树节点，将节点插入到树中。
你需要保证该树仍然是一棵二叉查找树。


注意这里3、6在4的下面

"""
Definition of TreeNode:
class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left, self.right = None, None
"""
    def insertNode(self, root, node):
        # write your code here
        if root is None:
            return node

        if node.val < root.val:
            root.left = self.insertNode(root.left, node)
        if node.val > root.val:
            root.right = self.insertNode(root.right, node)
        return root

官方答案：

在树上定位要插入节点的位置。
如果它大于当前根节点，则应该在右子树中，如果没有右子树则将该点作为右儿子插入；若存在右子树则在右子树中继续定位。
如果它小于当前根节点，则应该在左子树中，处理同上。
（二叉查找树中保证不插入已经存在的值）

  def insertNode(self, root, node):
        if root is None:
            return node
            
        curt = root
        while curt != node:
            if node.val < curt.val:
                if curt.left is None:
                    curt.left = node
                curt = curt.left
            else:
                if curt.right is None:
                    curt.right = node
                curt = curt.right
        return root

93 · 平衡二叉树

给定一个二叉树,确定它是高度平衡的。对于这个问题,一棵高度平衡的二叉树的定义是：一棵二叉树中每个节点的两个子树的深度相差不会超过1。

没写出来，下面是官方答案：

class Solution:
    """
    @param root: The root of binary tree.
    @return: True if this Binary tree is Balanced, or false.
    """
    def isBalanced(self, root):
        is_balanced, _ = self.helper(root)
        return is_balanced
        
    def helper(self, root):
        if not root:
            return True, 0
        
        is_left_balanced, left_height = self.helper(root.left)
        is_right_balanced, right_height = self.helper(root.right)
        
        root_height = max(left_height, right_height) + 1
        
        if not is_left_balanced or not is_right_balanced:
            return False, root_height
            
        if abs(left_height - right_height) > 1:
            return False, root_height
            
        return True, root_height

95 · 验证二叉查找树

给定一个二叉树，判断它是否是合法的二叉查找树(BST)

一棵BST定义为：
节点的左子树中的值要严格小于该节点的值。
节点的右子树中的值要严格大于该节点的值。
左右子树也必须是二叉查找树。
一个节点的树也是二叉查找树。

一开始没想出来，看了老师的讲解，写出来的。

"""
Definition of TreeNode:
class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left, self.right = None, None
"""

class Solution:
    """
    @param root: The root of binary tree.
    @return: True if the binary tree is BST, or false
    """
    def isValidBST(self, root):
        # write your code here
        res = []
        self.BST_traverse(root, res)
        for i in range(1, len(res)):
            if res[i] <= res[i - 1]:
                return False
        return True
        

    def BST_traverse(self, root, res):
        if not root: return 

        self.BST_traverse(root.left, res)
        res.append(root.val)
        self.BST_traverse(root.right, res)