symmetric tree and complete-binary-tree-inserter java (#24)

Author: girishgr8

Java/complete-binary-tree-inserter.java

@@ -0,0 +1,64 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class CBTInserter {
+    TreeNode root;
+    Queue<TreeNode> q = new LinkedList<TreeNode>(); 
+    // This queue is a helper to reduce load on insert function.. 
+    public CBTInserter(TreeNode root) {
+        this.root = root;
+        Queue<TreeNode> temp = new LinkedList(q);
+        temp.add(root);
+        q.add(root);
+        // Prepare a queue for the for our insert function...
+        while(!temp.isEmpty()){
+            TreeNode t = temp.poll();
+            if(t.left!=null){
+                temp.add(t.left);
+                q.add(t.left);
+            }
+            if(t.right!=null){
+                temp.add(t.right);
+                q.add(t.right);
+            }
+        }
+    }
+    
+    
+    public int insert(int v) {
+        TreeNode n = new TreeNode(v);
+        n.left = n.right = null;
+        TreeNode parent = null;
+        // Add new node to the queue...
+        q.add(n);
+        while(true){
+            parent = q.peek();
+            // If the node's left is null then, insert there.
+            if(parent.left==null){
+                parent.left = n;
+                break;
+            }
+            // If the node's right is null then, insert there....
+            // Now this node can never become parent of new node, so remove it from the queue
+            if(parent.right==null){
+                parent.right = n;
+                q.poll();
+                break;
+            }
+            // else it means the node has left and right children which are not null... so remove it from queue.
+            q.poll();
+        }
+        // Return the parent's value to the caller function...
+        return parent.val;
+    }
+    
+    public TreeNode get_root() {
+        return root;
+    }
+}

Java/symmetric-tree.java

@@ -0,0 +1,34 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ * Runtime: 0 ms
+ * Memory Usage: 37.9 MB
+ */
+class Solution {
+    public boolean isSymmetric(TreeNode root) {
+	/* if root node of tree itself is null, then it's symmetric */
+        if(root==null)
+            return true;
+        return checkMirror(root.left, root.right);
+    }
+    public boolean checkMirror(TreeNode lt, TreeNode rt){
+	/* if root's left and root's right both are null, is then that subtree is symmetric */
+        if(lt==null && rt==null)
+            return true;
+
+	/* if root's left is null and root's right is not null and vice-versa, is then that subtree is not symmetric */
+        if((lt!=null && rt==null) || (lt==null && rt!=null))
+           return false;
+
+	/* check if left node's value matches with right node's value, and recursively check for their left and right subtrees */
+        if(lt.val==rt.val && checkMirror(lt.left,rt.right) && checkMirror(lt.right,rt.left))
+            return true;
+
+        return false;
+    }
+}

README.md

@@ -130,14 +130,16 @@ Check out ---> [Sample PR](https://github.com/codedecks-in/LeetCode-Solutions/pu
 
 ## Tree
 
-| #   | Title                                                                                             | Solution                                                   | Time      | Space     | Difficulty | Tag                             | Note |
-| --- | ------------------------------------------------------------------------------------------------- | ---------------------------------------------------------- | --------- | --------- | ---------- | ------------------------------- | ---- |
-| 094 | [Binary Tree Inorder Traversal](https://leetcode.com/problems/binary-tree-inorder-traversal/)     | [Java](./Java/binary-tree-inorder-traversal.java)          | _O(n)_    | _O(logn)_ | Medium     | Binary Tree, Stack, HashTable   |      |
-| 144 | [Binary Tree Preorder Traversal](https://leetcode.com/problems/binary-tree-preorder-traversal/)   | [Java](./Java/binary-tree-preorder-traversal.java)         | _O(n)_    | _O(logn)_ | Medium     | Binary Tree, Stack              |      |
-| 145 | [Binary Tree Postorder Traversal](https://leetcode.com/problems/binary-tree-postorder-traversal/) | [Java](./Java/binary-tree-postorder-traversal.java)        | _O(n)_    | _O(logn)_ | Hard       | Binary Tree, Stack              |      |
-| 103 | [ZigZag Level Order](https://leetcode.com/problems/binary-tree-zigzag-level-order-traversal/)     | [JavaScript](./JavaScript/Binary-Tree-ZigZag-Traversal.js) | _O(n)_    | _O(n)_    | Medium     | Binary Tree                     |      |
-| 129 | [Sum Root to Leaf Numbers](https://leetcode.com/problems/sum-root-to-leaf-numbers/)               | [Java](./Java/sum-root-to-leaf-numbers.java)               | _O(n)_    | _O(logn)_ | Medium     | Binary Tree, Depth First Search |      |
-| 307 | [Range Sum Query - Mutable](https://leetcode.com/problems/range-sum-query-mutable/)               | [Java](./Java/Range-Sum-Query-Mutable.java)                | _O(logn)_ | _O(n)_    | Medium     | Segment Tree                    |      |
+| #   | Title                                                                                             | Solution                                                   | Time      | Space     | Difficulty | Tag                                            | Note |
+| --- | ------------------------------------------------------------------------------------------------- | ---------------------------------------------------------- | --------- | --------- | ---------- | ---------------------------------------------- | ---- |
+| 094 | [Binary Tree Inorder Traversal](https://leetcode.com/problems/binary-tree-inorder-traversal/)     | [Java](./Java/binary-tree-inorder-traversal.java)          | _O(n)_    | _O(logn)_ | Medium     | Binary Tree, Stack, HashTable                  |      |
+| 101 | [Symmetric Tree](https://leetcode.com/problems/symmetric-tree/)                                   | [Java](./Java/symmetric-tree.java)                         | _O(n)_    | _O(n)_    | Easy       | Tree, Breadth-first Search, Depth-first Search |      |
+| 144 | [Binary Tree Preorder Traversal](https://leetcode.com/problems/binary-tree-preorder-traversal/)   | [Java](./Java/binary-tree-preorder-traversal.java)         | _O(n)_    | _O(logn)_ | Medium     | Binary Tree, Stack                             |      |
+| 145 | [Binary Tree Postorder Traversal](https://leetcode.com/problems/binary-tree-postorder-traversal/) | [Java](./Java/binary-tree-postorder-traversal.java)        | _O(n)_    | _O(logn)_ | Hard       | Binary Tree, Stack                             |      |
+| 103 | [ZigZag Level Order](https://leetcode.com/problems/binary-tree-zigzag-level-order-traversal/)     | [JavaScript](./JavaScript/Binary-Tree-ZigZag-Traversal.js) | _O(n)_    | _O(n)_    | Medium     | Binary Tree                                    |      |
+| 129 | [Sum Root to Leaf Numbers](https://leetcode.com/problems/sum-root-to-leaf-numbers/)               | [Java](./Java/sum-root-to-leaf-numbers.java)               | _O(n)_    | _O(logn)_ | Medium     | Binary Tree, Depth First Search                |      |
+| 307 | [Range Sum Query - Mutable](https://leetcode.com/problems/range-sum-query-mutable/)               | [Java](./Java/Range-Sum-Query-Mutable.java)                | _O(logn)_ | _O(n)_    | Medium     | Segment Tree                                   |      |
+| 919 | [Complete Binary Tree Inserter](https://leetcode.com/problems/complete-binary-tree-inserter/)     | [Java](./Java/complete-binary-tree-inserter.java)          | _O(n)_    | _O(n)_    | Medium     | Tree                                           |      |
 
 <br/>
 <div align="right">