add a solution for 508

Author: fishercoder1534

Diff for: src/main/java/com/fishercoder/solutions/firstthousand/_508.java

@@ -1,6 +1,7 @@
 package com.fishercoder.solutions.firstthousand;
 
 import com.fishercoder.common.classes.TreeNode;
+import com.fishercoder.solutions._Contest;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -107,9 +108,42 @@ private int dfs(TreeNode root, Map<Integer, Integer> map) {
             if (root.right != null) {
                 rightVal = dfs(root.right, map);
             }
-            int val = leftVal + rightVal + root.val;
-            map.put(val, map.getOrDefault(val, 0) + 1);
-            return val;
+            int subtreeSum = leftVal + rightVal + root.val;
+            map.put(subtreeSum, map.getOrDefault(subtreeSum, 0) + 1);
+            return subtreeSum;
+        }
+    }
+
+    public static class Solution3 {
+        /**
+         * Use post-order traversal for this problem as it needs to process subtree first before processing the root.
+         */
+        Map<Integer, Integer> map = new HashMap<>();
+
+        public int[] findFrequentTreeSum(TreeNode root) {
+            postOrder(root);
+            int mostFreq = -1;
+            for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
+                mostFreq = Math.max(mostFreq, entry.getValue());
+            }
+            List<Integer> list = new ArrayList<>();
+            for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
+                if (entry.getValue() == mostFreq) {
+                    list.add(entry.getKey());
+                }
+            }
+            return list.stream().mapToInt(integer -> integer).toArray();
+        }
+
+        private int postOrder(TreeNode root) {
+            if (root == null) {
+                return 0;
+            }
+            int leftSum = postOrder(root.left);
+            int rightSum = postOrder(root.right);
+            int subtreeSum = leftSum + rightSum + root.val;
+            map.put(subtreeSum, map.getOrDefault(subtreeSum, 0) + 1);
+            return subtreeSum;
         }
     }
 

Diff for: src/test/java/com/fishercoder/firstthousand/_508Test.java

@@ -3,32 +3,26 @@
 import com.fishercoder.common.classes.TreeNode;
 import com.fishercoder.common.utils.TreeUtils;
 import com.fishercoder.solutions.firstthousand._508;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
 import java.util.Arrays;
 
-import static org.junit.Assert.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 
 public class _508Test {
     private static _508.Solution1 solution1;
     private static _508.Solution2 solution2;
+    private static _508.Solution3 solution3;
     private static int[] expected;
     private static int[] actual;
     private static TreeNode root;
 
-    @BeforeClass
-    public static void setup() {
+    @BeforeEach
+    public void setup() {
         solution1 = new _508.Solution1();
         solution2 = new _508.Solution2();
-    }
-
-    @Before
-    public void setupForEachTest() {
-        expected = new int[]{};
-        actual = new int[]{};
-        root = null;
+        solution3 = new _508.Solution3();
     }
 
     @Test
@@ -44,6 +38,10 @@ public void test1() {
         actual = solution2.findFrequentTreeSum(root);
         Arrays.sort(actual);
         assertArrayEquals(expected, actual);
+
+        actual = solution3.findFrequentTreeSum(root);
+        Arrays.sort(actual);
+        assertArrayEquals(expected, actual);
     }
 
     @Test
@@ -55,6 +53,9 @@ public void test2() {
 
         actual = solution2.findFrequentTreeSum(root);
         assertArrayEquals(expected, actual);
+
+        actual = solution3.findFrequentTreeSum(root);
+        assertArrayEquals(expected, actual);
     }
 
     @Test
@@ -67,5 +68,8 @@ public void test3() {
 
         actual = solution2.findFrequentTreeSum(root);
         assertArrayEquals(expected, actual);
+
+        actual = solution3.findFrequentTreeSum(root);
+        assertArrayEquals(expected, actual);
     }
 }