Added task 235.

Author: javadev

src/main/java/g0201_0300/s0235_lowest_common_ancestor_of_a_binary_search_tree/Solution.java

@@ -0,0 +1,18 @@
+package g0201_0300.s0235_lowest_common_ancestor_of_a_binary_search_tree;
+
+import com_github_leetcode.TreeNode;
+
+public class Solution {
+    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        while (true) {
+            if (root.val > p.val && root.val > q.val) {
+                root = root.left;
+            } else if (root.val < p.val && root.val < q.val) {
+                root = root.right;
+            } else {
+                break;
+            }
+        }
+        return root;
+    }
+}

src/main/java/g0201_0300/s0235_lowest_common_ancestor_of_a_binary_search_tree/readme.md

@@ -0,0 +1,41 @@
+235\. Lowest Common Ancestor of a Binary Search Tree
+
+Easy
+
+Given a binary search tree (BST), find the lowest common ancestor (LCA) of two given nodes in the BST.
+
+According to the [definition of LCA on Wikipedia](https://en.wikipedia.org/wiki/Lowest_common_ancestor): “The lowest common ancestor is defined between two nodes `p` and `q` as the lowest node in `T` that has both `p` and `q` as descendants (where we allow **a node to be a descendant of itself**).”
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png)
+
+**Input:** root = \[6,2,8,0,4,7,9,null,null,3,5\], p = 2, q = 8
+
+**Output:** 6
+
+**Explanation:** The LCA of nodes 2 and 8 is 6. 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png)
+
+**Input:** root = \[6,2,8,0,4,7,9,null,null,3,5\], p = 2, q = 4
+
+**Output:** 2
+
+**Explanation:** The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition. 
+
+**Example 3:**
+
+**Input:** root = \[2,1\], p = 2, q = 1
+
+**Output:** 2 
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.
+*   <code>-10<sup>9</sup> <= Node.val <= 10<sup>9</sup></code>
+*   All `Node.val` are **unique**.
+*   `p != q`
+*   `p` and `q` will exist in the BST.

src/test/java/g0201_0300/s0235_lowest_common_ancestor_of_a_binary_search_tree/SolutionTest.java

@@ -0,0 +1,21 @@
+package g0201_0300.s0235_lowest_common_ancestor_of_a_binary_search_tree;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com_github_leetcode.TreeNode;
+import org.junit.Test;
+
+public class SolutionTest {
+    @Test
+    public void lowestCommonAncestor() {
+        TreeNode leftNodeLeftNode = new TreeNode(0);
+        TreeNode leftNodeRightNode = new TreeNode(4, new TreeNode(3), new TreeNode(5));
+        TreeNode leftNode = new TreeNode(2, leftNodeLeftNode, leftNodeRightNode);
+        TreeNode rightNode = new TreeNode(6, new TreeNode(7), new TreeNode(9));
+        TreeNode root = new TreeNode(6, leftNode, rightNode);
+        assertThat(
+                new Solution().lowestCommonAncestor(root, new TreeNode(2), new TreeNode(8)).val,
+                equalTo(6));
+    }
+}