Day2

Author: shivhare1996

src/Day2/ReverseLevelOrderTraversal.txt

@@ -0,0 +1,38 @@
+Problem Statement:
+Source: https://leetcode.com/problems/binary-tree-level-order-traversal-ii/
+
+Solution 1:
+
+Simply first find the Height of the tree.
+For each level -> (height to 1) find the nodes which are present at that level and add that in the list.
+Add each list of levels to desired allLevels List. It will be desired solution.
+
+Time Complexity O(n*2)
+Space Complexity O(n)
+
+
+I feel this solution is necessary to see, as it will teach you basic tree operations. How to calculate height, and overall get the feel of moving into binary tree in recursion.
+
+
+Solution 2:
+
+Statement is to find the Level Order Traversal but from bottom up.
+Do Level Order Traversal level by level and save each nodes of particular level in an Array. Finally when moving to other level, save this level to
+allLevel Array.
+
+How to Do this?
+
+1. Use queue to travel level by travel. Take a Queue and add it in queue.
+2. Now for every loop we will have nodes for that level. (Run the loop till that level via fetching size)
+3. Create an ArrayList for holding that level. Get the size of current queue and loop it until size > 0
+4. Take element one by one and add their children if exist to the queue.
+5. Add that node into that ArrayList which you have created for holding that level.
+6. Add this level array to AllLevels Arraylist which you have created.
+
+
+Now, you have Array of Array of all levels, from top to bottom order. Reverse the collection to get the desired result.
+
+Time Complexity O(n)
+Space Complexity O(n)
+
+/* Happy Coding */

src/Day2/Solution1.java

@@ -0,0 +1,48 @@
+package Day2;
+
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Date 02/07/2020
+ * @author Aman Shivhare
+ *
+ * Source: https://leetcode.com/problems/binary-tree-level-order-traversal-ii/
+ *
+ */
+
+public class Solution1 {
+
+    private static int height(TreeNode root){
+        if(root==null){
+            return 0;
+        }
+        return Math.max(height(root.left), height(root.right)) + 1;
+    }
+
+    private static void givenLevel(TreeNode node, int level, List<Integer> levelNodes){
+        if(node == null){
+            return;
+        }
+        if(level == 1){
+            levelNodes.add(node.val);
+            return;
+        }
+
+        givenLevel(node.left, level-1, levelNodes);
+        givenLevel(node.right, level-1, levelNodes);
+    }
+
+    public List<List<Integer>> levelOrderBottom(TreeNode root) {
+        int height = height(root);
+        List<List<Integer>> allLevels = new ArrayList<>();
+
+        for(int i = height; i>0; i--){
+            List<Integer> currentLevelNodes = new ArrayList<>();
+            givenLevel(root, i, currentLevelNodes);
+            allLevels.add(currentLevelNodes);
+        }
+        return  allLevels;
+    }
+}

src/Day2/Solution2.java

@@ -0,0 +1,39 @@
+package Day2;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+/**
+ * Date 02/07/2020
+ * @author Aman Shivhare
+ *
+ * Source: https://leetcode.com/problems/binary-tree-level-order-traversal-ii/
+ *
+ */
+
+
+public class Solution2 {
+    public List<List<Integer>> levelOrderBottom(TreeNode root) {
+
+        List<List<Integer>> allLevels = new ArrayList<>();
+        Queue<TreeNode> pipe = new LinkedList<>();
+        if(root!=null) pipe.add(root);
+        while(!pipe.isEmpty()){
+            int size = pipe.size();
+            List<Integer> level = new ArrayList<>();
+            while(size!=0){
+                TreeNode node = pipe.poll();
+                if(node.left != null) pipe.add(node.left);
+                if(node.right != null) pipe.add(node.right);
+                level.add(node.val);
+                size--;
+            }
+            allLevels.add(level);
+        }
+        Collections.reverse(allLevels);
+        return allLevels;
+    }
+}

src/Day2/TreeNode.java

@@ -0,0 +1,14 @@
+package Day2;
+
+public class TreeNode {
+    int val;
+    TreeNode left;
+    TreeNode right;
+    TreeNode() {}
+    TreeNode(int val) { this.val = val; }
+    TreeNode(int val, TreeNode left, TreeNode right) {
+        this.val = val;
+        this.left = left;
+        this.right = right;
+    }
+}