代码随想录算法训练营第二十一天|530. 二叉搜索树的最小绝对差,501. 二叉搜索树中的众数,236. 二叉树的最近公共祖先

【注意】

1.二叉搜索树采用中序遍历，其实就是一个有序数组。

2.使用双指针，更快。

【代码】

 1 # Definition for a binary tree node.
 2 # class TreeNode(object):
 3 #     def __init__(self, val=0, left=None, right=None):
 4 #         self.val = val
 5 #         self.left = left
 6 #         self.right = right
 7 class Solution(object):
 8     def getMinimumDifference(self, root):
 9         """
10         :type root: TreeNode
11         :rtype: int
12         """
13         global pre, minval
14         pre = None
15         minval = 10**5
16         self.traversal(root)
17         return minval
18 
19     def traversal(self, root):
20         global pre, minval
21         if not root:
22             return None
23         #左
24         self.traversal(root.left)
25         
26         #中
27         if pre and root.val - pre.val < minval:
28             minval = root.val - pre.val
29         pre = root
30 
31         #右
32         self.traversal(root.right)

501. 二叉搜索树中的众数

【注意】

1.同上中序遍历（有序），双指针，求众数，众数不止一个。

2.中是我们处理逻辑，pre=cur，处理时需要清空result数组。

【代码】

 1 # Definition for a binary tree node.
 2 # class TreeNode(object):
 3 #     def __init__(self, val=0, left=None, right=None):
 4 #         self.val = val
 5 #         self.left = left
 6 #         self.right = right
 7 class Solution(object):
 8         """
 9         :type root: TreeNode
10         :rtype: List[int]
11         """
12         #递归法 常量空间，递归产生的栈不算
13         def __init__(self):
14             self.pre = TreeNode() #双指针
15             self.count = 0
16             self.max_count = 0
17             self.result = []
18         
19         def findMode(self,root):
20             if not root:
21                 return None
22             self.search_BST(root)
23             return self.result
24         
25         #递归
26         def search_BST(self,cur):
27             if not cur:
28                 return None
29             #左
30             self.search_BST(cur.left)
31             #中
32             if not self.pre: #pre还为None时
33                 self.count = 1
34             # 与前一个节点数值相同
35             elif self.pre.val == cur.val:
36                 self.count += 1
37             # 与前一个节点数值不相同
38             else:
39                 self.count = 1
40             
41             self.pre = cur
42 
43             if self.count == self.max_count:#众数不止一个
44                 self.result.append(cur.val)
45                 
46             if self.count > self.max_count:
47                 self.max_count = self.count
48                 self.result = [cur.val]    # 清空self.result，确保result之前的的元素都失效
49 
50             #右
51             self.search_BST(cur.right)

236. 二叉树的最近公共祖先

[注意]

1.情况2.就是节点本身p(q)，它拥有一个子孙节点q(p)。

2.要理解如果返回值left为空，right不为空为什么要返回right，为什么可以用返回right传给上一层结果。

[代码]

1.求最小公共祖先，需要从底向上遍历，那么二叉树，只能通过后序遍历（即：回溯）实现从底向上的遍历方式。

2.在回溯的过程中，必然要遍历整棵二叉树，即使已经找到结果了，依然要把其他节点遍历完，因为要使用递归函数的返回值（也就是代码中的left和right）做逻辑判断。

 1 # Definition for a binary tree node.
 2 # class TreeNode(object):
 3 #     def __init__(self, x):
 4 #         self.val = x
 5 #         self.left = None
 6 #         self.right = None
 7 
 8 class Solution(object):
 9     def lowestCommonAncestor(self, root, p, q):
10         """
11         :type root: TreeNode
12         :type p: TreeNode
13         :type q: TreeNode
14         :rtype: TreeNode
15         """
16         if not root or root == p or root == q:#root为,返回null
17             return root
18         #后序遍历
19         #左
20         left = self.lowestCommonAncestor(root.left,p,q)
21         #右
22         right = self.lowestCommonAncestor(root.right,p,q)
23         #中
24         if left and right:
25             return root
26         if left:
27             return left
28         if right:
29             return right
30         return None