[Function add]

1. Add leetcode solutions.

Author: Botao Xiao

README.md

@@ -411,6 +411,10 @@
 
 [234. Palindrome Linked List](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/234.%20Palindrome%20Linked%20List.md)
 
+[235. Lowest Common Ancestor of a Binary Search Tree](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/235.%20Lowest%20Common%20Ancestor%20of%20a%20Binary%20Search%20Tree.md)
+
+[236. Lowest Common Ancestor of a Binary Tree](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/236.%20Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree.md)
+
 ## Algorithm(4th_Edition)
 Reading notes of book Algorithm(4th Algorithm),ISBN: 9787115293800.
 All java realization codes are placed in different packages.

leetcode/235. Lowest Common Ancestor of a Binary Search Tree.md

@@ -87,4 +87,62 @@ class Solution {
         return root;
     }
 }
-```
+```
+
+### 二刷
+1. Same thing as Method1
+```Java
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        if(p == root || q == root) return root;
+        boolean pInLeft = isChild(root.left, p);
+        boolean pInRight = isChild(root.right, p);
+        boolean qInLeft = isChild(root.left, q);
+        boolean qInRight = isChild(root.right, q);
+        if(pInLeft && qInLeft){
+            return lowestCommonAncestor(root.left, p, q);
+        }else if(pInRight && qInRight){
+            return lowestCommonAncestor(root.right, p, q);
+        }else{
+            return root;
+        }
+    }
+
+    private boolean isChild(TreeNode node, TreeNode p){
+        if(node == null) return false;
+        if(node == p) return true;
+        return isChild(node.left, p) || isChild(node.right, p);
+    }
+}
+```
+
+2. Different from the previous method, we can use the property of BST and check isChild by just comparing the value, and even can check if current node is in left or right child node of current node.
+```Java
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        if(root == null) return null;
+        if(root.val == p.val || root.val == q.val) return root;
+        else if(p.val < root.val && q.val < root.val) return lowestCommonAncestor(root.left, p, q);
+        else if(p.val > root.val && q.val > root.val) return lowestCommonAncestor(root.right, p, q);
+        else return root;
+    }
+}
+```

leetcode/236. Lowest Common Ancestor of a Binary Tree.md

@@ -85,4 +85,99 @@ class Solution {
         return null;
     }
 }
-```
+```
+
+### 二刷
+1. Same as previous quesiton, I just copy and paste.
+```Java
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        if(root == null) return null;
+        if(root == q || root == p) return root;
+        boolean pinLeft = contains(root.left, p);
+        boolean pinRight = contains(root.right, p);
+        boolean qinRight = contains(root.right, q);
+        boolean qinLeft = contains(root.left, q)
+        if(pinLeft && qinRight) return root;
+        else if(pinRight && qinLeft) return root;
+        else if(pinLeft && qinLeft) return lowestCommonAncestor(root.left, p, q);
+        else if(pinRight && qinRight) return lowestCommonAncestor(root.right, p, q);
+        return null;
+    }
+    private boolean contains(TreeNode root, TreeNode node){
+        if(root == null) return false;
+        if(root == node) return true;
+        return contains(root.left, node) || contains(root.right, node);
+    }
+}
+```
+
+2. I modified the result a little bit and get a result.
+```Java
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        if(p == root || q == root) return root;
+        boolean pInLeft = isChild(root.left, p);
+        boolean qInRight = isChild(root.right, q);
+        if(pInLeft && qInRight || !pInLeft && !qInRight) return root;
+        else if(!pInLeft && qInRight){
+            return lowestCommonAncestor(root.right, p, q);
+        }else{
+            return lowestCommonAncestor(root.left, p, q);
+        }
+    }
+
+    private boolean isChild(TreeNode node, TreeNode p){
+        if(node == null) return false;
+        if(node == p) return true;
+        return isChild(node.left, p) || isChild(node.right, p);
+    }
+}
+```
+
+3. Method 3, it is using divide and conquer method.
+  * We first find their common ancestor in left child. Result is A.
+  * Then we find their common ancestor in right child. Result is B.
+  * if A and B are both not null, it means current node is their closest common ancestor.
+  * if one of them is not null, the other one is their closest common ancestor.
+```Java
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        if(root == p || root == q || root == null) return root;
+        TreeNode left = lowestCommonAncestor(root.left, p ,q);
+        TreeNode right = lowestCommonAncestor(root.right, p ,q);
+        if(left != null && right != null){
+            return root;
+        }else if(left != null) return left;
+        else if(right != null) return right;
+        return null;
+    }
+}
+```