代码随想录算法训练营第二十一天| LeetCode530.二叉搜索树的最小绝对差、LeetCode501.二叉搜索树中的众数、LeetCode236. 二叉树的最近公共祖先
530.二叉搜索树的最小绝对差
题目描述: 530.二叉搜索树的最小绝对差.
解法
递归(数组)
class Solution(object):
def travel(self,root):
if not root:
return []
left = self.travel(root.left)
right = self.travel(root.right)
return left + [root.val] + right
def getMinimumDifference(self, root):
vals = self.travel(root)
min = float("inf")
for i in range(1,len(vals)):
if vals[i] - vals[i-1] < min:
min = vals[i] - vals[i-1]
return min
递归（指针）
class Solution(object):
def __init__(self):
self.min = float('inf')
self.pre = None
def travel(self,root):
if not root:
return
left = self.travel(root.left)
if self.pre:
self.min = min(self.min,root.val - self.pre.val)
self.pre = root
right = self.travel(root.right)
def getMinimumDifference(self, root):
self.travel(root)
return self.min
如果在递归里想用指针的话，需要将一些值放在递归之外。
迭代
lass Solution(object):
def getMinimumDifference(self, root):
min_abs = float('inf')
st = [root]
pre = None
while st:
node = st.pop()
if node:
if node.right:
st.append(node.right)
st.append(node)
st.append(None)
if node.left:
st.append(node.left)
else:
node = st.pop()
if pre:
min_abs = min(min_abs,node.val-pre.val)
pre = node
return min_abs
501.二叉搜索树中的众数
题目描述: 530.二叉搜索树的最小绝对差.
解法
递归(字典数组)
class Solution(object):
def __init__(self):
self.map = collections.defaultdict(int)
def travel(self,node):
if not node:
return
self.travel(node.left)
self.map[node.val] += 1
self.travel(node.right)
def findMode(self, root):
if not root:
return []
res = []
self.travel(root)
max_num = max(self.map.values())
for k,v in self.map.items():
if v == max_num:
res.append(k)
return res
递归双指针
class Solution(object):
def __init__(self):
self.max_count = 0
self.count = 0
self.pre = None
self.res = []
def travel(self,node):
if not node:
return
self.travel(node.left)
if not self.pre: # 第一个节点
self.res.append(node.val) # 直接将当前节点加入到res
self.count += 1 # 当前计数+1
self.max_count+=1 # 最大计数+1
else: # 非第一个节点
if self.pre.val != node.val: # 与前一个结点不同
self.count = 1 # 重新计算当前计数
else: # 与前一个结点不同
self.count += 1 # 当前计数+1
if self.count == self.max_count: # 当前计数达到最大计数
self.res.append(node.val) # 在结果中加入当前计数对应的数字
if self.count > self.max_count: # 当前计数超过最大计数
self.max_count = self.count # 更新最大计数
self.res = [node.val] # 清空并赋值
self.pre = node
self.travel(node.right)
def findMode(self, root):
self.travel(root)
return self.res
迭代
class Solution(object):
def findMode(self, root):
res = []
st = [root]
pre = None
max_count = 0
count = 0
while st:
node = st.pop()
if node:
if node.right:
st.append(node.right)
st.append(node)
st.append(None)
if node.left:
st.append(node.left)
else:
node = st.pop()
if not pre or node.val != pre.val:
count = 1
else:
count += 1
if count == max_count:
res.append(node.val)
if count > max_count:
max_count = count
res = [node.val]
pre = node
return res
236. 二叉树的最近公共祖先
题目描述: 530.二叉搜索树的最小绝对差.
解法
class Solution(object):
def lowestCommonAncestor(self, root, p, q):
if root == p or root == q or not root:
return root
right = self.lowestCommonAncestor(root.right,p,q)
left = self.lowestCommonAncestor(root.left,p,q)
if left and right:
return root
if not left and right:
return right
elif left and not right:
return left
else:
return None
判断每一颗树就好，首先判断它自身，如果它是q或者是p，那么直接返回他就好，如果这个节点和另一个节点不在一个分支上，那就作为left或者right条件，如果他是另一个节点的父节点，最后也会返回到结果中。
接下来就要判断它的左右子树了，如果左右子树都分别返回了内容（这个内容是不可能重复的，因为p和q都只有一个），那这个节点就是要返回的内容，最终一直到根节点，根节点的另一边没有返回内容，所以最后返回的是这个节点。
如果左右只有一个，那返回有的那个即可。
左右都没有的话，就返回None。