LeetCode（98）验证二叉搜索树（102,107）层次遍历

(98)验证二叉搜索树
二叉树的三种访问方式
1.先序遍历：按照根节点->左子树->右子树的顺序访问二叉树

先序遍历结果：A BDFE CGHI
思惟过程：
（1）先访问根节点A，

（2）A分为左右两个子树，由于是递归调用，因此左子树也遵循“先根节点-再左-再右”的顺序，因此访问B节点，

（3）而后访问D节点，

（4）访问F节点的时候有分支，一样遵循“先根节点-再左–再右”的顺序,

(5)访问E节点，此时左边的大的子树已经访问完毕，

(6)而后遵循最后访问右子树的顺序，访问右边大的子树，右边大子树一样先访问根节点C,

(7)访问左子树G,

(8)由于G的左子树没有，因此接下俩访问G的右子树H,

(9)最后访问C的右子树I

2.中序遍历：按照左子树->根节点->右子树的顺序访问

中序遍历结果：DBEF A GHCI

3.后序遍历

后序遍历的结果：DEFB HGIC A

这道题咱们能够使用中序遍历为升序对的解法，先把节点中序排列(左-根-右)，再对数组进行遍历，同时判断相邻元素间大小，若是排前面的数大于等于以后的数，说明不是二叉搜索树。

class Solution:
    def isValidBST(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        self.last_node = float("-inf")
        return self.helper(root)
    
    def helper(self, root):
        
        if not root:
            return True
        
        left = self.helper(root.left)
        
        if root.val <= self.last_node:
            return False
        self.last_node = root.val
        right = self.helper(root.right)
        
        return left and right

(102)二叉树的层次遍历
思路：二叉树或通常树的水平层次遍历，能够使用BFS（广度搜素）算法，使用队列Queue标记每一层的结点元素；

Queue：先进先出， 后进后出。能够保证每一层遍历时的结点顺序；

BFS：相似于电影中的病毒传染，先感染靠近本身的，再由易感染层感染更外层…(我理解的就是这么个理)；

该题二叉树中，先把根结点压入队列，当队列不为空时，移除队首结点，并判断该结点的左右子树中有无非空结点，若存在，则再次入队对应的左右子树结点……同一层的每一个结点循环以上操做，直至队列为空，循环结束。

class Solution:
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
      
        ret = list()
        if root == None:
            return ret

        from queue import Queue
        q = Queue()
        q.put((root, 0))
        while not q.empty():
            node, level = q.get()

            if level == len(ret):
                ret.append([])
                
            ret[level].append(node.val)

            if node.left != None:
                q.put((node.left, level + 1))

            if node.right != None:
                q.put((node.right, level + 1))

        return ret

（107）二叉树的层次遍历 II
思路与前一题雷同，就不在赘述。

class Solution:
    def levelOrderBottom(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        
        q, result = [root], []
        while any(q):
            tmp = list()
            len_q = len(q)
            for _ in range(len_q):
                node = q.pop(0)
                tmp.append(node.val)
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)

            result.insert(0, tmp)
        return result