[N-0] refactor 543

Author: fishercoder1534

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

@@ -3,7 +3,11 @@
 import com.fishercoder.common.classes.TreeNode;
 
 /**
- * Given a binary tree, you need to compute the length of the diameter of the tree. The diameter of a binary tree is the length of the longest path between any two nodes in a tree. This path may or may not pass through the root.
+ * 543. Diameter of Binary Tree
+ *
+ * Given a binary tree, you need to compute the length of the diameter of the tree.
+ * The diameter of a binary tree is the length of the longest path between any two nodes in a tree.
+ * This path may or may not pass through the root.
 
  Example:
  Given a binary tree
@@ -18,21 +22,32 @@
  */
 public class _543 {
 
-    int diameter = 0;
-
-    public int diameterOfBinaryTree(TreeNode root) {
-        dfs(root);
-        return diameter;
-    }
+    public static class Solution1 {
+        /**This is a very great problem for practicing recursion:
+         * 1. What dfs() returns is the max height it should pick from either its left or right subtree, that's
+         * what the int return type stands for;
+         * 2. And during the recursion, we can keep updating the global variable: "diameter";
+         * 3. When computing length/height of a subtree, we should take the max of its left and right, then plus one
+         * and left height should be like this
+         * int left = dfs(root.left);
+         * instead of dfs(root.left) + 1;
+         * we'll only plus one at the end
+         * */
+        int diameter = 0;
+
+        public int diameterOfBinaryTree(TreeNode root) {
+            dfs(root);
+            return diameter;
+        }
 
-    private int dfs(TreeNode root) {
-        if (root == null) {
-            return 0;
+        private int dfs(TreeNode root) {
+            if (root == null) {
+                return 0;
+            }
+            int left = dfs(root.left);
+            int right = dfs(root.right);
+            diameter = Math.max(diameter, left + right);
+            return Math.max(left, right) + 1;
         }
-        int left = dfs(root.left);
-        int right = dfs(root.right);
-        diameter = Math.max(diameter, left + right);
-        return Math.max(left, right) + 1;
     }
-
 }

src/test/java/com/fishercoder/_543Test.java

@@ -0,0 +1,29 @@
+package com.fishercoder;
+
+import com.fishercoder.common.classes.TreeNode;
+import com.fishercoder.common.utils.TreeUtils;
+import com.fishercoder.solutions._543;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.util.Arrays;
+
+import static junit.framework.TestCase.assertEquals;
+
+public class _543Test {
+    private static _543.Solution1 solution1;
+    private static TreeNode root;
+
+    @BeforeClass
+    public static void setup() {
+        solution1 = new _543.Solution1();
+    }
+
+    @Test
+    public void test1() {
+        root = TreeUtils.constructBinaryTree(Arrays.asList(1, 2, 3, 4, 5));
+        TreeUtils.printBinaryTree(root);
+        assertEquals(3, solution1.diameterOfBinaryTree(root));
+    }
+
+}