Skip to content

Commit bd1bf9a

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0700.Search in a Binary Search
Tree
1 parent 87b4bfe commit bd1bf9a

File tree

6 files changed

+245
-53
lines changed

6 files changed

+245
-53
lines changed

‎solution/0700-0799/0700.Search in a Binary Search Tree/README.md

+93-2
Original file line numberDiff line numberDiff line change
@@ -32,7 +32,6 @@
3232

3333
<p>在上述示例中，如果要找的值是 <code>5</code>，但因为没有节点值为 <code>5</code>，我们应该返回 <code>NULL</code>。</p>
3434

35-
3635
## 解法
3736

3837
<!-- 这里可写通用的实现逻辑 -->
@@ -44,15 +43,107 @@
4443
<!-- 这里可写当前语言的特殊实现逻辑 -->
4544

4645
```python
47-
46+
# Definition for a binary tree node.
47+
# class TreeNode:
48+
# def __init__(self, val=0, left=None, right=None):
49+
# self.val = val
50+
# self.left = left
51+
# self.right = right
52+
class Solution:
53+
def searchBST(self, root: TreeNode, val: int) -> TreeNode:
54+
if root is None:
55+
return None
56+
if root.val == val:
57+
return root
58+
if root.val < val:
59+
return self.searchBST(root.right, val)
60+
return self.searchBST(root.left, val)
4861
```
4962

5063
### **Java**
5164

5265
<!-- 这里可写当前语言的特殊实现逻辑 -->
5366

5467
```java
68+
/**
69+
* Definition for a binary tree node.
70+
* public class TreeNode {
71+
* int val;
72+
* TreeNode left;
73+
* TreeNode right;
74+
* TreeNode() {}
75+
* TreeNode(int val) { this.val = val; }
76+
* TreeNode(int val, TreeNode left, TreeNode right) {
77+
* this.val = val;
78+
* this.left = left;
79+
* this.right = right;
80+
* }
81+
* }
82+
*/
83+
class Solution {
84+
public TreeNode searchBST(TreeNode root, int val) {
85+
if (root == null) {
86+
return null;
87+
}
88+
if (root.val == val) {
89+
return root;
90+
}
91+
if (root.val < val) {
92+
return searchBST(root.right, val);
93+
}
94+
return searchBST(root.left, val);
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() : val(0), left(nullptr), right(nullptr) {}
109+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
110+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
111+
* };
112+
*/
113+
class Solution {
114+
public:
115+
TreeNode* searchBST(TreeNode* root, int val) {
116+
if (root == nullptr) return nullptr;
117+
if (root->val == val) return root;
118+
if (root->val < val) return searchBST(root->right, val);
119+
return searchBST(root->left, val);
120+
}
121+
};
122+
```
55123
124+
### **Go**
125+
126+
```go
127+
/**
128+
* Definition for a binary tree node.
129+
* type TreeNode struct {
130+
* Val int
131+
* Left *TreeNode
132+
* Right *TreeNode
133+
* }
134+
*/
135+
func searchBST(root *TreeNode, val int) *TreeNode {
136+
if root == nil {
137+
return nil
138+
}
139+
if root.Val == val {
140+
return root
141+
}
142+
if root.Val < val {
143+
return searchBST(root.Right, val)
144+
}
145+
return searchBST(root.Left, val)
146+
}
56147
```
57148

58149
### **...**

‎solution/0700-0799/0700.Search in a Binary Search Tree/README_EN.md

+93-2
Original file line numberDiff line numberDiff line change
@@ -33,21 +33,112 @@
3333
<li><code>1 &lt;= val &lt;= 10<sup>7</sup></code></li>
3434
</ul>
3535

36-
3736
## Solutions
3837

3938
<!-- tabs:start -->
4039

4140
### **Python3**
4241

4342
```python
44-
43+
# Definition for a binary tree node.
44+
# class TreeNode:
45+
# def __init__(self, val=0, left=None, right=None):
46+
# self.val = val
47+
# self.left = left
48+
# self.right = right
49+
class Solution:
50+
def searchBST(self, root: TreeNode, val: int) -> TreeNode:
51+
if root is None:
52+
return None
53+
if root.val == val:
54+
return root
55+
if root.val < val:
56+
return self.searchBST(root.right, val)
57+
return self.searchBST(root.left, val)
4558
```
4659

4760
### **Java**
4861

4962
```java
63+
/**
64+
* Definition for a binary tree node.
65+
* public class TreeNode {
66+
* int val;
67+
* TreeNode left;
68+
* TreeNode right;
69+
* TreeNode() {}
70+
* TreeNode(int val) { this.val = val; }
71+
* TreeNode(int val, TreeNode left, TreeNode right) {
72+
* this.val = val;
73+
* this.left = left;
74+
* this.right = right;
75+
* }
76+
* }
77+
*/
78+
class Solution {
79+
public TreeNode searchBST(TreeNode root, int val) {
80+
if (root == null) {
81+
return null;
82+
}
83+
if (root.val == val) {
84+
return root;
85+
}
86+
if (root.val < val) {
87+
return searchBST(root.right, val);
88+
}
89+
return searchBST(root.left, val);
90+
}
91+
}
92+
```
93+
94+
### **C++**
95+
96+
```cpp
97+
/**
98+
* Definition for a binary tree node.
99+
* struct TreeNode {
100+
* int val;
101+
* TreeNode *left;
102+
* TreeNode *right;
103+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
104+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
105+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
106+
* };
107+
*/
108+
class Solution {
109+
public:
110+
TreeNode* searchBST(TreeNode* root, int val) {
111+
if (root == nullptr) return nullptr;
112+
if (root->val == val) return root;
113+
if (root->val < val) return searchBST(root->right, val);
114+
return searchBST(root->left, val);
115+
}
116+
};
117+
```
50118
119+
### **Go**
120+
121+
```go
122+
/**
123+
* Definition for a binary tree node.
124+
* type TreeNode struct {
125+
* Val int
126+
* Left *TreeNode
127+
* Right *TreeNode
128+
* }
129+
*/
130+
func searchBST(root *TreeNode, val int) *TreeNode {
131+
if root == nil {
132+
return nil
133+
}
134+
if root.Val == val {
135+
return root
136+
}
137+
if root.Val < val {
138+
return searchBST(root.Right, val)
139+
}
140+
return searchBST(root.Left, val)
141+
}
51142
```
52143

53144
### **...**

‎solution/0700-0799/0700.Search in a Binary Search Tree/Solution.cpp

+9-19
Original file line numberDiff line numberDiff line change
@@ -4,27 +4,17 @@
44
* int val;
55
* TreeNode *left;
66
* TreeNode *right;
7-
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
7+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
8+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
9+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
810
* };
911
*/
1012
class Solution {
11-
public:
13+
public:
1214
TreeNode* searchBST(TreeNode* root, int val) {
13-
14-
TreeNode* temp = root;
15-
16-
while( temp != NULL ){
17-
if( temp->val == val ){
18-
return temp;
19-
}
20-
else if( val < temp->val ){
21-
temp = temp->left;
22-
}
23-
else{
24-
temp = temp->right;
25-
}
26-
}
27-
28-
return NULL;
15+
if (root == nullptr) return nullptr;
16+
if (root->val == val) return root;
17+
if (root->val < val) return searchBST(root->right, val);
18+
return searchBST(root->left, val);
2919
}
30-
};
20+
};

‎solution/0700-0799/0700.Search in a Binary Search Tree/Solution.go

+20
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* type TreeNode struct {
4+
* Val int
5+
* Left *TreeNode
6+
* Right *TreeNode
7+
* }
8+
*/
9+
func searchBST(root *TreeNode, val int) *TreeNode {
10+
if root == nil {
11+
return nil
12+
}
13+
if root.Val == val {
14+
return root
15+
}
16+
if root.Val < val {
17+
return searchBST(root.Right, val)
18+
}
19+
return searchBST(root.Left, val)
20+
}

‎solution/0700-0799/0700.Search in a Binary Search Tree/Solution.java

+18-6
Original file line numberDiff line numberDiff line change
@@ -4,14 +4,26 @@
44
* int val;
55
* TreeNode left;
66
* TreeNode right;
7-
* TreeNode(int x) { val = x; }
7+
* TreeNode() {}
8+
* TreeNode(int val) { this.val = val; }
9+
* TreeNode(int val, TreeNode left, TreeNode right) {
10+
* this.val = val;
11+
* this.left = left;
12+
* this.right = right;
13+
* }
814
* }
915
*/
1016
class Solution {
1117
public TreeNode searchBST(TreeNode root, int val) {
12-
if (root == null) return null;
13-
if (root.val == val) return root;
14-
if (root.val < val) return searchBST(root.right, val);
15-
else return searchBST(root.left, val);
18+
if (root == null) {
19+
return null;
20+
}
21+
if (root.val == val) {
22+
return root;
23+
}
24+
if (root.val < val) {
25+
return searchBST(root.right, val);
26+
}
27+
return searchBST(root.left, val);
1628
}
17-
}
29+
}

‎solution/0700-0799/0700.Search in a Binary Search Tree/Solution.py

+12-24
Original file line numberDiff line numberDiff line change
@@ -1,27 +1,15 @@
11
# Definition for a binary tree node.
22
# class TreeNode:
3-
# def __init__(self, x):
4-
# self.val = x
5-
# self.left = None
6-
# self.right = None
7-
3+
# def __init__(self, val=0, left=None, right=None):
4+
# self.val = val
5+
# self.left = left
6+
# self.right = right
87
class Solution:
9-
def searchBST(self, root, val):
10-
"""
11-
:type root: TreeNode
12-
:type val: int
13-
:rtype: TreeNode
14-
"""
15-
16-
temp = root
17-
18-
while temp != None :
19-
20-
if temp.val == val :
21-
return temp
22-
elif val < temp.val :
23-
temp = temp.left
24-
else:
25-
temp = temp.right
26-
27-
return None
8+
def searchBST(self, root: TreeNode, val: int) -> TreeNode:
9+
if root is None:
10+
return None
11+
if root.val == val:
12+
return root
13+
if root.val < val:
14+
return self.searchBST(root.right, val)
15+
return self.searchBST(root.left, val)

0 commit comments

Comments
 (0)