Update 108.convert-sorted-array-to-binary-search-tree.md

problems/108.convert-sorted-array-to-binary-search-tree.md

@@ -45,22 +45,9 @@ https://leetcode-cn.com/problems/convert-sorted-array-to-binary-search-tree/
 
 ## 代码
 
-代码支持：Python，JS ，Java
+代码支持：JS，C++，Java，Python
 
-Python:
-
-```py
-class Solution:
-    def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
-        if not nums: return None
-        mid = (len(nums) - 1) // 2
-        root = TreeNode(nums[mid])
-        root.left = self.sortedArrayToBST(nums[:mid])
-        root.right = self.sortedArrayToBST(nums[mid + 1:])
-        return root
-```
-
-JS:
+JS Code:
 
 ```js
 var sortedArrayToBST = function (nums) {
@@ -76,14 +63,59 @@ var sortedArrayToBST = function (nums) {
 };
 ```
 
+Python Code:
+
+```py
+class Solution:
+    def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
+        if not nums: return None
+        mid = (len(nums) - 1) // 2
+        root = TreeNode(nums[mid])
+        root.left = self.sortedArrayToBST(nums[:mid])
+        root.right = self.sortedArrayToBST(nums[mid + 1:])
+        return root
+```
+
+
+
 **复杂度分析**
 
 - 时间复杂度：$O(N)$
 - 空间复杂度：每次递归都 copy 了 N 的 空间，因此空间复杂度为 $O(N ^ 2)$
 
 然而，实际上没必要开辟新的空间：
 
-Java:
+C++ Code:
+
+```c++
+class Solution {
+public:
+    TreeNode* sortedArrayToBST(vector<int>& nums) {
+        return reBuild(nums, 0, nums.size()-1);
+    }
+
+    TreeNode* reBuild(vector<int>& nums, int left, int right) 
+    {
+        // 终止条件：中序遍历为空
+        if(left > right)
+        {
+            return NULL;
+        }
+        // 建立当前子树的根节点
+        int mid = (left+right)/2;
+        TreeNode * root = new TreeNode(nums[mid]);
+
+        // 左子树的下层递归
+        root->left = reBuild(nums, left, mid-1);
+        // 右子树的下层递归
+        root->right = reBuild(nums, mid+1, right);
+        // 返回根节点
+        return root;
+    }
+};
+```
+
+Java Code:
 
 ```java
 class Solution {
@@ -105,6 +137,30 @@ class Solution {
 
 ```
 
+Python Code:
+```python
+class Solution(object):
+    def sortedArrayToBST(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: TreeNode
+        """
+        return self.reBuild(nums, 0, len(nums)-1)
+
+    def reBuild(self, nums, left, right):
+         # 终止条件：
+        if left > right:
+            return
+        # 建立当前子树的根节点
+        mid = (left + right)//2
+        root = TreeNode(nums[mid])
+        # 左右子树的下层递归
+        root.left = self.reBuild(nums, left, mid-1)
+        root.right = self.reBuild(nums, mid+1, right)
+
+        return root
+```
+
 **复杂度分析**
 
 - 时间复杂度：$O(N)$