refactor 235

fishercoder1534 · fishercoder1534 · commit e92950904a44 · 2019-01-22T14:11:58.000-08:00
diff --git a/src/main/java/com/fishercoder/solutions/_235.java b/src/main/java/com/fishercoder/solutions/_235.java
@@ -10,12 +10,12 @@
  * “The lowest common ancestor is defined between two nodes v and w as the lowest node in T that has both v and w as descendants
  * (where we allow a node to be a descendant of itself).”
 
- _______6______
- /              \
- ___2__          ___8__
- /      \        /      \
- 0      _4       7       9
- /  \
+          _______6______
+         /              \
+     ___2__          ___8__
+    /      \        /      \
+    0      4        7       9
+  /  \
  3   5
 
  For example, the lowest common ancestor (LCA) of nodes 2 and 8 is 6.
@@ -38,4 +38,22 @@ public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
             return root;
         }
     }
+
+    public static class Solution2 {
+        public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+            if (p == root || q == root || p == q) {
+                return root;
+            }
+            if (p.val < root.val && q.val > root.val) {
+                return root;
+            }
+            if (p.val < root.val && q.val < root.val) {
+                return lowestCommonAncestor(root.left, p, q);
+            }
+            if (p.val > root.val && q.val > root.val) {
+                return lowestCommonAncestor(root.right, p, q);
+            }
+            return root;
+        }
+    }
 }
diff --git a/src/test/java/com/fishercoder/_235Test.java b/src/test/java/com/fishercoder/_235Test.java
@@ -0,0 +1,54 @@
+package com.fishercoder;
+
+import com.fishercoder.common.classes.TreeNode;
+import com.fishercoder.common.utils.TreeUtils;
+import com.fishercoder.solutions._235;
+import java.util.Arrays;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _235Test {
+  private static _235.Solution1 solution1;
+  private static _235.Solution2 solution2;
+  private static TreeNode root;
+  private static TreeNode p;
+  private static TreeNode q;
+
+  @BeforeClass
+  public static void setup() {
+    solution1 = new _235.Solution1();
+    solution2 = new _235.Solution2();
+  }
+
+  @Test
+  public void test1() {
+    root = TreeUtils.constructBinaryTree(Arrays.asList(6, 2, 8, 0, 4, 7, 9, 3, 5));
+    TreeUtils.printBinaryTree(root);
+
+    p = TreeUtils.constructBinaryTree(Arrays.asList(2, 0, 4, 3, 5));
+    TreeUtils.printBinaryTree(p);
+
+    q = TreeUtils.constructBinaryTree(Arrays.asList(8, 7, 9));
+    TreeUtils.printBinaryTree(q);
+
+    assertEquals(root, solution1.lowestCommonAncestor(root, p, q));
+    assertEquals(root, solution2.lowestCommonAncestor(root, p, q));
+  }
+
+  @Test
+  public void test2() {
+    root = TreeUtils.constructBinaryTree(Arrays.asList(6, 2, 8, 0, 4, 7, 9, 3, 5));
+    TreeUtils.printBinaryTree(root);
+
+    p = TreeUtils.constructBinaryTree(Arrays.asList(2, 0, 4, 3, 5));
+    TreeUtils.printBinaryTree(p);
+
+    q = TreeUtils.constructBinaryTree(Arrays.asList(4));
+    TreeUtils.printBinaryTree(q);
+
+    assertEquals(p, solution1.lowestCommonAncestor(root, p, q));
+    assertEquals(p, solution2.lowestCommonAncestor(root, p, q));
+  }
+}
