[LeetCode] Binary Tree Upside Down

Problem Description:

Given a binary tree where all the right nodes are either leaf nodes with a sibling (a left node that shares the same parent node) or empty, flip it upside down and turn it into a tree where the original right nodes turned into left leaf nodes. Return the new root.

For example:
Given a binary tree {1,2,3,4,5},

    1
   / 
  2   3
 / 
4   5

return the root of the binary tree [4,5,2,#,#,3,1].

   4
  / 
 5   2
    / 
   3   1  

---

This problem seems to be tricky at first glance. Well, let's analyze the above example carefully. We can immediately see that there is a reversed correspondence between the two trees, which are the 1 -> 2 -> 4 in the tree above and the 4 -> 2 -> 1 in the tree below. Moreover, for each node along the left path 1 -> 2 -> 4 in the original tree, its new left child is its original right sibling and its new right child is its original parent.

Now we can write down the following recursive code.

class Solution {
public:
    TreeNode* upsideDownBinaryTree(TreeNode* root) {
        return upsideDown(root, NULL, NULL);    // start from root
    }
private:
    TreeNode* upsideDown(TreeNode* node, TreeNode* parent, TreeNode* sibling) {
        if (!node) return parent;
        TreeNode* left = node -> left;          // old left child
        TreeNode* right = node -> right;        // old right child
        node -> left = sibling;                 // new left child is old right sibling
        node -> right = parent;                 // new right child is old parent
        return upsideDown(left, node, right);   // node is left's parent and right is left's sibling
    }
};

The above recursive code can be turned into the following iterative code easily.

class Solution {
public:
    TreeNode* upsideDownBinaryTree(TreeNode* root) {
        TreeNode* run = root;
        TreeNode* parent = NULL;
        TreeNode* sibling = NULL;
        while (run) {
            TreeNode* left = run -> left;   // old left child
            TreeNode* right = run -> right; // old right child
            run -> left = sibling;          // new left child is old right sibling
            run -> right = parent;          // new right child is old parent
            parent = run;
            run = left;
            sibling = right;
        }
        return parent;
    }
};