LeetCode

Flatten Binary Tree to Linked List

2014.2.13 01:03

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.

Solution:

　　The easy way to solve this problem is by postorder traversal of this tree:

　　　　1. Flatten the left subtree.

　　　　2. Flatten the right subtree.

　　　　3. Connect the root->left subtree->right subtree.

　　When the left and right subtrees are both flattened, piece them together with the root node to make a complete left-skewed tree.

　　When connecting them, we have to know the boundary nodes of each part. This can be done by passing two parameters as the left and right borders of the tree. Their values are updated as the recursions are performed.

　　Total time complexity is O(n). Space complexity is O(n) as well.

　　As for the non-recursive solution of this problem, well...maybe later.

Accepted code:

// 4WA, 1AC, not so easy.
/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    void flatten(TreeNode *root) {
        if (root == nullptr) {
            return;
        }
        
        if (root->left == nullptr && root->right == nullptr) {
            return;
        }
        
        TreeNode *left_most, *right_most;
        
        flattenRecursive(root, left_most, right_most);
    }
private:
    void flattenRecursive(TreeNode *root, TreeNode *&left_most, TreeNode *&right_most) {
        if (root->left == nullptr && root->right == nullptr) {
            left_most = root;
            right_most = root;
            return;
        }
        
        TreeNode *ll, *lr, *rl, *rr;
        
        if (root->left != nullptr) {
            flattenRecursive(root->left, ll, lr);
        } else {
            ll = lr = root;
        }
        if (root->right != nullptr) {
            flattenRecursive(root->right, rl, rr);
        } else {
            rl = rr = root;
        }
        
        TreeNode *ptr;
        root->left = nullptr;
        if (ll != root) {
            root->right = ll;
            lr->right = nullptr;
            ptr = lr;
        } else {
            ptr = root;
        }
        if (rr != root) {
            ptr->right = rl;
        }
        
        left_most = root;
        if (rr != root) {
            right_most = rr;
        } else {
            right_most = lr;
        }
    }
};