Flatten Binary Tree to Linked List

Given a binary tree, flatten it to a linked list in-place.

For example,
Given

         1
        / 
       2   5
      /    
     3   4   6

The flattened tree should look like:

   1
    
     2
      
       3
        
         4
          
           5
            
             6

Hints:

If you notice carefully in the flattened tree, each node's right child points to the next node of a pre-order traversal.

这里我直接新建了一个tree。代替原来的。注意必须在最后修改root的指针指向的地方，而不是修改root。（值的传递）

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public void flatten(TreeNode root) {
        // Start typing your Java solution below
        // DO NOT write main() function
        if(root == null) return;
        TreeNode r = new TreeNode(root.val);
        Stack<TreeNode> s = new Stack<TreeNode>();
        s.push(root);
        TreeNode ts = r;
        while(s.empty() != true){
            TreeNode cur = s.pop();
            if(cur.right != null)
            s.push(cur.right);
            if(cur.left != null)
            s.push(cur.left);
            ts.right = new TreeNode(cur.val);
            ts = ts.right;
        }
        root.right = r.right.right;
        root.left = null;
    }
}

方法二： 直接修改原来的树。

We can notice that in the flattened tree, each sub node is the successor node of it’s parent node in the pre-order of the original tree. So, we can do it in recursive manner, following the steps below:
1.if root is NULL return;
2.flatten the left sub tree of root, if there is left sub-tree;
3.flatten the right sub-tree of root, if has;
4.if root has no left sub-tree, then root is flattened already, just return;
5.we need to merge the left sub-tree with the right sub-tree, by concatenate the right sub-tree to the last node in left sub-tree.
5.1.find the last node in the left sub tree, as the left is flattened, this is easy.
5.2.concatenate the right sub-tree to this node’s right child.
5.3.move the left sub-tree to the right for root.
5.4.clear the left child of root.
6.done.

A much simpler solution.
public class Solution {
public void flatten(TreeNode root) {
// Start typing your Java solution below
// DO NOT write main() function
preOrder(root, null);
return;
}

public static TreeNode preOrder(TreeNode root, TreeNode prev) {
if (root == null) return null;

TreeNode leftNode = root.left;
TreeNode rightNode = root.right;

if (prev == null) {
prev = root;
} else {
prev.left = null;
prev.right = root;
prev = root;
}

if (leftNode != null) {
prev = preOrder(leftNode, prev);
}
if (rightNode != null) {
prev = preOrder(rightNode, prev);
}
return prev;
}
}

 第二遍：

public class Solution {
    public void flatten(TreeNode root) {
        // Start typing your Java solution below
        // DO NOT write main() function
        if(root == null) return;
        LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
        TreeNode result = null;
        queue.push(root);
        while(queue.size() != 0){
            TreeNode tmp = queue.pop();
            if(tmp.right != null) queue.push(tmp.right);
            if(tmp.left != null) queue.push(tmp.left);
            if(result == null) result = tmp;
            else{
                result.right = tmp;
                result = result.right;
            }
            result.left = result.right = null;
        }
    }
}

采用stack做preorder search。 存一个current list的tail指针， 更新这个指针。