LeetCode，二叉树，二叉搜索树

1. 题目解析

1.1 LeetCode700，二叉搜索树中的搜索

题目来源：力扣

给定二叉搜索树（BST）的根节点 root 和一个整数值 val。

你需要在 BST 中找到节点值等于 val 的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 null 。

图1. 二叉树搜索示例

分析，从根节点开始层次遍历树，遇到目标值返回当前节点即可。通过当前节点，即可以得到其子树。

1.2 LeetCode98. 验证二叉搜素树

题目来源：力扣

给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

有效 二叉搜索树定义如下：

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

 图2. 二叉搜索树的验证

验证一棵二叉树是否为搜索树，即其左节点小，根节点中，右节点大。按照该思路，即判定按照中序遍历是否为递增数列。

（1）调用中序遍历返回序列；

（2）判定中序遍历序列是否为递增序列。

1.3 LeetCode530. 二叉搜索树的最小绝对差

题目来源：力扣

题目描述

给你一个二叉搜索树的根节点 root ，返回 树中任意两不同节点值之间的最小差值 。

差值是一个正数，其数值等于两值之差的绝对值。

 图3. 二叉搜索树的最小绝对差

和判断是否为二叉搜素树的思路一致。先中序遍历返回序列，再根据序列判断相邻元素之间的差值，返回最小差值。

1.4 LeetCode501. 二叉搜索树中的众数

题目来源： 力扣

给你一个含重复值的二叉搜索树（BST）的根节点 root ，找出并返回 BST 中的所有 众数（即，出现频率最高的元素）。

如果树中有不止一个众数，可以按 任意顺序 返回。

假定 BST 满足如下定义：

结点左子树中所含节点的值 小于等于 当前节点的值
结点右子树中所含节点的值 大于等于 当前节点的值
左子树和右子树都是二叉搜索树

 图4. 二叉搜索树中的众数

分析：在遍历二叉树的过程中，统计每个val出现的个数。由于可能不仅仅只有一个众数，分为以下几种情况，用list，r存储结果：

（1）若是元素val之前存在于r中，则清空r，r = [val]；

（2）若val不存在y于r中，

如果val出现的次数>r中任一元素出现的次数，那么清空r，r = [val];

如果val出现的次数=r中元素出现的次数，那么r.append(val)。

返回即可。该过程中可以看出，如果r中有大于1个元素，那么元素出现的次数相等。

2. 代码

代码如下，

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

    def set_left(self, left):
        self.left = left

    def set_right(self, right):
        self.right = right

class Solution(object):
    def preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        r = []
        if root is not None:
            r.append(root.val)
            if root.left != None:
                r.extend(self.preorderTraversal(root.left))
            if root.right != None:
                r.extend(self.preorderTraversal(root.right))
            return r
        else:
            return
    
    def searchBST(self, root, val):
        """
        :type root: TreeNode
        :type val: int
        :rtype: TreeNode
        """
        if root == None:
            return
        current = [root]
        while current != []:
            tmp = []
            for node in current:
                if node.val == val:
                    return node
                if node.left != None:
                    tmp.append(node.left)
                if node.right != None:
                    tmp.append(node.right)

                current = tmp
        return
    
    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        r = []
        if root is not None:
            if root.left != None:
                r.extend(self.inorderTraversal(root.left))
            r.append(root.val)
            if root.right != None:
                r.extend(self.inorderTraversal(root.right))
            return r
        else:
            return

    def isValidBST(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        r = self.inorderTraversal(root)
        for i in range(1, len(r)):
            if r[i-1] >= r[i]:
                return False
        return True

    def getMinimumDifference(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        lst = self.inorderTraversal(root)
        r = 1e5
        for i in range(1, len(lst)):
            if lst[i] - lst[i-1] < r:
                r = lst[i] - lst[i-1]
        return r

    def findMode(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        dic = {}
        r = []
        if root == None:
            return
        current = [root]
        while current != []:
            tmp = []
            for node in current:
                if node.val not in dic.keys():
                    dic.setdefault(node.val, 1)
                    if r == []:
                        r.append(node.val)
                    # 若node.val已经存在，那么+1之后更大
                    elif node.val in r or dic[r[-1]] < dic[node.val]:
                        r = [node.val]
                    # 保证了node.val不在r中
                    elif dic[r[-1]] == dic[node.val]:
                        r.append(node.val)
                else:
                    dic[node.val] += 1
                    if node.val in r or dic[r[-1]] < dic[node.val]:
                        r = [node.val]
                    # 保证了node.val不在r中
                    elif dic[r[-1]] == dic[node.val]:
                        r.append(node.val)


                if node.left != None:
                    tmp.append(node.left)
                if node.right != None:
                    tmp.append(node.right)
            current = tmp

        return r

if __name__ == '__main__':
    sol = Solution()
    node1 = TreeNode(62)
    node2 = TreeNode(2)
    node3 = TreeNode(93)
    node4 = TreeNode(30)
    node5 = TreeNode(15)

    node1 = TreeNode(5)
    node2 = TreeNode(1)
    node3 = TreeNode(4)
    node4 = TreeNode(3)
    node5 = TreeNode(6)

    node1.left = node2
    node1.right = node3
    node3.right = node5
    node3.left = node4
    r = sol.searchBST(node1, 15)
    r = sol.isValidBST(node1)
    r = sol.getMinimumDifference(node1)
    r = sol.findMode(node1)
    print(r)