二叉搜索树（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
```

 

**687** 二叉树结构，寻找最长路径，路径上的每个值都是相同的。```# Definition for a binary tree node.# class TreeNode(object):# def __init__(self, x):# self.val = x# self.left = None# self.right = Noneclass 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 = Noneclass 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 = Noneclass 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,binary search tree)**1）定义：二叉搜索树中的关键字key中的存储方式总是满足二叉搜索树的性质：****设x是二叉搜索树中的一个节点，如果y是x左子树中的一个节点，那么会有y.key<=x.key;如果y是右子树中的一个节点那么y.key>=x.key。**举一个简单的例子：<center></center>**2）作用：二叉搜索数很多时候用来进行数据查找，从根节点开始，然后沿着一条简单的路径一直往下，之道找到数据或者得到null值**时间复杂度分析：如果假设树的高度是h，那么查找过程的时间复杂度就是O(n)。**3) 伪代码**```递归实现Tree_Search(x,k):if x ==null or x.key ==k: return xif 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.rightreturn x```