代码随想录day21，22| 530.二叉搜索树的最小绝对差 501.二叉搜索树中的众数 235. 二叉搜索树的最近公共祖先 701.二叉搜索树中的插入操作 450.删除二叉搜索树

---

前言

530迭代法没看

530.二叉搜索树的最小绝对差

思路

递归法思路和昨天的一样，双指针

方法一 递归法 双指针

最大值的设定方法为：float(“inf”)
更新最小值的代码优化

class Solution(object):
    def __init__(self):
        self.pre = None
        self.result = float("inf")
    def getMinimumDifference(self, curr):
        """
        :type root: TreeNode
        :rtype: int
        """
        if curr== None: return None
        self.getMinimumDifference(curr.left)
        if self.pre: 
            self.result = min(self.result, curr.val - self.pre.val)
        self.pre = curr
        self.getMinimumDifference(curr.right) 
        return self.result

方法二

501.二叉搜索树中的众数

1. 更改了搜索树的定义：可以有重复的了
2. 众数：如果两个数的出现频率都是2的话，那这两个数都返回

思路

方法一 迭代法 普通二叉树

使用普通二叉树的方法进行中序遍历，利用哈希表来记录次数，然后返回次数最大的。
💦自己代码的注意点

1. 记住，使用from collections import defaultdict self.map_ = defaultdict()
2. 遍历字典的时候的语句是：for key, freq in freq_map.items():
3. 自己写的时候没有使用max函数来找map_里面的最大的，有一些处理。
4. 如果要用对于字典寻找最大值，句法是：max(freq_map.values())

from collections import defaultdict
# map里面key为叶子节点的数值，val为统计的次数
class Solution(object):
    def __init__(self):
        self.map_ = defaultdict(int)

    def traversal(self,root):
        if not root: return
        # print("enter traversal: root-val",root.val)
        self.traversal(root.left)
        self.map_[root.val] += 1
        self.traversal(root.right)
    def findMode(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """      
        self.result = []
        max_freq = 0
        self.traversal(root)
        for key, freq in self.map_.items():
            if freq > max_freq:    
                self.result = [key]
                max_freq = freq
                continue
            if freq == max_freq:
                self.result.append(key)
        return self.result
# 使用max函数的方法
from collections import defaultdict

class Solution:
    def searchBST(self, cur, freq_map):
        if cur is None:
            return
        freq_map[cur.val] += 1  # 统计元素频率
        self.searchBST(cur.left, freq_map)
        self.searchBST(cur.right, freq_map)

    def findMode(self, root):
        freq_map = defaultdict(int)  # key:元素，value:出现频率
        result = []
        if root is None:
            return result
        self.searchBST(root, freq_map)
        max_freq = max(freq_map.values())
        for key, freq in freq_map.items():
            if freq == max_freq:
                result.append(key)
        return result

方法二 利用搜索树的性质-双指针

总体思想：双指针pre和curr，定义单个元素次数count和次数最大的max-count，如果发现curr和pre的val相等，那就count++；如果不等，那就count=1从头开始重新计算；
对于max-count，如果发现count==max-count，那就result里面append这个元素；如果有一个count是大于max-count的那就result清空，append新的

class Solution(object):
    def __init__(self):
        self.count = 0#记录当前元素的次数
        self.max_count = 0# 记录次数最大的元素
        self.result = []
        self.pre = None
    def traversal(self,curr):
        if not curr: return
        ##
        # 首先要左中右的顺序遍历 
        self.traversal(curr.left) # 左
        #中
        # 处理第一个节点
        if self.pre == None: #如果刚刚进入，还没有pre的话
            self.count += 1
        elif self.pre.val == curr.val:#如果发现和前面一个相当的话，count++
            self.count += 1
        elif self.pre.val != curr.val:
            self.count = 1
        self.pre = curr# 别忘了这个

        if self.count == self.max_count: 
            self.result.append(curr.val)
        elif self.count > self.max_count:
            self.result = [curr.val]# 很关键的一步，不要忘记清空result，之前result里的元素都失效了
            self.max_count = self.count
        self.traversal(curr.right) #右


    def findMode(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """ 
        self.traversal(root)
        return self.result

方法三 迭代法

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

思路

总体思路：后序遍历从下往上返回，如果一个节点的左右节点中有p和q说明它就是最近的公共节点；
特殊情况：p是q的子节点
递归三部曲：

1. 确定返回值：返回root，传入根节点和p和q的值；
2. 确定终止条件：如果传入节点为空的话，返回；如果传入的节点等于p或者q，就把p节点返回上去

   注意啊，这里包括了上面讲的特殊情况；以下面的10和9为p，q举例，到10节点的时候左为空，右边不为空，但是它自己等于了p的值，直接返回了自己，一路往上返回，最后返回的还是它自己是对的

3. 单层递归逻辑：

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

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

   • 如果都是空的话，就返回none吧
     

方法一 递归

!! 注意处理的都是节点，p和q都是节点

#精简版
class Solution:
    def lowestCommonAncestor(self, root, p, q):
        if root == q or root == p or root is None:
            return root

        left = self.lowestCommonAncestor(root.left, p, q)
        right = self.lowestCommonAncestor(root.right, p, q)

        if left is not None and right is not None:
            return root

        if left is None:
            return right
        return left



#自己写的
class Solution(object):
    def traversal(self,root,p,q):
        #停止递归逻辑
        if root == None: return root
        if root == p or root == q: return root

        # 单层递归逻辑
        #后序遍历，先左右
        left = self.traversal(root.left,p,q)
        right = self.traversal(root.right,p,q)
        if left and right:# 左右孩子都有
            return root
        elif left and not right: #
            return left
        elif right and not left:
            return right
        return None
    def lowestCommonAncestor(self, root, p, q):
        """
        :type root: TreeNode
        :type p: TreeNode
        :type q: TreeNode
        :rtype: TreeNode
        """
        re = self.traversal(root,p,q)
        return re if re else None

方法二 迭代法

235. 二叉搜索树的最近公共祖先

总体思路

利用搜索树的特性：最近公共祖先一定是左子树有p，右子树有q

方法一 递归

注意：pq不知道谁大谁小

class Solution(object):
    def lowestCommonAncestor(self, root, p, q):
        """
        :type root: TreeNode
        :type p: TreeNode
        :type q: TreeNode
        :rtype: TreeNode
        """
        if root == None: return None
        if p.val < root.val and q.val < root.val:
            left_re = self.lowestCommonAncestor(root.left,p,q)
            return left_re
        elif p.val>root.val and q.val>root.val:
            right_re = self.lowestCommonAncestor(root.right,p,q)
            return right_re
        elif (p.val <= root.val and q.val >= root.val) or(q.val <= root.val and p.val >= root.val):
            return root
#精简
class Solution:
    def lowestCommonAncestor(self, root, p, q):
        if root.val > p.val and root.val > q.val:
            return self.lowestCommonAncestor(root.left, p, q)
        elif root.val < p.val and root.val < q.val:
            return self.lowestCommonAncestor(root.right, p, q)
        else:
            return root

方法二 迭代

因为有序，所以迭代也很简单

class Solution(object):
    def lowestCommonAncestor(self, root, p, q):
        """
        :type root: TreeNode
        :type p: TreeNode
        :type q: TreeNode
        :rtype: TreeNode
        """
        if root == None: return None
        curr = root
        while curr:
            if curr.val > p.val and curr.val>q.val:
                curr = curr.left
            elif curr.val < p.val and curr.val<q.val:
                curr = curr.right
            else: 
                return curr
        return None   

701.二叉搜索树中的插入操作

总体思路

本题不要想复杂了，直接在叶子节点插入就行了

1. 终止条件：如果发现是叶子节点，就插入

方法一 递归

有好几个版本，但是我直接写出了下面这个版本。。。。可能可以看看吧【再看一遍视频吧，不知道他为什么写那么复杂】

class Solution:
    def insertIntoBST(self, root, val):
        if root is None:
            node = TreeNode(val)
            return node

        if root.val > val:
            root.left = self.insertIntoBST(root.left, val)
            return root
        if root.val < val:
            root.right = self.insertIntoBST(root.right, val)
            return root

        # return root

方法二 迭代法 没看

450.删除二叉搜索树

总体思路

删除的时候有三种情况：

1. 删除叶子节点，直接删，返回none
2. 删除只有一个叶子的节点，返回它的叶子
3. 删除两个叶子都有的根节点：返回右叶子节点，将左子树放到右子树里面，左子树一定是都小于右边子树的所有节点，所以一定是放在右子树最左边的叶子节点上；同理，返回左叶子节点，将右边叶子节点加到左子树里面最右边的叶子节点
   具体递归的过程中分了五种情况讨论：
   

方法一 递归

class Solution(object):
    def deleteNode(self, root, key):
        """
        :type root: TreeNode
        :type key: int
        :rtype: TreeNode
        """
        # 下面都是终止条件
        if root == None: return None #就没有要删除的节点，都遍历到最后了
        if root.val == key:
            if not root.left and not root.right: return None
            elif root.left and not root.right: return root.left
            elif root.right and not root.left: return root.right
            else:
                #返回右节点
                curr = root.right
                while curr.left:
                    curr = curr.left
                curr.left = root.left
                return root.right
        # 递归单层逻辑
        if root.val > key:
            root.left = self.deleteNode(root.left,key)

        elif root.val < key:
            root.right = self.deleteNode(root.right,key)
        return root
     
    # 简洁版 没看
class Solution:
    def deleteNode(self, root, key):
        if root is None:  # 如果根节点为空，直接返回
            return root
        if root.val == key:  # 找到要删除的节点
            if root.right is None:  # 如果右子树为空，直接返回左子树作为新的根节点
                return root.left
            cur = root.right
            while cur.left:  # 找到右子树中的最左节点
                cur = cur.left
            root.val, cur.val = cur.val, root.val  # 将要删除的节点值与最左节点值交换
        root.left = self.deleteNode(root.left, key)  # 在左子树中递归删除目标节点
        root.right = self.deleteNode(root.right, key)  # 在右子树中递归删除目标节点
        return root

方法二 迭代

---

总结