687. 最长同值路径

我觉得这一题好难哇，看了题解写的，个人觉得还是有很多trick……之后还需要慢慢品
这里的“路径”只有两种情况，由父节点向左或向右，并没有父节点在路径中间的情况，评论中有人说有这种情况，但写个测试用例看看就知道其实是不存在这种情况的。

class Solution(object):
    def longestUnivaluePath(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        self.maxlength = 0
        def isSame(node):
            if not node: return 0
            left_len = isSame(node.left)
            right_len = isSame(node.right)
            left = right = 0
            if node.left and node.left.val == node.val:
                left = left_len + 1
            if node.right and node.right.val == node.val:
                right = right_len + 1
            self.maxlength = max(self.maxlength, left + right)
            return max(left, right)
        isSame(root)
        return self.maxlength

783. 二叉搜索树结点最小距离

二叉搜索树的中序遍历结果是一个升序数组，然后记录每两个pop出来的node值之差，就能在遍历一遍的情况下找到最小值

class Solution(object):
    def minDiffInBST(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        self.res = []
        node = root
        def saveTree(node):
            while node:
                self.res.append(node)
                node = node.left

        pre = -101
        min_diff = 101
        while node or self.res:
            saveTree(node)
            node = self.res.pop()
            min_diff = min(min_diff, node.val - pre)
            pre = node.val
            node = node.right
        return min_diff

递归写法

class Solution(object):
    def minDiffInBST(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        self.pre = -101
        self.min_diff = 101
        def traverse(node):
            if node:
                traverse(node.left)
                self.min_diff = min(self.min_diff, node.val - self.pre)
                self.pre = node.val
                traverse(node.right)
        traverse(root)
        return self.min_diff

938. 二叉搜索树的范围和

给定二叉搜索树的根结点 root，返回 L 和 R（含）之间的所有结点的值的和。

二叉搜索树保证具有唯一的值。

示例 1：

输入：root = [10,5,15,3,7,null,18], L = 7, R = 15 输出：32
示例 2：

输入：root = [10,5,15,3,7,13,18,1,null,6], L = 6, R = 10 输出：23

提示：

树中的结点数量最多为 10000 个。 最终的答案保证小于 2^31。

这一题就是算L<= node.val <= R的和 中序遍历就行

class Solution(object):
    def rangeSumBST(self, root, L, R):
        """
        :type root: TreeNode
        :type L: int
        :type R: int
        :rtype: int
        """
        self.val = R + L
        self.L = L
        self.R = R
        def tarverse(node):
            if node:
                tarverse(node.left)
                if node.val > L and node.val < R:
                    self.val += node.val
                # if node.val < L or node.val > R: return
                tarverse(node.right)
        tarverse(root)
        return self.val