leetcode *114. 二叉树展开为链表（在哪见过）

【题目】*114. 二叉树展开为链表

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

例如，给定二叉树

    1
   / \
  2   5
 / \   \
3   4   6
将其展开为：

1
 \
  2
   \
    3
     \
      4
       \
        5
         \
          6

【解题思路1】原地操作

递归：先把左右子树分别展开，然后将左子树插入到右子树上。注意将左孩子清空。

/**
 * 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 {
    
    
    TreeNode cur;
    public void flatten(TreeNode root) {
    
    
        helper(root);
    }
    public TreeNode helper(TreeNode root){
    
    
        if(root==null){
    
    
            return null;
        }
        TreeNode temp_left=root.left;
        TreeNode temp_right=root.right;
        cur=root;
        cur.left=null;
        cur.right=helper(temp_left);
        cur.right=helper(temp_right);
        return root;
    }
}

非递归：寻找前驱节点

class Solution {
    
    
    public void flatten(TreeNode root) {
    
    
        TreeNode curr = root;
        while (curr != null) {
    
    
            if (curr.left != null) {
    
    
                TreeNode next = curr.left;
                TreeNode predecessor = next;
                while (predecessor.right != null) {
    
    
                    predecessor = predecessor.right;
                }
                predecessor.right = curr.right;
                curr.left = null;
                curr.right = next;
            }
            curr = curr.right;
        }
    }
}

【解题思路2】前序遍历

class Solution {
    
    
    public void flatten(TreeNode root) {
    
    
        List<TreeNode> list = new ArrayList<TreeNode>();
        preorderTraversal(root, list);
        int size = list.size();
        for (int i = 1; i < size; i++) {
    
    
            TreeNode prev = list.get(i - 1), curr = list.get(i);
            prev.left = null;
            prev.right = curr;
        }
    }

    public void preorderTraversal(TreeNode root, List<TreeNode> list) {
    
    
        if (root != null) {
    
    
            list.add(root);
            preorderTraversal(root.left, list);
            preorderTraversal(root.right, list);
        }
    }
}

class Solution {
    
    
    public void flatten(TreeNode root) {
    
    
        List<TreeNode> list = new ArrayList<TreeNode>();
        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        TreeNode node = root;
        while (node != null || !stack.isEmpty()) {
    
    
            while (node != null) {
    
    
                list.add(node);
                stack.push(node);
                node = node.left;
            }
            node = stack.pop();
            node = node.right;
        }
        int size = list.size();
        for (int i = 1; i < size; i++) {
    
    
            TreeNode prev = list.get(i - 1), curr = list.get(i);
            prev.left = null;
            prev.right = curr;
        }
    }
}