文章目录
前言
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.二叉搜索树中的众数
- 更改了搜索树的定义:可以有重复的了
- 众数:如果两个数的出现频率都是2的话,那这两个数都返回
思路
方法一 迭代法 普通二叉树
使用普通二叉树的方法进行中序遍历,利用哈希表来记录次数,然后返回次数最大的。
💦自己代码的注意点
- 记住,使用from collections import defaultdict self.map_ = defaultdict()
- 遍历字典的时候的语句是:for key, freq in freq_map.items():
- 自己写的时候没有使用max函数来找map_里面的最大的,有一些处理。
- 如果要用对于字典寻找最大值,句法是: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的子节点
递归三部曲:
- 确定返回值:返回root,传入根节点和p和q的值;
- 确定终止条件:如果传入节点为空的话,返回;如果传入的节点等于p或者q,就把p节点返回上去
注意啊,这里包括了上面讲的特殊情况;以下面的10和9为p,q举例,到10节点的时候左为空,右边不为空,但是它自己等于了p的值,直接返回了自己,一路往上返回,最后返回的还是它自己是对的
- 单层递归逻辑:
-
如果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.二叉搜索树中的插入操作
总体思路
本题不要想复杂了,直接在叶子节点插入就行了
- 终止条件:如果发现是叶子节点,就插入
方法一 递归
有好几个版本,但是我直接写出了下面这个版本。。。。可能可以看看吧【再看一遍视频吧,不知道他为什么写那么复杂】
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.删除二叉搜索树
总体思路
删除的时候有三种情况:
- 删除叶子节点,直接删,返回none
- 删除只有一个叶子的节点,返回它的叶子
- 删除两个叶子都有的根节点:返回右叶子节点,将左子树放到右子树里面,左子树一定是都小于右边子树的所有节点,所以一定是放在右子树最左边的叶子节点上;同理,返回左叶子节点,将右边叶子节点加到左子树里面最右边的叶子节点
具体递归的过程中分了五种情况讨论:
方法一 递归
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
方法二 迭代