承接二叉树(纲领篇),先复述一下前文总结的二叉树解题总纲:
- 是否可以通过遍历一遍二叉树得到答案? 如果可以,用一个
traverse
函数配合外部变量来实现,这叫「遍历」的思维模式。- 是否可以定义一个递归函数,通过子问题(子树)的答案推导出原问题的答案? 如果可以,写出这个递归函数的定义,并充分利用这个函数的返回值,这叫「
分解问题
」的思维模式。无论使用哪种思维模式,你都需要思考:
如果单独抽出一个二叉树节点,它需要做什么事情?需要在什么时候(前/中/后序位置)做?其他的节点不用你操心,递归函数会帮你在所有节点上执行相同的操作。
本文就以几道比较简单的题目为例,带你实践运用这几条总纲,理解「遍历」的思维和「分解问题」的思维有何区别和联系。
一、翻转二叉树
力扣第 226 题「 翻转二叉树」
不难发现,只要把二叉树上的每一个节点的左右子节点进行交换,最后的结果就是完全翻转之后的二叉树。
那么现在开始在心中默念二叉树解题总纲:
1、这题能不能用「遍历」的思维模式解决?
可以,我写一个 traverse 函数遍历每个节点,让每个节点的左右子节点颠倒过来就行了。
单独抽出一个节点,需要让它做什么?让它把自己的左右子节点交换一下。
需要在什么时候做?好像前中后序位置都可以。
综上,可以写出如下解法代码:
// 主函数
TreeNode invertTree(TreeNode root) {
// 遍历二叉树,交换每个节点的子节点
traverse(root);
return root;
}
// 二叉树遍历函数
void traverse(TreeNode root) {
if (root == null) {
return;
}
/**** 前序位置 ****/
// 每一个节点需要做的事就是交换它的左右子节点
TreeNode tmp = root.left;
root.left = root.right;
root.right = tmp;
// 遍历框架,去遍历左右子树的节点
traverse(root.left);
traverse(root.right);
}
2、这题能不能用「分解问题」的思维模式解决?
我们尝试给 invertTree
函数赋予一个定义:
// 定义:将以 root 为根的这棵二叉树翻转,返回翻转后的二叉树的根节点
TreeNode invertTree(TreeNode root);
然后思考,对于某一个二叉树节点 x
执行 invertTree(x)
,你能利用这个递归函数的定义做点啥?
我可以用 invertTree(x.left)
先把 x
的左子树翻转,再用 invertTree(x.right)
把 x
的右子树翻转,最后把 x
的左右子树交换,这恰好完成了以 x
为根的整棵二叉树的翻转,即完成了 invertTree(x)
的定义。
直接写出解法代码:
// 定义:将以 root 为根的这棵二叉树翻转,返回翻转后的二叉树的根节点
TreeNode invertTree(TreeNode root) {
if (root == null) {
return null;
}
// 利用函数定义,先翻转左右子树
TreeNode left = invertTree(root.left);
TreeNode right = invertTree(root.right);
// 然后交换左右子节点
root.left = right;
root.right = left;
// 和定义逻辑自恰:以 root 为根的这棵二叉树已经被翻转,返回 root
return root;
}
这种「分解问题」的思路,核心在于你要给递归函数一个合适的定义,然后用函数的定义来解释你的代码;如果你的逻辑成功自恰,那么说明你这个算法是正确的。
第二题、填充节点的右侧指针
力扣第 116 题「 填充每个二叉树节点的右侧指针」
这道题怎么做呢?来默念二叉树解题总纲:
1、这题能不能用「遍历」的思维模式解决?
传统的 traverse
函数是遍历二叉树的所有节点,但现在我们想遍历的其实是两个相邻节点之间的「空隙」。
所以我们可以在二叉树的基础上进行抽象,你把图中的每一个方框看做一个节点:
这样,一棵二叉树被抽象成了一棵三叉树,三叉树上的每个节点就是原先二叉树的两个相邻节点。
// 主函数
Node connect(Node root) {
if (root == null) return null;
// 遍历「三叉树」,连接相邻节点
traverse(root.left, root.right);
return root;
}
// 三叉树遍历框架
void traverse(Node node1, Node node2) {
if (node1 == null || node2 == null) {
return;
}
/**** 前序位置 ****/
// 将传入的两个节点穿起来
node1.next = node2;
// 连接相同父节点的两个子节点
traverse(node1.left, node1.right);
traverse(node2.left, node2.right);
// 连接跨越父节点的两个子节点
traverse(node1.right, node2.left);
}
2、这题能不能用「分解问题」的思维模式解决?
好像没有什么特别好的思路,所以这道题无法使用「分解问题」的思维来解决。
3、当然也能使用寻常的层次遍历方法来解决
class Solution {
public Node connect(Node root) {
if(root==null) return null;
Deque<Node> q=new ArrayDeque<>();
q.offer(root);
while(!q.isEmpty()){
int size=q.size();
Node pre=q.pop();
if(pre.left!=null) q.offer(pre.left);
if(pre.right!=null) q.offer(pre.right);
for(int i=0;i<size-1;i++){
Node cur=q.pop();
pre.next=cur;
pre=cur;
if(pre.left!=null) q.offer(pre.left);
if(pre.right!=null) q.offer(pre.right);
}
pre.next=null;
}
return root;
}
}
第三题、将二叉树展开为链表
力扣第 114 题「 将二叉树展开为链表」
1、这题能不能用「遍历」的思维模式解决?
可以,但是需要重新造一条链表,但是函数的返回值为viod
,表明题目要求我们在原地进行操作
2、这题能不能用「分解问题」的思维模式解决?
我们尝试给出函数的定义:
// 定义:输入节点 root,然后 root 为根的二叉树就会被拉平为一条链表
void flatten(TreeNode root);
有了这个函数定义,如何按题目要求把一棵树拉平成一条链表?
对于一个节点 x
,可以执行以下流程:
1、先利用 flatten(x.left)
和 flatten(x.right)
将 x
的左右子树拉平。
2、将 x
的右子树接到左子树下方,然后将整个左子树作为右子树。
直接看代码实现:
// 定义:将以 root 为根的树拉平为链表
void flatten(TreeNode root) {
// base case
if (root == null) return;
// 利用定义,把左右子树拉平
flatten(root.left);
flatten(root.right);
/**** 后序遍历位置 ****/
// 1、左右子树已经被拉平成一条链表
TreeNode left = root.left;
TreeNode right = root.right;
// 2、将左子树作为右子树
root.left = null;
root.right = left;
// 3、将原先的右子树接到当前右子树的末端
TreeNode p = root;
while (p.right != null) {
p = p.right;
}
p.right = right;
}
你看,这就是递归的魅力,你说 flatten
函数是怎么把左右子树拉平的?
不容易说清楚,但是只要知道 flatten
的定义如此并利用这个定义,让每一个节点做它该做的事情,然后 flatten
函数就会按照定义工作。