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)