l力扣114. 二叉树展开为链表

114. 二叉树展开为链表

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

例如，给定二叉树

将其展开为：

 

 思路一：

先来一个前序遍历把所有结点存在一个列表中,然后遍历链表，把所有结点用右指针串起来

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public void flatten(TreeNode root) {
        if(root == null)
            return ;
        List<TreeNode> list = new ArrayList<>();
        TreeNode top = root;
        Stack<TreeNode> stack = new Stack<>();
        // 先来一个前序遍历把所有结点存在一个列表中
        while(!stack.empty() || top != null){
            while(top != null){
                list.add(top);
                stack.push(top);
                top = top.left;
            }
            top = stack.pop();
            top = top.right;
        }

        // 遍历链表，把所有结点用右指针串起来
        int n = list.size();
        for(int i = 0; i < n; i++){
            if(i > 0){
                list.get(i - 1).right = list.get(i);
            }
            list.get(i).left = null;
        }
    }
}

力扣测试：时间为2ms, 空间为39MB

复杂度分析：

时间复杂度：一次存，一次遍历，相当于遍历了两次二叉树，所以时间复杂度为O(n), n为节点个数

空间复杂度：列表的大小，所以为O(n)

 思路二：

1. 把当前结点的右子树挂到左子树最右边的结点上

2. 把左子树挂到右子树上、

3. 更新当前结点的右子树为新的当前结点，重复上面的操作，直到当前结点为空

class Solution {
    public void flatten(TreeNode root) {
        TreeNode cur = root;
        while(cur != null){
            // 如果左子树为空，直接进入下个结点
            if(cur.left == null){
                cur = cur.right;
            }else{
                // 如果左子树不为空，找到它最右边的结点
                TreeNode leftRight = cur.left;
                while(leftRight.right != null){
                    leftRight = leftRight.right;
                }
                // 将右子树挂到这个结点上
                leftRight.right = cur.right;

                // 将左子树挂到右子树的位置
                cur.right = cur.left;
                cur.left = null;

                // 更新cur指针
                cur = cur.right;
            }
        }
       
    }
}

力扣测试时间为：1ms, 空间为39.2mb

复杂度分析：

这个时间复杂度不太好判断，我觉得应该是O(nlogn),首先总体对每个结点必须访问一次，所以是O(n), 其次内层循环中每次都必须找到左子树最右边的结点，我觉得这个复杂度应该是O(logn)，所以我觉的时间复杂度是O(nlogn)

空间复杂度为O(1)

思路三：巧用后序遍历（速度最快）

1. 右、左、根的后序遍历，遍历结果为6->5->4->3->2->1

2. 使用p->right = pre, 即可把逆序编程正序，变为把 1->2->3->4->5->6，pre结点刚好是p结点的左结点，所以不用担心左结点会丢失，

class Solution {
    public void flatten(TreeNode root) {
        // 右、左、根的后序遍历，遍历结果为6->5->4->3->2->1
        // 使用p->right = pre, 即可把逆序编程正序，变为把 1->2->3->4->5->6，pre结点刚好是p结点的左结点，所以不用担心左结点会丢失，
        postTraversal(root);
    }
    public TreeNode pre = null;
    public void postTraversal(TreeNode p){
        if(p != null){
            postTraversal(p.right);
            postTraversal(p.left);
            p.right = pre;
            p.left = null;
            pre = p;
        }
    }
}

力扣测试时间为0ms, 空间为39.8MB

复杂度分析：

时间复杂度为：仅仅是一次后序遍历，所以复杂度为O(n）

空间复杂度：方法栈最大递归层数为树的高度，所以空间复杂度为O(n)

思路四：利用栈

借助一个栈，每次先把右子树压入栈，然后把左子树压入栈，这样每次左子树都会先弹栈，直接把根的右子树指向这个弹出的左子树，因为右子树已经被压入栈中了，所以右子树不会丢失

class Solution {
    public void flatten(TreeNode root) {
      Stack<TreeNode> stack = new Stack<TreeNode>();
      if(root != null){
          stack.push(root);
      }
      TreeNode pre = null;
      while(!stack.empty()){
          TreeNode top = stack.pop();
          if(top.right != null){
              stack.push(top.right);
          }
          if(top.left != null){
              stack.push(top.left);
          }
          // 直接把根的右子树指向这个弹出的左子树
          if(pre != null){
              pre.right = top;
              pre.left = null;
          }
            pre = top;
      }
    }
}

力扣测试时间为2ms, 空间为39.7MB

复杂度分析：

时间复杂度：对每个结点都出栈一次，所以时间复杂度为O(n)

空间复杂度：栈的大小即为空间的花费，这里栈同时存储的是同一层的结点，所以最坏情况下，当树只有两层时，空间复杂度为O(n/2),所以空间复杂度为O(n)

思路参考：

https://leetcode-cn.com/problems/flatten-binary-tree-to-linked-list/solution/xiang-xi-tong-su-de-si-lu-fen-xi-duo-jie-fa-by--26/