二叉树结构转化

• 通常将二叉树根据某些要求进行结构重构，比如线性结构转化(链表，数组)，序列化等。

常见题型

注：这类题目最基本的解题思路是利用递归分治 (也可以使用迭代方法)，在构建树结构的时候，我们通常会使用前序遍历的思路自上而下，进行建树，每一次递归中，得到左右子树的值进行连接。

链表类

Leetcode 114 - Flatten Binary Tree to LinkedList

LeetCode 426 - Convert BST to Sorted Doubly Linked List

线性数组或字符类

Leetcode 297. 序列化和反序列化二叉树

Leetcode 106. Construct Binary Tree from Inorder and Postorder Traversal

Leetcode 105. Construct Binary Tree from Preorder and Inorder Traversal

Leetcode 536. Construct Binary Tree from String

Leetcode 606. Construct String from Binary Tree

Leetcode 889. Construct Binary Tree from Preorder and Postorder Traversal

二叉搜索树

Leetcode 449. Serialize and Deserialize BST

题目思路

Leetcode 114 - Flatten Binary Tree to LinkedList

将二叉树以前序遍历的顺序转化成连接结构，要求in-place即不占用额外空间存储新的链表结构。基本思路是递归分治，这里我们使用后序遍历的思路，先拿到左右结点然后转化成链表结构，在每一次递归中：

1. 拿到左右子结点
2. 如果左子树为空则直接返回右子树
3. 如果左子树不为空，将左子树的最右边的结点与当前节点右子树连接，然后将当前节点右边连接到该左子树，然后将当前节点左子树置空。

代码如下：

class Solution {
    public void flatten(TreeNode root) {
        dfs(root);
    }

    private void dfs(TreeNode root) {
        if (root==null) return;
        if (root.left==null && root.right==null) return;

        dfs(root.left);
        dfs(root.right);

        if (root.left==null) return;
        else {
            TreeNode dum = root.left;
            while (dum.right!=null) {
                dum = dum.right;
            }
            dum.right = root.right;
            root.right = root.left;
            root.left = null;
        }
    }
}

Leetcode 606. Construct String from Binary Tree

二叉树序列化问题，根据二叉树前序遍历顺序将各节点按照继承关系打印出来

例子：[1,2,3,4] -> "1(2(4))(3)"

二叉树序列化，通常思路就是前序遍历依次打印各个节点，按照分治的思路，我们在每一次递归任务中，需要做以下步骤：

1. 打印当前节点
2. 打印左括号
3. 遍历左子树
4. 打印右括号
5. 判断右子树是否为空，如果不为空重复 2，3(打印右子树)，4。

代码如下：

时间复杂度： ; 空间复杂度： , h代表递归深度。

class Solution {
    StringBuilder str = new StringBuilder();
    public String tree2str(TreeNode root) {
        dfs(root);
        return str.toString();
    }

    private void dfs(TreeNode root) {
        if (root==null) return;

        str.append(root.val+"");

        if (root.left==null && root.right==null) return;

        str.append('(');
        dfs(root.left);
        str.append(')');

        // skip if right == null
        if (root.right!=null) {
            str.append('(');
            dfs(root.right);
            str.append(')');
        }
    }
}

 

Leetcode 536. Construct Binary Tree from String

这道题目则是上面LC.606的反序列化，通过给定序列化字符串构造原始的树结构，由于序列化后可以通过"()" 来判断节点的父子关系，这道题思路有一些类似Leetcode基础计算器或者表达式计算的问题，我们需要维护一个栈结构，在遍历字符串过程中：

1. 如果遇到左括号，继续循环
2. 如果遇到数字或者负号，读取数字位，创建结点并加入Stack中
3. 如果遇到右括号，即需要开始处理结点父子关系，将最近结点pop出来，pop后栈中最顶上的结点一定是pop出结点的父亲结点，将当前节点连接到该父亲结点上，左优先如果左边不为空则连接到右子树。

代码如下：

时间复杂度： ; 空间复杂度： , h代表递归深度。

class Solution {
    public TreeNode str2tree(String s) {
        if (s==null || s.length()==0) return null;
        Stack<TreeNode> stk = new Stack<>();

        for (int i=0; i<s.length();) {
            if (s.charAt(i)=='(') {
                i++;
                continue;
            } else if (s.charAt(i)==')') {
                if (!stk.isEmpty()) {
                    TreeNode node = stk.pop();
                    TreeNode parent = stk.peek();
                    if (parent.left==null) parent.left = node;
                    else parent.right = node;
                }
                i++;
            } else {
                String num = "";
                while (i<s.length() && ((s.charAt(i)>='0' && s.charAt(i)<='9') || s.charAt(i)=='-')) {
                    num+=s.charAt(i);
                    i++;
                }

                TreeNode node = new TreeNode(Integer.parseInt(num));
                stk.push(node);
            }
        }

        return stk.pop();
    }
}

Leetcode 297. 序列化和反序列化二叉树

上面两道题目的合并版，比起使用上述括号形式进行序列化编码，这道题目我们可以对于序列化的格式进行简化，对于缺失的左右叶子结点我们用NULL来表示，每一个结点以逗号隔开。

对于反序列化的步骤，由于序列化是以前序遍历的顺序，所以反序列化也利用前序遍历的顺序，每一次递归过程中进行如下操作：

1. 根据当前遍历的结点创建二叉树结点，并从列表中移除该结点
2. 向下遍历左右子树，得到左右子树
3. 将当前节点连接到左右子树，并返回当前节点

前序遍历的特性是根-左-右，是比较适合构建二叉树这类问题

代码如下：

public class Codec {
    StringBuilder str;
    // Encodes a tree to a single string.
    public String serialize(TreeNode root) {
        str = new StringBuilder();
        helper(root);

        return str.toString().substring(0, str.length()-1);
    }

    private void helper(TreeNode root) {
        if (root==null) {
            str.append("null,");
            return;
        }

        str.append(root.val+",");
        helper(root.left);
        helper(root.right);
    }

    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        List<String> nodes = new LinkedList<String>(Arrays.asList(data.split(",")));
        return deshelper(nodes);
    }

    private TreeNode deshelper(List<String> nodes) {
        if (nodes==null || nodes.size()==0) return null;

        if (nodes.get(0).equals("null")) {
            nodes.remove(0);
            return null;
        }

        TreeNode curr = new TreeNode(Integer.parseInt(nodes.get(0)));
        nodes.remove(0);
        curr.left = deshelper(nodes);
        curr.right = deshelper(nodes);

        return curr;
    }
}