Skip to content

Commit 7b4fa56

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0653. Two Sum IV - Input is a BST
1 parent 624a206 commit 7b4fa56

File tree

6 files changed

+287
-3
lines changed

6 files changed

+287
-3
lines changed

‎solution/0600-0699/0653.Two Sum IV - Input is a BST/README.md

+100-1
Original file line numberDiff line numberDiff line change
@@ -47,6 +47,8 @@ Target = 28
4747

4848
<!-- 这里可写通用的实现逻辑 -->
4949

50+
用哈希表记录访问过的节点。
51+
5052
<!-- tabs:start -->
5153

5254
### **Python3**
@@ -69,7 +71,7 @@ class Solution:
6971
return True
7072
nodes.add(node.val)
7173
return find(node.left) or find(node.right)
72-
74+
7375
nodes = set()
7476
return find(root)
7577
```
@@ -79,7 +81,104 @@ class Solution:
7981
<!-- 这里可写当前语言的特殊实现逻辑 -->
8082

8183
```java
84+
/**
85+
* Definition for a binary tree node.
86+
* public class TreeNode {
87+
* int val;
88+
* TreeNode left;
89+
* TreeNode right;
90+
* TreeNode() {}
91+
* TreeNode(int val) { this.val = val; }
92+
* TreeNode(int val, TreeNode left, TreeNode right) {
93+
* this.val = val;
94+
* this.left = left;
95+
* this.right = right;
96+
* }
97+
* }
98+
*/
99+
class Solution {
100+
private Set<Integer> nodes;
101+
102+
public boolean findTarget(TreeNode root, int k) {
103+
nodes = new HashSet<>();
104+
return find(root, k);
105+
}
106+
107+
private boolean find(TreeNode node, int k) {
108+
if (node == null) {
109+
return false;
110+
}
111+
if (nodes.contains(k - node.val)) {
112+
return true;
113+
}
114+
nodes.add(node.val);
115+
return find(node.left, k) || find(node.right, k);
116+
}
117+
}
118+
```
119+
120+
### **C++**
121+
122+
```cpp
123+
/**
124+
* Definition for a binary tree node.
125+
* struct TreeNode {
126+
* int val;
127+
* TreeNode *left;
128+
* TreeNode *right;
129+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
130+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
131+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
132+
* };
133+
*/
134+
class Solution {
135+
public:
136+
unordered_set<int> nodes;
137+
138+
bool findTarget(TreeNode* root, int k) {
139+
return find(root, k);
140+
}
141+
142+
bool find(TreeNode* node, int k) {
143+
if (node == nullptr) {
144+
return false;
145+
}
146+
if (nodes.count(k - node->val)) {
147+
return true;
148+
}
149+
nodes.insert(node->val);
150+
return find(node->left, k) || find(node->right, k);
151+
}
152+
};
153+
```
82154
155+
### **Go**
156+
157+
```go
158+
/**
159+
* Definition for a binary tree node.
160+
* type TreeNode struct {
161+
* Val int
162+
* Left *TreeNode
163+
* Right *TreeNode
164+
* }
165+
*/
166+
func findTarget(root *TreeNode, k int) bool {
167+
nodes := make(map[int]bool)
168+
var find func(node *TreeNode, k int) bool
169+
find = func(node *TreeNode, k int) bool {
170+
if node == nil {
171+
return false
172+
}
173+
if nodes[k-node.Val] {
174+
return true
175+
}
176+
nodes[node.Val] = true
177+
return find(node.Left, k) || find(node.Right, k)
178+
}
179+
return find(root, k)
180+
181+
}
83182
```
84183

85184
### **...**

‎solution/0600-0699/0653.Two Sum IV - Input is a BST/README_EN.md

+98-1
Original file line numberDiff line numberDiff line change
@@ -75,15 +75,112 @@ class Solution:
7575
return True
7676
nodes.add(node.val)
7777
return find(node.left) or find(node.right)
78-
78+
7979
nodes = set()
8080
return find(root)
8181
```
8282

8383
### **Java**
8484

8585
```java
86+
/**
87+
* Definition for a binary tree node.
88+
* public class TreeNode {
89+
* int val;
90+
* TreeNode left;
91+
* TreeNode right;
92+
* TreeNode() {}
93+
* TreeNode(int val) { this.val = val; }
94+
* TreeNode(int val, TreeNode left, TreeNode right) {
95+
* this.val = val;
96+
* this.left = left;
97+
* this.right = right;
98+
* }
99+
* }
100+
*/
101+
class Solution {
102+
private Set<Integer> nodes;
103+
104+
public boolean findTarget(TreeNode root, int k) {
105+
nodes = new HashSet<>();
106+
return find(root, k);
107+
}
108+
109+
private boolean find(TreeNode node, int k) {
110+
if (node == null) {
111+
return false;
112+
}
113+
if (nodes.contains(k - node.val)) {
114+
return true;
115+
}
116+
nodes.add(node.val);
117+
return find(node.left, k) || find(node.right, k);
118+
}
119+
}
120+
```
121+
122+
### **C++**
123+
124+
```cpp
125+
/**
126+
* Definition for a binary tree node.
127+
* struct TreeNode {
128+
* int val;
129+
* TreeNode *left;
130+
* TreeNode *right;
131+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
132+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
133+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
134+
* };
135+
*/
136+
class Solution {
137+
public:
138+
unordered_set<int> nodes;
139+
140+
bool findTarget(TreeNode* root, int k) {
141+
return find(root, k);
142+
}
143+
144+
bool find(TreeNode* node, int k) {
145+
if (node == nullptr) {
146+
return false;
147+
}
148+
if (nodes.count(k - node->val)) {
149+
return true;
150+
}
151+
nodes.insert(node->val);
152+
return find(node->left, k) || find(node->right, k);
153+
}
154+
};
155+
```
86156
157+
### **Go**
158+
159+
```go
160+
/**
161+
* Definition for a binary tree node.
162+
* type TreeNode struct {
163+
* Val int
164+
* Left *TreeNode
165+
* Right *TreeNode
166+
* }
167+
*/
168+
func findTarget(root *TreeNode, k int) bool {
169+
nodes := make(map[int]bool)
170+
var find func(node *TreeNode, k int) bool
171+
find = func(node *TreeNode, k int) bool {
172+
if node == nil {
173+
return false
174+
}
175+
if nodes[k-node.Val] {
176+
return true
177+
}
178+
nodes[node.Val] = true
179+
return find(node.Left, k) || find(node.Right, k)
180+
}
181+
return find(root, k)
182+
183+
}
87184
```
88185

89186
### **...**

‎solution/0600-0699/0653.Two Sum IV - Input is a BST/Solution.cpp

+30
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
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) {}
10+
* };
11+
*/
12+
class Solution {
13+
public:
14+
unordered_set<int> nodes;
15+
16+
bool findTarget(TreeNode* root, int k) {
17+
return find(root, k);
18+
}
19+
20+
bool find(TreeNode* node, int k) {
21+
if (node == nullptr) {
22+
return false;
23+
}
24+
if (nodes.count(k - node->val)) {
25+
return true;
26+
}
27+
nodes.insert(node->val);
28+
return find(node->left, k) || find(node->right, k);
29+
}
30+
};

‎solution/0600-0699/0653.Two Sum IV - Input is a BST/Solution.go

+24
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
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 findTarget(root *TreeNode, k int) bool {
10+
nodes := make(map[int]bool)
11+
var find func(node *TreeNode, k int) bool
12+
find = func(node *TreeNode, k int) bool {
13+
if node == nil {
14+
return false
15+
}
16+
if nodes[k-node.Val] {
17+
return true
18+
}
19+
nodes[node.Val] = true
20+
return find(node.Left, k) || find(node.Right, k)
21+
}
22+
return find(root, k)
23+
24+
}

‎solution/0600-0699/0653.Two Sum IV - Input is a BST/Solution.java

+34
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,34 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* public class TreeNode {
4+
* int val;
5+
* TreeNode left;
6+
* TreeNode right;
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+
* }
14+
* }
15+
*/
16+
class Solution {
17+
private Set<Integer> nodes;
18+
19+
public boolean findTarget(TreeNode root, int k) {
20+
nodes = new HashSet<>();
21+
return find(root, k);
22+
}
23+
24+
private boolean find(TreeNode node, int k) {
25+
if (node == null) {
26+
return false;
27+
}
28+
if (nodes.contains(k - node.val)) {
29+
return true;
30+
}
31+
nodes.add(node.val);
32+
return find(node.left, k) || find(node.right, k);
33+
}
34+
}

‎solution/0600-0699/0653.Two Sum IV - Input is a BST/Solution.py

+1-1
Original file line numberDiff line numberDiff line change
@@ -13,6 +13,6 @@ def find(node):
1313
return True
1414
nodes.add(node.val)
1515
return find(node.left) or find(node.right)
16-
16+
1717
nodes = set()
1818
return find(root)

0 commit comments

Comments
 (0)