add 987

Author: fishercoder1534

README.md

@@ -50,6 +50,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |994|[Rotting Oranges](https://leetcode.com/problems/rotting-oranges/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_994.java) | O(m*2*n*2) | O(m*n) | |Easy| BFS
 |993|[Cousins in Binary Tree](https://leetcode.com/problems/cousins-in-binary-tree/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_993.java) | O(n) | O(m) (m is length of the nodes that has the max number of nodes on the same level) | |Easy| Tree, BFS
 |989|[Add to Array-Form of Integer](https://leetcode.com/problems/add-to-array-form-of-integer/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_989.java) | O(max(N, logk)) | O(max(N, logk)) | |Easy| Array
+|987|[Vertical Order Traversal of a Binary Tree](https://leetcode.com/problems/vertical-order-traversal-of-a-binary-tree/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_987.java) | O(n) | O(n) | |Medium| Recursion
 |985|[Sum of Even Numbers After Queries](https://leetcode.com/problems/sum-of-even-numbers-after-queries/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_985.java) | O(n) | O(n) | |Easy| Array
 |979|[Distribute Coins in Binary Tree](https://leetcode.com/problems/distribute-coins-in-binary-tree/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_979.java) | O(n) | O(1) | |Medium| Recursion
 |977|[Squares of a Sorted Array](https://leetcode.com/problems/squares-of-a-sorted-array/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_977.java) | O(nlogn) | O(1) | |Easy| Array

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

@@ -0,0 +1,86 @@
+package com.fishercoder.solutions;
+
+import com.fishercoder.common.classes.TreeNode;
+
+import java.util.*;
+
+/**
+ * 987. Vertical Order Traversal of a Binary Tree
+ *
+ * Given a binary tree, return the vertical order traversal of its nodes values.
+ * For each node at position (X, Y), its left and right children respectively will be at positions (X-1, Y-1) and (X+1, Y-1).
+ * Running a vertical line from X = -infinity to X = +infinity, whenever the vertical line touches some nodes, we report the values of the nodes in order from top to bottom (decreasing Y coordinates).
+ * If two nodes have the same position, then the value of the node that is reported first is the value that is smaller.
+ * Return an list of non-empty reports in order of X coordinate.  Every report will have a list of values of nodes.
+ *
+ * Example 1:
+ *
+ *        3
+ *       / \
+ *      9  20
+ *        /  \
+ *       15  7
+ *
+ * Input: [3,9,20,null,null,15,7]
+ * Output: [[9],[3,15],[20],[7]]
+ * Explanation:
+ * Without loss of generality, we can assume the root node is at position (0, 0):
+ * Then, the node with value 9 occurs at position (-1, -1);
+ * The nodes with values 3 and 15 occur at positions (0, 0) and (0, -2);
+ * The node with value 20 occurs at position (1, -1);
+ * The node with value 7 occurs at position (2, -2).
+ *
+ *
+ * Example 2:
+ *
+ *       1
+ *      / \
+ *     2   3
+ *    / \ / \
+ *   4  5 6 7
+ *
+ * Input: [1,2,3,4,5,6,7]
+ * Output: [[4],[2],[1,5,6],[3],[7]]
+ * Explanation:
+ * The node with value 5 and the node with value 6 have the same position according to the given scheme.
+ * However, in the report "[1,5,6]", the node value of 5 comes first since 5 is smaller than 6.
+ *
+ * Note:
+ *
+ * The tree will have between 1 and 1000 nodes.
+ * Each node's value will be between 0 and 1000.
+ * */
+public class _987 {
+    public static class Solution1 {
+        /**credit: https://leetcode.com/problems/vertical-order-traversal-of-a-binary-tree/discuss/231148/Java-TreeMap-Solution*/
+        public List<List<Integer>> verticalTraversal(TreeNode root) {
+            TreeMap<Integer, TreeMap<Integer, PriorityQueue<Integer>>> map = new TreeMap<>();
+            dfs(root, 0, 0, map);
+            List<List<Integer>> list = new ArrayList<>();
+            for (TreeMap<Integer, PriorityQueue<Integer>> ys : map.values()) {
+                list.add(new ArrayList<>());
+                for (PriorityQueue<Integer> nodes : ys.values()) {
+                    while (!nodes.isEmpty()) {
+                        list.get(list.size() - 1).add(nodes.poll());
+                    }
+                }
+            }
+            return list;
+        }
+
+        private void dfs(TreeNode root, int x, int y, TreeMap<Integer, TreeMap<Integer, PriorityQueue<Integer>>> map) {
+            if (root == null) {
+                return;
+            }
+            if (!map.containsKey(x)) {
+                map.put(x, new TreeMap<>());
+            }
+            if (!map.get(x).containsKey(y)) {
+                map.get(x).put(y, new PriorityQueue<>());
+            }
+            map.get(x).get(y).offer(root.val);
+            dfs(root.left, x - 1, y + 1, map);
+            dfs(root.right, x + 1, y + 1, map);
+        }
+    }
+}

src/test/java/com/fishercoder/_987Test.java

@@ -0,0 +1,59 @@
+package com.fishercoder;
+
+import com.fishercoder.common.classes.TreeNode;
+import com.fishercoder.common.utils.TreeUtils;
+import com.fishercoder.solutions._987;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static junit.framework.Assert.assertEquals;
+
+public class _987Test {
+    private static _987.Solution1 solution1;
+    private static TreeNode root;
+    private static List<List<Integer>> expected;
+    private static List<List<Integer>> actual;
+
+    @BeforeClass
+    public static void setup() {
+        solution1 = new _987.Solution1();
+    }
+
+    @Test
+    public void test1() {
+        root = TreeUtils.constructBinaryTree(Arrays.asList(3, 9, 20, null, null, 15, 7));
+        expected = Arrays.asList(Arrays.asList(9), Arrays.asList(3, 15), Arrays.asList(20), Arrays.asList(7));
+        actual = solution1.verticalTraversal(root);
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void test2() {
+        root = TreeUtils.constructBinaryTree(Arrays.asList(1, 2, 3, 4, 5, 6, 7));
+        expected = Arrays.asList(Arrays.asList(4), Arrays.asList(2), Arrays.asList(1, 5, 6), Arrays.asList(3), Arrays.asList(7));
+        actual = solution1.verticalTraversal(root);
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void test3() {
+        root = TreeUtils.constructBinaryTree(Arrays.asList(0, 5, 1, 9, null, 2, null, null, null, null, 3, 4, 8, 6, null, null, null, 7));
+        TreeUtils.printBinaryTree(root);
+        expected = Arrays.asList(Arrays.asList(9, 7), Arrays.asList(5, 6), Arrays.asList(0, 2, 4), Arrays.asList(1, 3), Arrays.asList(8));
+        actual = solution1.verticalTraversal(root);
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void test4() {
+        root = TreeUtils.constructBinaryTree(Arrays.asList(0, 2, 1, 3, null, null, null, 4, 5, null, 7, 6, null, 10, 8, 11, 9));
+        TreeUtils.printBinaryTree(root);
+        expected = Arrays.asList(Arrays.asList(4, 10, 11), Arrays.asList(3, 6, 7), Arrays.asList(2, 5, 8, 9), Arrays.asList(0), Arrays.asList(1));
+        actual = solution1.verticalTraversal(root);
+        assertEquals(expected, actual);
+    }
+
+}