二叉树（思路篇）

承接二叉树（纲领篇），先复述一下前文总结的二叉树解题总纲：

1. 是否可以通过遍历一遍二叉树得到答案？ 如果可以，用一个 traverse 函数配合外部变量来实现，这叫「遍历」的思维模式。
2. 是否可以定义一个递归函数，通过子问题（子树）的答案推导出原问题的答案？ 如果可以，写出这个递归函数的定义，并充分利用这个函数的返回值，这叫「分解问题」的思维模式。

无论使用哪种思维模式，你都需要思考：

如果单独抽出一个二叉树节点，它需要做什么事情？需要在什么时候（前/中/后序位置）做？其他的节点不用你操心，递归函数会帮你在所有节点上执行相同的操作。

本文就以几道比较简单的题目为例，带你实践运用这几条总纲，理解「遍历」的思维和「分解问题」的思维有何区别和联系。

一、翻转二叉树

力扣第 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 函数就会按照定义工作。