add java solution for BST

Author: Zhanganjin0520

README.md

@@ -212,7 +212,7 @@
 |238|[Product of Array Except Self](https://leetcode.com/problems/product-of-array-except-self/)| |Medium|
 |237|[Node in a Linked List](https://leetcode.com/problems/-node-in-a-linked-list/)| [js](./algorithms/nodeInALinkedList/nodeInALinkedList.js),[java](./algorithms/nodeInALinkedList/Solution.java) |Easy|
 |236|[Lowest Common Ancestor of a Binary Tree](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/)| |Medium|
-|235|[Lowest Common Ancestor of a Binary Search Tree](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/)| |Easy|
+|235|[Lowest Common Ancestor of a Binary Search Tree](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/)| [java](./algorithms/lowestCommonAncestorOfBST/Solution.java) |Easy|
 |234|[Palindrome Linked List](https://leetcode.com/problems/palindrome-linked-list/)| [java](./algorithms/palindromeLinkedList/Solution.java) |Easy|
 |233|[Number of Digit One](https://leetcode.com/problems/number-of-digit-one/)| |Medium|
 |232|[Implement Queue using Stacks](https://leetcode.com/problems/implement-queue-using-stacks/)| |Easy|
@@ -320,7 +320,7 @@
 |124|[Binary Tree Maximum Path Sum](https://leetcode.com/problems/binary-tree-maximum-path-sum/)| |Hard|
 |123|[Best Time to Buy and Sell Stock III](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iii/)| |Hard|
 |122|[Best Time to Buy and Sell Stock II](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/)| [js](./algorithms/bestTimeToBuyAndSellStockIi/Solution.js) |Medium|
-|121|[Best Time to Buy and Sell Stock](https://leetcode.com/problems/best-time-to-buy-and-sell-stock/)| |Medium|
+|121|[Best Time to Buy and Sell Stock](https://leetcode.com/problems/best-time-to-buy-and-sell-stock/)| [java](./algorithms/bestTimeToBuyAndSellStock/Solution.java) |Medium|
 |120|[Triangle](https://leetcode.com/problems/triangle/)| |Medium|
 |119|[Pascal's Triangle II](https://leetcode.com/problems/pascals-triangle-ii/)| |Easy|
 |118|[Pascal's Triangle](https://leetcode.com/problems/pascals-triangle/)| |Easy|
@@ -337,7 +337,7 @@
 |107|[Binary Tree Level Order Traversal II](https://leetcode.com/problems/binary-tree-level-order-traversal-ii/)| |Easy|
 |106|[Construct Binary Tree from Inorder and Postorder Traversal](https://leetcode.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/)| |Medium|
 |105|[Construct Binary Tree from Preorder and Inorder Traversal](https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/)| |Medium|
-|104|[Maximum Depth of Binary Tree](https://leetcode.com/problems/maximum-depth-of-binary-tree/)| [js](./algorithms/maximumDepthOfBinaryTree/maximumDepthOfBinaryTree.js) |Easy|
+|104|[Maximum Depth of Binary Tree](https://leetcode.com/problems/maximum-depth-of-binary-tree/)| [js](./algorithms/maximumDepthOfBinaryTree/maximumDepthOfBinaryTree.js) [java](./algorithms/maximumDepthOfBinaryTree/Solution.java) |Easy|
 |103|[Binary Tree Zigzag Level Order Traversal](https://leetcode.com/problems/binary-tree-zigzag-level-order-traversal/)| |Medium|
 |102|[Binary Tree Level Order Traversal](https://leetcode.com/problems/binary-tree-level-order-traversal/)| [js](./algorithms/binaryTreeLevelOrderTraversal/binaryTreeLevelOrderTraversal.js) |Easy|
 |101|[Symmetric Tree](https://leetcode.com/problems/symmetric-tree/)| [java](./algorithms/sysmetricTree/Solution.java), [js](./algorithms/sysmetricTree/Solution.js) |Easy|

algorithms/bestTimeToBuyAndSellStock/Solution.java

@@ -0,0 +1,14 @@
+public class Solution {
+    public int maxProfit(int prices[]) {
+        int minprice = Integer.MAX_VALUE;
+        int maxprofit = 0;
+        for (int i = 0; i < prices.length; i++) {
+            if (prices[i] < minprice) {
+                minprice = prices[i];
+            } else if (prices[i] - minprice > maxprofit) {
+                maxprofit = prices[i] - minprice;
+            }
+        }
+        return maxprofit;
+    }
+}

algorithms/lowestCommonAncestorOfBST/Solution.java

@@ -0,0 +1,42 @@
+/**
+ * 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) {
+        List<TreeNode> pPath = getPath(root,p);
+        List<TreeNode> qPath = getPath(root,q);
+
+        TreeNode common = null;
+        for(int i=0; i<pPath.size()&&i<qPath.size();i++){
+            if(pPath.get(i) == qPath.get(i)){
+                common = pPath.get(i);
+            }else{
+                break;
+            }
+        }
+        return common;
+    }
+
+
+    public List<TreeNode> getPath(TreeNode root, TreeNode target){
+        List<TreeNode> treeNodePath = new ArrayList();
+        TreeNode node = root;
+        while(node!=target){
+            treeNodePath.add(node);
+            if(node.val > target.val){
+                node = node.left;
+            }else{
+                node = node.right;
+            }
+        }
+        treeNodePath.add(target);
+        return treeNodePath;
+    }
+}

algorithms/maximumDepthOfBinaryTree/Solution.java

@@ -0,0 +1,53 @@
+/**
+ * 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 int maxDepth(TreeNode root) {
+        if(null == root){
+            return 0;
+        }
+        int rightMax = maxDepth(root.right);
+        int leftMax = maxDepth(root.left);
+        return Math.max(rightMax,leftMax)+1;
+    }
+
+        //广度遍历
+    public int maxDepth(TreeNode root){
+        if(root == null){
+                return 0;
+        }
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.offer(root);
+        int res = 0;
+    
+        while(!queue.isEmpty()){
+            //广度遍历核心是一层一层的进行
+            int size = queue.size();
+            while(size>0){
+                TreeNode node = queue.poll();
+                if(node.left !=null){
+                    queue.offer(node.left);
+                }
+                if(node.right !=null){
+                    queue.offer(node.right);
+                }
+                size--;
+            }
+            res++;
+        }
+        return res;
+    }
+}