算法第九题(二叉树）

98. 验证二叉搜索树

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

# class Solution:
#     def isValidBST(self, root: TreeNode) -> bool:
#         return self.isVaildNode(root)

#     def isVaildNode(self,node):
#         if node is None:
#             return True
        
#         leftbool = (node.left is None) or (node.left.val < node.val)
#         rightbool = (node.right is None) or (node.right.val > node.val)
#         if leftbool and rightbool:
#             leftnode = self.isVaildNode(node.left)
#             rightnode = self.isVaildNode(node.right)
#             return (leftnode and rightnode)
#         else:
#             return False #错误示例

# class Solution:
#     def isValidBST(self, root: TreeNode) -> bool:
#         return self.isValidNode(root,+inf,-inf)

#     def isValidNode(self,node,up,low):
#         if node is None:
#             return True
        
#         if node.val<up and node.val>low:
#             leftbool = self.isValidNode(node.left,node.val,low)
#             rightbool = self.isValidNode(node.right,up,node.val)
#             return (leftbool and rightbool)
#         else:
#             return False

class Solution:
    def isValidBST(self, root: TreeNode) -> bool:
        self.compare = -inf
        return self.isValidNode(root)
    def isValidNode(self,node):
        if node is None:
            return True
        
        boolleft = self.isValidNode(node.left)
        if node.val<=self.compare:
            return False
        else:
            self.compare = node.val
        boolright = self.isValidNode(node.right)
        return (boolleft and boolright)

错误思路：验证二叉搜索树，直接验证每个节点左节点的val小于root的val，右节点的val大于root的val，这是不对的。

思路1：递归思路，遍历每个节点，为每个节点设置一个上阈值与下阈值，进行判断。
思路2：二叉搜索树的中序遍历的值是排好序的，利用此性质，在中序遍历中进行判断。

103. 二叉树的锯齿形层次遍历

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

class Solution:
    def zigzagLevelOrder(self, root: TreeNode) -> List[List[int]]:
        if root is None:
            return []
        
        deque= [[root],[]]
        output = [[]]
        i = 0
        while deque[0] or deque[1]:
            if i%2==0:
                if not deque[0]:
                    output.append([])
                    i += 1
                    continue
                node = deque[0].pop()
                if node.left: deque[1].append(node.left)
                if node.right: deque[1].append(node.right)
                output[i].append(node.val)
            else:
                if not deque[1]:
                    output.append([])
                    i += 1
                    continue
                node = deque[1].pop()
                if node.right:deque[0].append(node.right)
                if node.left:deque[0].append(node.left)
                output[i].append(node.val)
        return output

这道题为BFS的一道扩展题，锯齿状即两个BFS，奇数则正向，偶数则负向，用条件判断一下。