add 662

Author: fishercoder1534

README.md

@@ -23,6 +23,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |  #  |      Title     |   Solutions   | Time          | Space         | Difficulty  | Tag          | Notes
 |-----|----------------|---------------|---------------|---------------|-------------|--------------|-----
 |663|[Equal Tree Partition](https://leetcode.com/problems/equal-tree-partition/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_663.java) | O(n) | O(n) | Medium | Tree
+|662|[Maximum Width of Binary Tree](https://leetcode.com/problems/maximum-width-of-binary-tree/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_662.java) | O(n) | O(k) | Medium | BFS, DFS
 |661|[Image Smoother](https://leetcode.com/problems/image-smoother/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_661.java) | O(m*n) | O(1) | Easy | Array 
 |660|[Remove 9](https://leetcode.com/problems/remove-9/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_660.java) | O(n) | O(1) | Hard | Math
 |659|[Split Array into Consecutive Subsequences](https://leetcode.com/problems/split-array-into-consecutive-subsequences/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_659.java) | O(n) | O(n) | Medium | HashMap

src/main/java/com/fishercoder/solutions/_662.java

@@ -0,0 +1,98 @@
+package com.fishercoder.solutions;
+
+import com.fishercoder.common.classes.TreeNode;
+
+import java.util.*;
+
+/**
+ * 662. Maximum Width of Binary Tree
+ *
+ * Given a binary tree, write a function to get the maximum width of the given tree.
+ * The width of a tree is the maximum width among all levels.
+ * The binary tree has the same structure as a full binary tree, but some nodes are null.
+ * The width of one level is defined as the length between the end-nodes
+ * (the leftmost and right most non-null nodes in the level,
+ * where the null nodes between the end-nodes are also counted into the length calculation.
+
+ Example 1:
+ Input:
+
+      1
+    /   \
+   3     2
+  / \     \
+ 5   3     9
+
+ Output: 4
+ Explanation: The maximum width existing in the third level with the length 4 (5,3,null,9).
+
+ Example 2:
+ Input:
+
+     1
+    /
+   3
+  / \
+ 5   3
+
+ Output: 2
+ Explanation: The maximum width existing in the third level with the length 2 (5,3).
+
+ Example 3:
+ Input:
+
+     1
+    / \
+   3   2
+  /
+ 5
+
+ Output: 2
+ Explanation: The maximum width existing in the second level with the length 2 (3,2).
+ Example 4:
+ Input:
+
+       1
+      / \
+     3   2
+    /     \
+   5       9
+  /         \
+ 6           7
+
+ Output: 8
+ Explanation:The maximum width existing in the fourth level with the length 8 (6,null,null,null,null,null,null,7).
+
+ Note: Answer will in the range of 32-bit signed integer.
+ */
+public class _662 {
+    public int widthOfBinaryTree(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+        Queue<Map.Entry<TreeNode, Integer>> queue = new LinkedList<>();
+        queue.offer(new AbstractMap.SimpleEntry<>(root, 1));
+        int max = 1;
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            List<Map.Entry<TreeNode, Integer>> list = new ArrayList<>();
+            for (int i = 0; i < size; i++) {
+                Map.Entry<TreeNode, Integer> curr = queue.poll();
+                if (curr.getKey().left != null) {
+                    Map.Entry<TreeNode, Integer> newEntry = new AbstractMap.SimpleEntry<>(curr.getKey().left, curr.getValue() * 2 - 1);
+                    queue.offer(newEntry);
+                    list.add(newEntry);
+                }
+                if (curr.getKey().right != null) {
+                    Map.Entry<TreeNode, Integer> newEntry = new AbstractMap.SimpleEntry<>(curr.getKey().right, curr.getValue() * 2);
+                    queue.offer(newEntry);
+                    list.add(newEntry);
+                }
+            }
+            if (list.size() > 1) {
+                max = Math.max(list.get(list.size() - 1).getValue() - list.get(0).getValue() + 1, max);
+            }
+        }
+        return max;
+    }
+}

src/test/java/com/fishercoder/_662Test.java

@@ -0,0 +1,60 @@
+package com.fishercoder;
+
+import com.fishercoder.common.classes.TreeNode;
+import com.fishercoder.common.utils.TreeUtils;
+import com.fishercoder.solutions._662;
+import org.junit.BeforeClass;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import java.util.Arrays;
+
+import static junit.framework.TestCase.assertEquals;
+
+public class _662Test {
+    private static _662 test;
+    private static TreeNode root;
+    private static int expected;
+
+    @BeforeClass
+    public static void setup(){
+        test = new _662();
+    }
+
+    @Test
+    public void test1(){
+        root = TreeUtils.constructBinaryTree(Arrays.asList(1,3,2,5,3,null,9));
+        expected = 4;
+        assertEquals(expected, test.widthOfBinaryTree(root));
+    }
+
+    @Test
+    public void test2(){
+        root = TreeUtils.constructBinaryTree(Arrays.asList(1,3,null, 5 ,3));
+        expected = 2;
+        assertEquals(expected, test.widthOfBinaryTree(root));
+    }
+
+    @Test
+    public void test3(){
+        root = TreeUtils.constructBinaryTree(Arrays.asList(1,3,2,5));
+        expected = 2;
+        assertEquals(expected, test.widthOfBinaryTree(root));
+    }
+
+    @Test
+    @Ignore
+    /**TODO: need to figure out how to pass in the input for the 4th example on Leetcode*/
+    public void test4(){
+        root = TreeUtils.constructBinaryTree(Arrays.asList(1,3,2,5,null,null,9,6,null,null,null,null,null,null,7));
+        expected = 8;
+        assertEquals(expected, test.widthOfBinaryTree(root));
+    }
+
+    @Test
+    public void test5(){
+        root = TreeUtils.constructBinaryTree(Arrays.asList(1));
+        expected = 1;
+        assertEquals(expected, test.widthOfBinaryTree(root));
+    }
+}