二分查找的应用【110平衡二叉树】+【98验证二叉搜索树】

算法原理

二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法，前提是数据结构必须先排好序，可以在数据规模的对数时间复杂度内完成查找。但是，二分查找要求线性表具有有随机访问的特点（例如数组），也要求线性表能够根据中间元素的特点推测它两侧元素的性质，以达到缩减问题规模的效果。

二分查找问题也是面试中经常考到的问题，虽然它的思想很简单，但写好二分查找算法并不是一件容易的事情。

110. 平衡二叉树

给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：

一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。

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

class Solution(object):
    def isBalanced(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        return self.depth(root)!=-1
    def depth(self,root):
        if not root: return 0
        treel=self.depth(root.left)
        if treel==-1 :return -1
        treer=self.depth(root.right)
        if treer==-1 :return -1
        return max(treel,treer)+1 if abs(treel - treer) < 2 else -1

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

class Solution(object):
    def isBalanced(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        if not root : return True
        return abs(self.depth(root.left)-self.depth(root.right))<=1 \
            and self.isBalanced(root.left) and self.isBalanced(root.right)
    def depth(self,root):
        if not root: return 0
        return max(self.depth(root.left)+1,self.depth(root.right)+1)

98. 验证二叉搜索树

给定一个二叉树，判断其是否是一个有效的二叉搜索树。

假设一个二叉搜索树具有如下特征：

节点的左子树只包含小于当前节点的数。
节点的右子树只包含大于当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。

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

class Solution(object):
    def isValidBST(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        if not root :return True
        return root.val>self.depth(root.left,1) and root.val<self.depth(root.right,0) and self.isValidBST(root.left)and self.isValidBST(root.right)
    def depth(self,root,num):
        if not root :
            if num==1:
                return -float("inf") 
            else :
                return float("inf") 

        if num==1:
            return max(self.depth(root.left,1),self.depth(root.right,1),root.val)
        else :
            return min(self.depth(root.left,0),self.depth(root.right,0),root.val)

# 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:
        if root==None :return True
        if root.left==None and root.right==None :return True
        t=0
        if (not root.left==None) and root.val>self.findl(root.left): 
            t=t+1
        elif (not root.left==None):
            return False
        if (not root.right==None)and root.val<self.findr(root.right):
            t=t+1
        elif (not root.right==None):
            return False
        if t==2:
            return self.isValidBST(root.left) and self.isValidBST(root.right)
        elif  (not root.left==None)and (t==1):
            return self.isValidBST(root.left)
        elif  (not root.right==None)and (t==1):
            return self.isValidBST(root.right)
        else: 
            return False
    def findl(self,root:TreeNode)-> int :
        if root==None:  return float(-1000000)
        if root.left==None and root.right==None :return root.val
        return max(root.val,self.findl(root.left),self.findl(root.right))
    def findr(self,root:TreeNode)-> int :
        if root==None:  return float(1000000)
        if root.left==None and root.right==None :return root.val
        return min(root.val,self.findr(root.left),self.findr(root.right))