binary tree upside down: done

Author: rampatra

src/main/java/com/leetcode/trees/BinaryTreeUpsideDown.java

@@ -0,0 +1,207 @@
+package com.leetcode.trees;
+
+import java.util.Stack;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+/**
+ * Level: Medium
+ * Problem Link: https://leetcode.com/problems/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.
+ *
+ * Example:
+ * Input: [1,2,3,4,5]
+ *
+ *     1
+ *    / \
+ *   2   3
+ *  / \
+ * 4   5
+ *
+ * Output: return the root of the binary tree [4,5,2,#,#,3,1]
+ *
+ *    4
+ *   / \
+ *  5   2
+ *     / \
+ *    3   1
+ *
+ * Clarification:
+ * Confused what [4,5,2,#,#,3,1] means? Read more below on how binary tree is serialized on OJ. The serialization of
+ * a binary tree follows a level order traversal, where '#' signifies a path terminator where no node exists below.
+ *
+ * Here's an example:
+ *
+ *    1
+ *   / \
+ *  2   3
+ *     /
+ *    4
+ *     \
+ *      5
+ *
+ * The above binary tree is serialized as [1,2,3,#,#,4,#,#,5].
+ *
+ * @author rampatra
+ * @since 2019-08-04
+ */
+public class BinaryTreeUpsideDown {
+
+    /**
+     * The solution is simple, every node (except the root) on the left of the tree would have its parent's right child
+     * as it's left child and parent as its right child. That's all you have to do to flip the tree upside down.
+     *
+     * Time Complexity: O(h)
+     * Space Complexity: O(h)
+     * where,
+     * h = height of the tree
+     *
+     * Runtime: <a href="https://leetcode.com/submissions/detail/248816514/">1 ms</a>.
+     *
+     * @param root
+     * @return
+     */
+    public static TreeNode upsideDownBinaryTreeUsingStack(TreeNode root) {
+        if (root == null) return null;
+
+        TreeNode curr = root;
+        TreeNode currParent;
+        TreeNode newRoot = null;
+
+        // using stack to keep track of the parent node
+        Stack<TreeNode> stack = new Stack<>();
+
+        while (curr != null) {
+            stack.add(curr);
+            curr = curr.left;
+        }
+
+        while (!stack.empty()) {
+            curr = stack.pop();
+            currParent = stack.empty() ? null : stack.peek();
+
+            if (newRoot == null) newRoot = curr;
+
+            if (currParent != null) {
+                curr.left = currParent.right;
+                curr.right = currParent;
+            } else {
+                curr.left = null;
+                curr.right = null;
+            }
+        }
+
+        return newRoot;
+    }
+
+    /**
+     * The solution is simple, every node (except the root) on the left of the tree would have its parent's right child
+     * as it's left child and parent as its right child. That's all you have to do to flip the tree upside down.
+     *
+     * Time Complexity: O(h)
+     * Space Complexity: O(h)
+     * where,
+     * h = height of the tree
+     *
+     * Runtime: <a href="https://leetcode.com/submissions/detail/248821826/">0 ms</a>.
+     *
+     * @param node
+     * @return
+     */
+    public static TreeNode upsideDownBinaryTree(TreeNode node) {
+        if (node == null || node.left == null) return node;
+
+        // go to the last node on the extreme left branch
+        TreeNode newRoot = upsideDownBinaryTree(node.left);
+
+        // do the node changes as you backtrack
+        node.left.left = node.right;
+        node.left.right = node;
+
+        // clean up
+        node.left = null;
+        node.right = null;
+
+        return newRoot;
+    }
+
+    public static void main(String[] args) {
+        /*
+            Binary Tree
+
+                1
+               / \
+              2   3
+             / \
+            4   5
+         */
+        TreeNode tree = new TreeNode(1);
+        tree.left = new TreeNode(2);
+        tree.right = new TreeNode(3);
+        tree.left.left = new TreeNode(4);
+        tree.left.right = new TreeNode(5);
+
+        /*
+            Upside Down Binary Tree
+
+               4
+              / \
+             5   2
+                / \
+               3   1
+         */
+        TreeNode upsideDownTree = upsideDownBinaryTreeUsingStack(tree);
+        assertEquals(4, upsideDownTree.val);
+        assertEquals(5, upsideDownTree.left.val);
+        assertEquals(2, upsideDownTree.right.val);
+        assertEquals(1, upsideDownTree.right.right.val);
+        assertEquals(3, upsideDownTree.right.left.val);
+        assertNull(upsideDownTree.right.right.left);
+        assertNull(upsideDownTree.right.right.right);
+
+
+
+        /******************************
+         *
+         * Test for the recursive method
+         *
+         ******************************/
+
+        /*
+            Binary Tree
+
+                1
+               / \
+              2   3
+             / \
+            4   5
+         */
+        tree = new TreeNode(1);
+        tree.left = new TreeNode(2);
+        tree.right = new TreeNode(3);
+        tree.left.left = new TreeNode(4);
+        tree.left.right = new TreeNode(5);
+
+        /*
+            Upside Down Binary Tree
+
+               4
+              / \
+             5   2
+                / \
+               3   1
+         */
+        upsideDownTree = upsideDownBinaryTree(tree);
+        assertEquals(4, upsideDownTree.val);
+        assertEquals(5, upsideDownTree.left.val);
+        assertEquals(2, upsideDownTree.right.val);
+        assertEquals(1, upsideDownTree.right.right.val);
+        assertEquals(3, upsideDownTree.right.left.val);
+        assertNull(upsideDownTree.right.right.right);
+        assertNull(upsideDownTree.right.right.left);
+    }
+}