[leet code] 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

click to show hints.

Hints:

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

===============

Analysis:

Original thought was using recursive approach.  Then I found that in the flattened tree, we need to add the whole left sub-tree in the current node's right, then add the original right sub-tree.  In another world, I should handle not only node.next, but also node.next.next in one recursive call, which is complicated (for me).

Alternatively, if we use stack, we can save current node's left child and right child into the stack in 1 iteration.  Accordingly, in each iteration, we need only handle one "right child" in the flattened tree, which is to set current node as the right child as it's previous node.

/**
 * 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) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        if(root==null) return;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);
        TreeNode pre = null;
        
        while(!stack.isEmpty()){
            TreeNode curr = stack.pop();
            if(curr.right!=null) stack.push(curr.right);
            if(curr.left!=null) stack.push(curr.left);
            curr.left = null;
            if(curr!=root) pre.right = curr;
            pre = curr;
        }
    }
}