@@ -37,13 +37,124 @@ One possible answer is: [0,-3,9,-10,null,5],which represents the following tre
3737### ** Python3**
3838
3939``` python
40- 40+ # Definition for a binary tree node.
41+ # class TreeNode:
42+ # def __init__(self, x):
43+ # self.val = x
44+ # self.left = None
45+ # self.right = None
46+ 47+ class Solution :
48+ def sortedArrayToBST (self nums : List[int ]) -> TreeNode:
49+ def dfs (i , j ):
50+ if i > j:
51+ return None
52+ if i == j:
53+ return TreeNode(nums[i])
54+ mid = (i + j) >> 1
55+ node = TreeNode(nums[mid])
56+ node.left = dfs(i, mid - 1 )
57+ node.right = dfs(mid + 1 , j)
58+ return node
59+ 60+ return dfs(0 , len (nums) - 1 )
4161```
4262
4363### ** Java**
4464
4565``` java
66+ /**
67+ * Definition for a binary tree node.
68+ * public class TreeNode {
69+ * int val;
70+ * TreeNode left;
71+ * TreeNode right;
72+ * TreeNode(int x) { val = x; }
73+ * }
74+ */
75+ class Solution {
76+ private int [] nums;
77+ 78+ public TreeNode sortedArrayToBST (int [] nums ) {
79+ this . nums = nums;
80+ return dfs(0 , nums. length - 1 );
81+ }
82+ 83+ private TreeNode dfs (int i , int j ) {
84+ if (i > j) {
85+ return null ;
86+ }
87+ if (i == j) {
88+ return new TreeNode (nums[i]);
89+ }
90+ int mid = (i + j) >>> 1 ;
91+ TreeNode node = new TreeNode (nums[mid]);
92+ node. left = dfs(i, mid - 1 );
93+ node. right = dfs(mid + 1 , j);
94+ return node;
95+ }
96+ }
97+ ```
98+ 99+ ### ** C++**
100+ 101+ ``` cpp
102+ /* *
103+ * Definition for a binary tree node.
104+ * struct TreeNode {
105+ * int val;
106+ * TreeNode *left;
107+ * TreeNode *right;
108+ * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
109+ * };
110+ */
111+ class Solution {
112+ public:
113+ vector<int > nums;
114+ 115+ TreeNode* sortedArrayToBST(vector<int>& nums) {
116+ this->nums = nums;
117+ return dfs(0, nums.size() - 1);
118+ }
119+ 120+ TreeNode* dfs (int i, int j) {
121+ if (i > j) return nullptr;
122+ if (i == j) return new TreeNode(nums[ i] );
123+ int mid = i + j >> 1;
124+ TreeNode* node = new TreeNode(nums[ mid] );
125+ node->left = dfs(i, mid - 1);
126+ node->right = dfs(mid + 1, j);
127+ return node;
128+ }
129+ };
130+ ```
46131
132+ ### **Go**
133+
134+ ```go
135+ /**
136+ * Definition for a binary tree node.
137+ * type TreeNode struct {
138+ * Val int
139+ * Left *TreeNode
140+ * Right *TreeNode
141+ * }
142+ */
143+ func sortedArrayToBST(nums []int) *TreeNode {
144+ var dfs func(i, j int) *TreeNode
145+ dfs = func(i, j int) *TreeNode {
146+ if i > j {
147+ return nil
148+ }
149+ if i == j {
150+ return &TreeNode{Val: nums[i]}
151+ }
152+ mid := (i + j) >> 1
153+ return &TreeNode{Val: nums[mid], Left: dfs(i, mid-1), Right: dfs(mid+1, j)}
154+ }
155+
156+ return dfs(0, len(nums)-1)
157+ }
47158```
48159
49160### ** ...**
0 commit comments