二叉树展开为链表

题目

给定一个二叉树，原地将它展开为一个单链表。

例如，给定二叉树

将其展开为：

题解一

解法一可以发现展开的顺序其实就是二叉树的先序遍历。算法和 94 题中序遍历的 Morris 算法有些神似，我们需要两步完成这道题。

将左子树插入到右子树的地方
将原来的右子树接到左子树的最右边节点
考虑新的右子树的根节点，一直重复上边的过程，直到新的右子树为 null

public void flatten(TreeNode root) {
    while (root != null) { 
        //左子树为 null，直接考虑下一个节点
        if (root.left == null) {
            root = root.right;
        } else {
            // 找左子树最右边的节点
            TreeNode pre = root.left;
            while (pre.right != null) {
                pre = pre.right;
            } 
            //将原来的右子树接到左子树的最右边节点
            pre.right = root.right;
            // 将左子树插入到右子树的地方
            root.right = root.left;
            root.left = null;
            // 考虑下一个节点
            root = root.right;
        }
    }
}

解法二

如果用先序遍历的话，会丢失掉右孩子，除了用后序遍历，还有没有其他的方法避免这个问题。在 Discuss 又发现了一种解法。为了更好的控制算法，所以我们用先序遍历迭代的形式，正常的先序遍历代码如下，

public static void preOrderStack(TreeNode root) {
    if (root == null) { 
        return;
    }
    Stack<TreeNode> s = new Stack<TreeNode>();
    while (root != null || !s.isEmpty()) {
        while (root != null) {
            System.out.println(root.val);
            s.push(root);
            root = root.left;
        }
        root = s.pop();
        root = root.right;
    }
}
##解法三
看题意顺序明显是先序遍历，二叉树的深度遍历本来只用递，没有用到归，所以我判定把归利用起来，肯定是能够解题的。
一句话思路就是先序遍历，如果走到最左边，则把此节点指针返回到有右节点的位置，把该右节点挪到最左边节点的左边，继续递归即可。
需要注意的是，一定要注意将右节点接在左叶子节点之后记得把右节点清空。
还有如果将nullLeftNode左叶子节点指针改为全局变量会省事儿很多，不用归，直接递，但是考虑到原地展开，就没有用到外部存储空间。
本解法时间复杂度O(n)，因为每一个节点都遍历了一遍；空间复杂度O(1),只有两个临时节点。

还有一种特殊的先序遍历，提前将右孩子保存到栈中，我们利用这种遍历方式就可以防止右孩子的丢失了。由于栈是先进后出，所以我们先将右节点入栈。

public static void preOrderStack(TreeNode root) {
    if (root == null){
        return;
    }
    Stack<TreeNode> s = new Stack<TreeNode>();
    s.push(root);
    while (!s.isEmpty()) {
        TreeNode temp = s.pop();
        System.out.println(temp.val);
        if (temp.right != null){
            s.push(temp.right);
        }
        if (temp.left != null){
            s.push(temp.left);
        }
    }
}

题解三

先序遍历，二叉树的深度遍历本来只用递，没有用到归，所以我判定把归利用起来，肯定是能够解题的。一句话思路就是先序遍历，如果走到最左边，则把此节点指针返回到有右节点的位置，把该右节点挪到最左边节点的左边，继续递归即可。需要注意的是，一定要注意将右节点接在左叶子节点之后记得把右节点清空。还有如果将nullLeftNode左叶子节点指针改为全局变量会省事儿很多，不用归，直接递，但是考虑到原地展开，就没有用到外部存储空间。本解法时间复杂度O(n)，因为每一个节点都遍历了一遍；空间复杂度O(1),只有两个临时节点。

class Solution {
    public void flatten(TreeNode root) {
        if(root==null){
            return ;
        }
        //先将二叉树转换成左展开链表
        flattenHelper(root);
        //再将左展开转换成右展开链表
        TreeNode tempNode =root;
        while(tempNode.left!=null){
            tempNode.right = tempNode.left;
            tempNode.left = null;
            tempNode= tempNode.right;
        }
    }
    private TreeNode flattenHelper(TreeNode root){
        //如果左右节点都为空则返回当前节点，也就是最后的左边的节点；
        if(root.left==null&&root.right==null){
            return root;
        }
        //如果左为空右不为空，则把右边的移到左边，然后继续递归左边的；
        if(root.left==null&&root.right!=null){
            root.left=root.right;
            root.right=null;
            return flattenHelper(root.left);
        }
        //如果左不为空右为空则直接递归左边的；
        if(root.left!=null&&root.right==null){
            return flattenHelper(root.left);
        }
        //如果左右都不为空则把左边归过来的末节点的左节点赋值为当前节点的右节点，然后继续递归；
            TreeNode nullLeftNode= flattenHelper(root.left);
            nullLeftNode.left = root.right;
            root.right=null;
            return flattenHelper(nullLeftNode.left);
    }
}