add three solution for bst

Author: Zhanganjin0520

README.md

@@ -64,6 +64,8 @@
 |714|[Best Time to Buy and Sell Stock with Transaction Fee](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-transaction-fee) | |Medium|
 |712|[Minimum ASCII  Sum for Two Strings](https://leetcode.com/problems/minimum-ascii--sum-for-two-strings/) | |Medium|
 |704|[Binary Search](https://leetcode.com/problems/binary-search/)| [Java](./algorithms/binarySearch/Solution.java)
+|701|[Insert Into A Binary Search Tree](https://leetcode.com/problems/insert-into-a-binary-search-tree/)| [Java](./algorithms/insertIntoABST/Solution.java)
+|700|[Search In A Binary Search Tree](https://leetcode.com/problems/search-in-a-binary-search-tree/)| [Java](./algorithms/searchInABST/Solution.java)
 |695|[Max Area of Island](https://leetcode.com/problems/max-area-of-island/) | |Medium|
 |687|[Longest Univalue Path](https://leetcode.com/problems/longest-univalue-path/) | |Easy|
 |684|[Redundant Connection](https://leetcode.com/problems/redundant-connection/) | |Medium|
@@ -94,6 +96,7 @@
 |520|[Detect Capital](https://leetcode.com/problems/detect-capital/) | |Easy|
 |518|[Coin Change 2](https://leetcode.com/problems/coin-change-2/) | |Medium|
 |509|[Fibonacci Number](https://leetcode.com/problems/fibonacci-number/) | [java](./algorithms/fibonacciNumber/Solution.java) |Easy|
+|501|[Find Mode In Binary Search Tree](https://leetcode.com/problems/find-mode-in-binary-search-tree/) | [java](./algorithms/findModeInBST/Solution.java) |Easy|
 |477|[Total Hamming Distance](https://leetcode.com/problems/total-hamming-distance/) | |Medium|
 |463|[Island Perimeter](https://leetcode.com/problems/island-perimeter/) | |Easy|
 |450|[NodeInABST](https://leetcode.com/problems/-node-in-a-bst/) | |Medium|

algorithms/findModeInBST/Solution.java

@@ -0,0 +1,48 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    List<Integer> answer = new ArrayList<Integer>();
+    int base, count, maxCount;
+
+    public int[] findMode(TreeNode root) {
+        dfs(root);
+        int[] mode = new int[answer.size()];
+        for (int i = 0; i < answer.size(); ++i) {
+            mode[i] = answer.get(i);
+        }
+        return mode;
+    }
+
+    public void dfs(TreeNode o) {
+        if (o == null) {
+            return;
+        }
+        dfs(o.left);
+        update(o.val);
+        dfs(o.right);
+    }
+
+    public void update(int x) {
+        if (x == base) {
+            ++count;
+        } else {
+            count = 1;
+            base = x;
+        }
+        if (count == maxCount) {
+            answer.add(base);
+        }
+        if (count > maxCount) {
+            maxCount = count;
+            answer.clear();
+            answer.add(base);
+        }
+    }
+}

algorithms/insertIntoABST/Solution.java

@@ -0,0 +1,43 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public TreeNode insertIntoBST(TreeNode root, int val) {
+            if (root == null) {
+                return new TreeNode(val);
+            }
+            //指针
+            TreeNode pos = root;
+            //迭代
+            while (pos != null) {
+                if (val < pos.val) {
+                    if (pos.left == null) {
+                        pos.left = new TreeNode(val);
+                        break;
+                    } else {
+                        pos = pos.left;
+                    }
+                } else {
+                    if (pos.right == null) {
+                        pos.right = new TreeNode(val);
+                        break;
+                    } else {
+                        pos = pos.right;
+                    }
+                }
+            }
+            return root;
+        }
+    }

algorithms/searchInABST/Solution.java

@@ -0,0 +1,23 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public TreeNode searchBST(TreeNode root, int val) {
+        if(root == null || root.val == val){
+            return root;
+        }
+        return root.val > val ? searchBST(root.left,val):searchBST(root.right,val);    
+    }
+}