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 f2eecdc

Browse files
committed
feat: add solutions to lcof2 problem: No.056.Two Sum IV - Input is a BST
1 parent ff70914 commit f2eecdc

File tree

13 files changed

+391
-124
lines changed

13 files changed

+391
-124
lines changed

‎lcof2/剑指 Offer II 056. 二叉搜索树中两个节点之和/README.md‎

Lines changed: 143 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -44,22 +44,164 @@
4444

4545
<!-- 这里可写通用的实现逻辑 -->
4646

47+
用哈希表记录访问过的节点。
48+
4749
<!-- tabs:start -->
4850

4951
### **Python3**
5052

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

5355
```python
54-
56+
# Definition for a binary tree node.
57+
# class TreeNode:
58+
# def __init__(self, val=0, left=None, right=None):
59+
# self.val = val
60+
# self.left = left
61+
# self.right = right
62+
class Solution:
63+
def findTarget(self, root: TreeNode, k: int) -> bool:
64+
def find(root):
65+
if not root:
66+
return False
67+
if k - root.val in nodes:
68+
return True
69+
nodes.add(root.val)
70+
return find(root.left) or find(root.right)
71+
72+
nodes = set()
73+
return find(root)
5574
```
5675

5776
### **Java**
5877

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

6180
```java
81+
/**
82+
* Definition for a binary tree node.
83+
* public class TreeNode {
84+
* int val;
85+
* TreeNode left;
86+
* TreeNode right;
87+
* TreeNode() {}
88+
* TreeNode(int val) { this.val = val; }
89+
* TreeNode(int val, TreeNode left, TreeNode right) {
90+
* this.val = val;
91+
* this.left = left;
92+
* this.right = right;
93+
* }
94+
* }
95+
*/
96+
class Solution {
97+
private Set<Integer> nodes;
98+
99+
public boolean findTarget(TreeNode root, int k) {
100+
nodes = new HashSet<>();
101+
return find(root, k);
102+
}
103+
104+
private boolean find(TreeNode root, int k) {
105+
if (root == null) {
106+
return false;
107+
}
108+
if (nodes.contains(k - root.val)) {
109+
return true;
110+
}
111+
nodes.add(root.val);
112+
return find(root.left, k) || find(root.right, k);
113+
}
114+
}
115+
```
116+
117+
### **TypeScript**
118+
119+
```ts
120+
/**
121+
* Definition for a binary tree node.
122+
* class TreeNode {
123+
* val: number
124+
* left: TreeNode | null
125+
* right: TreeNode | null
126+
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
127+
* this.val = (val===undefined ? 0 : val)
128+
* this.left = (left===undefined ? null : left)
129+
* this.right = (right===undefined ? null : right)
130+
* }
131+
* }
132+
*/
133+
134+
function findTarget(root: TreeNode | null, k: number): boolean {
135+
let nodes: Set<number> = new Set();
136+
return find(root, k, nodes);
137+
};
138+
139+
function find(root: TreeNode | null, k: number, nodes: Set<number>): boolean {
140+
if (!root) return false;
141+
if (nodes.has(k - root.val)) return true;
142+
nodes.add(root.val);
143+
return find(root.left, k, nodes) || find(root.right, k, nodes);
144+
}
145+
```
146+
147+
### **C++**
148+
149+
```cpp
150+
/**
151+
* Definition for a binary tree node.
152+
* struct TreeNode {
153+
* int val;
154+
* TreeNode *left;
155+
* TreeNode *right;
156+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
157+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
158+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
159+
* };
160+
*/
161+
class Solution {
162+
public:
163+
unordered_set<int> nodes;
164+
165+
bool findTarget(TreeNode* root, int k) {
166+
return find(root, k);
167+
}
168+
169+
bool find(TreeNode* root, int k) {
170+
if (!root) return false;
171+
if (nodes.count(k - root->val)) return true;
172+
nodes.insert(root->val);
173+
return find(root->left, k) || find(root->right, k);
174+
}
175+
};
176+
```
62177
178+
### **Go**
179+
180+
```go
181+
/**
182+
* Definition for a binary tree node.
183+
* type TreeNode struct {
184+
* Val int
185+
* Left *TreeNode
186+
* Right *TreeNode
187+
* }
188+
*/
189+
func findTarget(root *TreeNode, k int) bool {
190+
nodes := make(map[int]bool)
191+
192+
var find func(root *TreeNode, k int) bool
193+
find = func(root *TreeNode, k int) bool {
194+
if root == nil {
195+
return false
196+
}
197+
if nodes[k-root.Val] {
198+
return true
199+
}
200+
nodes[root.Val] = true
201+
return find(root.Left, k) || find(root.Right, k)
202+
}
203+
return find(root, k)
204+
}
63205
```
64206

65207
### **...**
Lines changed: 26 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
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* root, int k) {
21+
if (!root) return false;
22+
if (nodes.count(k - root->val)) return true;
23+
nodes.insert(root->val);
24+
return find(root->left, k) || find(root->right, k);
25+
}
26+
};
Lines changed: 24 additions & 0 deletions
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+
12+
var find func(root *TreeNode, k int) bool
13+
find = func(root *TreeNode, k int) bool {
14+
if root == nil {
15+
return false
16+
}
17+
if nodes[k-root.Val] {
18+
return true
19+
}
20+
nodes[root.Val] = true
21+
return find(root.Left, k) || find(root.Right, k)
22+
}
23+
return find(root, k)
24+
}
Lines changed: 34 additions & 0 deletions
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 root, int k) {
25+
if (root == null) {
26+
return false;
27+
}
28+
if (nodes.contains(k - root.val)) {
29+
return true;
30+
}
31+
nodes.add(root.val);
32+
return find(root.left, k) || find(root.right, k);
33+
}
34+
}
Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
# Definition for a binary tree node.
2+
# class TreeNode:
3+
# def __init__(self, val=0, left=None, right=None):
4+
# self.val = val
5+
# self.left = left
6+
# self.right = right
7+
class Solution:
8+
def findTarget(self, root: TreeNode, k: int) -> bool:
9+
def find(root):
10+
if not root:
11+
return False
12+
if k - root.val in nodes:
13+
return True
14+
nodes.add(root.val)
15+
return find(root.left) or find(root.right)
16+
17+
nodes = set()
18+
return find(root)
Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* class TreeNode {
4+
* val: number
5+
* left: TreeNode | null
6+
* right: TreeNode | null
7+
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
8+
* this.val = (val===undefined ? 0 : val)
9+
* this.left = (left===undefined ? null : left)
10+
* this.right = (right===undefined ? null : right)
11+
* }
12+
* }
13+
*/
14+
15+
function findTarget(root: TreeNode | null, k: number): boolean {
16+
let nodes: Set<number> = new Set();
17+
return find(root, k, nodes);
18+
};
19+
20+
function find(root: TreeNode | null, k: number, nodes: Set<number>): boolean {
21+
if (!root) return false;
22+
if (nodes.has(k - root.val)) return true;
23+
nodes.add(root.val);
24+
return find(root.left, k, nodes) || find(root.right, k, nodes);
25+
}

0 commit comments

Comments
(0)

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