代码随想录day21：二叉树06（二叉搜索树最小绝对差，众数，最近公共祖先）

1. 二叉搜索树最小绝对差（leetcode 530）

我们要运用二叉搜索树的特性。还记得我们在上一题中说到，二叉搜索树的中序遍历就是从左下角往上走再走到右下角，最后得到的是一个有序数组。

因此我们可以用迭代法的中序遍历去访问记录每次的最小差值，最后直接return。时间复杂度的话只需要遍历一遍树，空间复杂度的话也不需要另外的数组记录。很高效。

class Solution:
    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
        stack = []
        cur = root
        pre = None
        record = float('inf')
        while cur or stack:
            if cur:
                stack.append(cur)
                cur = cur.left
            elif not cur:
                cur = stack.pop()
                if pre:
                    record = min(record, cur.val - pre.val)
                pre = cur
                cur = cur.right
        return record

同时我们也可以用递归法inorder traversal一遍，然后在遍历一遍数组。稍微慢一点点，总体差不多，都是O(n)

class Solution:
    def traversal(self, root):
        if not root:
            return 
        self.traversal(root.left)
        self.num.append(root.val)
        self.traversal(root.right)


    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
        self.num = []
        self.traversal(root)

        ans = float('inf')

        for i in range(1, len(self.num)):
            ans = min(ans, self.num[i] - self.num[i-1])
        
        return ans

2. 二叉搜索树的众数（leetcode 501）

如果不是二叉搜索树的话，最直观的做法就是遍历一遍，然后用dictionary来记录每个元素的频率。最后遍历dictionary找出频率最大的几个节点值

class Solution:
    def traversal(self, root, count):
        if not root:
            return 
        if root.val not in self.count:
            count[root.val] = 1
        else:
            count[root.val] += 1
        self.traversal(root.left, count)
        self.traversal(root.right, count)

    def findMode(self, root: Optional[TreeNode]) -> List[int]:
        self.count = {}
        self.traversal(root, self.count)
        result = []
        max_freq = max(self.count.values())
        for key, freq in self.count.items():
            if freq == max_freq:
                result.append(key)
        return result

同时这题我们也能运用二叉搜索树的中序为有序数列的特性。我们只需要像处理有序数列一样，用双指针法记录相同连续出现的节点的首尾，记录最大频率，然后以中序遍历树就可以了

class Solution:
    def findMode(self, root: Optional[TreeNode]) -> List[int]:
        st = []
        cur = root
        pre = None
        maxCount = 0  # 最大频率
        count = 0  # 统计频率
        result = []

        while cur is not None or st:
            if cur is not None:  # 指针来访问节点，访问到最底层
                st.append(cur)  # 将访问的节点放进栈
                cur = cur.left  # 左
            else:
                cur = st.pop()
                if pre is None:  # 第一个节点
                    count = 1
                elif pre.val == cur.val:  # 与前一个节点数值相同
                    count += 1
                else:  # 与前一个节点数值不同
                    count = 1

                if count == maxCount:  # 如果和最大值相同，放进result中
                    result.append(cur.val)

                if count > maxCount:  # 如果计数大于最大值频率
                    maxCount = count  # 更新最大频率
                    result = [cur.val]  # 很关键的一步，不要忘记清空result，之前result里的元素都失效了

                pre = cur
                cur = cur.right  # 右

        return result

3. 二叉树的公共祖先（leetcode 236）

还是老样子，bfs用不了，我们选择dfs。因为我们要找的是公共祖先，所以这里我们想要自下而上遍历，因此后序遍历最适合本题。

后序的迭代法比较麻烦，我们先尝试用递归法。

首先最容易想到的一个情况：如果找到一个节点，发现左子树出现结点p，右子树出现节点q，或者 左子树出现结点q，右子树出现节点p，那么该节点就是节点p和q的最近公共祖先。 即情况一：

判断逻辑为，递归遍历到q就将q返回，遍历到p就将p返回。如果左右子树的返回值都不为空，说明此时的中节点一定是pq的祖先。

第二种情况是p或q为对方的祖先节点，那么此时仍然是遇到p或者q就返回，这样也包含了pq本身为公共祖先的情况。

递归三部曲分析：

1. 参数和返回值。参数为root，q，p。遇到pq就返回

2. 确定终止条件。如果遇到空，返回空。遇到pq返回pq。

3. 确定单层递归逻辑。注意我们这题要用后序遍历法

我们曾经提到过，递归函数有返回值就是要遍历某一条边。但又返回值也要看如何处理返回值。

搜索一条边写法：

if (递归函数(root->left)) return ;

if (递归函数(root->right)) return ;

搜索整棵树写法：

left = 递归函数(root->left);  // 左
right = 递归函数(root->right); // 右
left与right的逻辑处理;         // 中 

在递归函数有返回值的情况下：如果要搜索一条边，递归函数返回值不为空的时候，立刻返回，如果搜索整个树，直接用一个变量left、right接住返回值，这个left、right后序还有逻辑处理的需要，也就是后序遍历中处理中间节点的逻辑（也是回溯）。

那么为什么要遍历整棵树呢？直观上来看，找到最近公共祖先，直接一路返回就可以了。

但事实上还要遍历根节点右子树（即使此时已经找到了目标节点了），也就是图中的节点4、15、20。

因为在如下代码的后序遍历中，如果想利用left和right做逻辑处理， 不能立刻返回，而是要等left与right逻辑处理完之后才能返回。

因此，本题我们一定要遍历完整棵树，才能做到逻辑统一，让每一个叶节点都能像传导一样返回我们所需要的东西，不管是找到的pq也好，还是没找到的null也好

TreeNode* left = lowestCommonAncestor(root->left, p, q);
TreeNode* right = lowestCommonAncestor(root->right, p, q);

我们用left right接住左右节点的返回值，再进行回溯。

如果left 和 right都不为空，说明此时root就是最近公共节点。返回。这个比较好理解

如果left为空，right不为空，就返回right，说明目标节点是通过right返回的，反之依然。

图中节点10的左子树返回null，右子树返回目标值7，那么此时节点10的处理逻辑就是把右子树的返回值（最近公共祖先7）返回上去！最后返回到头上的值就是我们的公共根节点。

完整流程图如下：

整体代码如下

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        if root == q or root == p or root == None:
            return root
        left = self.lowestCommonAncestor(root.left, p, q)   #左
        right = self.lowestCommonAncestor(root.right, p, q)  #右
        #中
        if left and right:     #两边有的节点找到目标
            return root
        elif left and not right: return left     #一边有的节点，传目标上来
        elif not left and right: return right
        elif not left and not right: return None   #啥都没有的节点穿None上来

        self.lowestCommonAncestor(root, p, q)