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

栈法

复杂度

时间 O(N) 空间 O(N)

思路

对于一个根节点，我们将它的右子树压进一个栈中，然后将它的左子树放到右边来。如果该节点没有左子树，说明该节点是某个左子树的最后一个节点，我们这时候把栈中最近的右子树pop出来接到它的右边。

代码

public class Solution {
    public void flatten(TreeNode root) {
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode p = root;
        while(p != null || !stack.empty()){
            // 如果有右子树，先压入栈，等待遇到当前节点左子树尽头的时候再pop出来
            if(p.right != null){
                stack.push(p.right);
            }
            // 如果存在左子树，将它放到右边来
            if(p.left != null){
                p.right = p.left;
                p.left = null;
            // 否则，说明是某个左子树的尽头，就将最近的右子树接到右边来
            }else if(!stack.empty()){
                TreeNode temp = stack.pop();
                p.right=temp;
            }
            // 移动到下一个待flat节点
            p = p.right;
        }
    }
}

2018/2

class Solution:
    def flatten(self, root):
        """
        :type root: TreeNode
        :rtype: void Do not return anything, modify root in-place instead.
        """
        stack = []
        currentNode = root
        while currentNode is not None:
            if currentNode.right is not None:
                stack.append(currentNode.right)
            if currentNode.left is not None:
                currentNode.right = currentNode.left
                currentNode.left = None
            elif stack:
                currentNode.right = stack.pop()
            currentNode = currentNode.right

2018/10

func flatten(root *TreeNode) {
    if root == nil {
        return
    }
    stack := []*TreeNode{root}
    curr := &TreeNode{0, nil, nil}
    for len(stack) != 0 {
        top := stack[len(stack)-1]
        stack = stack[:len(stack)-1]
        // DFS from left to right, push right to the stack first
        if top.Right != nil {
            stack = append(stack, top.Right)
        }
        // push left to the stack
        if top.Left != nil {
            stack = append(stack, top.Left)
        }
        // put top to curr's right and clear curr's left
        curr.Left = nil
        curr.Right = top
        // move on to the next
        curr = curr.Right
    }
}

链接左右子树法

复杂度

时间 O(N) 空间 O(1)

思路

如果我们将根节点的右子树接到左子树最后一个节点（就是左子树尽可能靠右下的节点）的右边，那我们可以确定的是，该根节点是已经flat的了。执行完该链接操作，根节点就只有右子树了，这样我们再移动到右子树的根节点，反复执行同样的操作，每次保证一个节点被flat。

代码

public class Solution {
    public void flatten(TreeNode root) {
        while(root != null){
            // 当存在左子树时，说明该节点还没被flat
            if(root.left != null){
                // 找到左子树最后一个节点
                TreeNode endOfLeftSubTree = root.left;
                while(endOfLeftSubTree.right != null){
                    endOfLeftSubTree = endOfLeftSubTree.right;
                }
                // 将右子树加到左子树最后一个节点的右边
                endOfLeftSubTree.right = root.right;
                // 将左子树放到当前节点的右边
                root.right = root.left;
                // 将当前节点左边置空
                root.left = null;
            }
            // 移动到下一个待flat的节点
            root = root.right;
        }
    }
}