二叉树刷题（BST）

**687** 二叉树结构，寻找最长路径，路径上的每个值都是相同的。

# 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 longestUnivaluePath(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        lon=[0]
        def tranverse(node):
            if not node:
                return 0
            left_len,right_len = tranverse(node.left),tranverse(node.right)
            left=(left_len+1) if node.left and node.left.val==node.val else 0
            right=(right_len+1) if node.right and node.right.val==node.val else 0
            lon[0]=max(lon[0],left+right)
            return max(left,right)
        tranverse(root)
        return lon[0]

**671** 二叉树中第二小的节点

# 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 findSecondMinimumValue(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        res=[float('inf')]#全局变量
        
        def traverse(node):
            if not node:
                return 
            if root.val <node.val<res[0]:
                res[0]=node.val
            traverse(node.left)
            traverse(node.right)
        traverse(root)
        return -1 if res[0]==float('inf') else res[0]

669 修剪叉搜索树

# 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 trimBST(self, root, L, R):
        """
        :type root: TreeNode
        :type L: int
        :type R: int
        :rtype: TreeNode
        """
        if not root:
            return None
        if root.val<L:
            return self.trimBST(root.right,L,R)
        if root.val>R:
            return self.trimBST(root.left,L,R)
        root.left=self.trimBST(root.left,L,R)
        root.right=self.trimBST(root.right,L,R)
        return root

BST搜索二叉树

**1）定义：二叉搜索树中的关键字key中的存储方式总是满足二叉搜索树的性质：****设x是二叉搜索树中的一个节点，如果y是x左子树中的一个节点，那么会有y.key<=x.key;如果y是右子树中的一个节点那么y.key>=x.key。**举一个简单的例子：

**2）作用：二叉搜索数很多时候用来进行数据查找，从根节点开始，然后沿着一条简单的路径一直往下，之道找到数据或者得到null值**时间复杂度分析：如果假设树的高度是h，那么查找过程的时间复杂度就是O(n)。**3) 伪代码**

```
递归实现
Tree_Search(x,k):
if x ==null or x.key ==k:
    return x
if k<x.key:
   return Tree_Search(x.left,k)
else return Tree_Search(x.right,k)
```
```
非递归实现
Tree_Search(x,k):
while x!=null and k!=x.key:
    if k < x.key:
       x=x.left
    else:
       x= x.right
return x
```