Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit bd1bf9a

Browse files
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

Lines changed: 93 additions & 2 deletions
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

Lines changed: 93 additions & 2 deletions
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

Lines changed: 9 additions & 19 deletions
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+
};
Lines changed: 20 additions & 0 deletions
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

Lines changed: 18 additions & 6 deletions
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+
}
Lines changed: 12 additions & 24 deletions
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)

AltStyle によって変換されたページ (->オリジナル) /