Skip to content

Commit a71c576

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1485
No.1485.Clone Binary Tree With Random Pointer
1 parent 2d329a3 commit a71c576

File tree

6 files changed

+393
-2
lines changed

6 files changed

+393
-2
lines changed

‎solution/1400-1499/1485.Clone Binary Tree With Random Pointer/README.md

Lines changed: 134 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -82,15 +82,148 @@
8282
<!-- 这里可写当前语言的特殊实现逻辑 -->
8383

8484
```python
85-
85+
# Definition for Node.
86+
# class Node:
87+
# def __init__(self, val=0, left=None, right=None, random=None):
88+
# self.val = val
89+
# self.left = left
90+
# self.right = right
91+
# self.random = random
92+
93+
class Solution:
94+
def copyRandomBinaryTree(self, root: 'Optional[Node]') -> 'Optional[NodeCopy]':
95+
def dfs(root):
96+
if root is None:
97+
return None
98+
if root in mp:
99+
return mp[root]
100+
copy = NodeCopy(root.val)
101+
mp[root] = copy
102+
copy.left = dfs(root.left)
103+
copy.right = dfs(root.right)
104+
copy.random = dfs(root.random)
105+
return copy
106+
107+
mp = {}
108+
return dfs(root)
86109
```
87110

88111
### **Java**
89112

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

92115
```java
116+
/**
117+
* Definition for Node.
118+
* public class Node {
119+
* int val;
120+
* Node left;
121+
* Node right;
122+
* Node random;
123+
* Node() {}
124+
* Node(int val) { this.val = val; }
125+
* Node(int val, Node left, Node right, Node random) {
126+
* this.val = val;
127+
* this.left = left;
128+
* this.right = right;
129+
* this.random = random;
130+
* }
131+
* }
132+
*/
133+
134+
class Solution {
135+
private Map<Node, NodeCopy> mp;
136+
137+
public NodeCopy copyRandomBinaryTree(Node root) {
138+
mp = new HashMap<>();
139+
return dfs(root);
140+
}
141+
142+
private NodeCopy dfs(Node root) {
143+
if (root == null) {
144+
return null;
145+
}
146+
if (mp.containsKey(root)) {
147+
return mp.get(root);
148+
}
149+
NodeCopy copy = new NodeCopy(root.val);
150+
mp.put(root, copy);
151+
copy.left = dfs(root.left);
152+
copy.right = dfs(root.right);
153+
copy.random = dfs(root.random);
154+
return copy;
155+
}
156+
}
157+
```
158+
159+
### **C++**
160+
161+
```cpp
162+
/**
163+
* Definition for a Node.
164+
* struct Node {
165+
* int val;
166+
* Node *left;
167+
* Node *right;
168+
* Node *random;
169+
* Node() : val(0), left(nullptr), right(nullptr), random(nullptr) {}
170+
* Node(int x) : val(x), left(nullptr), right(nullptr), random(nullptr) {}
171+
* Node(int x, Node *left, Node *right, Node *random) : val(x), left(left), right(right), random(random) {}
172+
* };
173+
*/
174+
175+
class Solution {
176+
public:
177+
NodeCopy* copyRandomBinaryTree(Node* root) {
178+
unordered_map<Node*, NodeCopy*> mp;
179+
return dfs(root, mp);
180+
}
181+
182+
NodeCopy* dfs(Node* root, unordered_map<Node*, NodeCopy*>& mp) {
183+
if (!root) return nullptr;
184+
if (mp.count(root)) return mp[root];
185+
NodeCopy* copy = new NodeCopy(root->val);
186+
mp[root] = copy;
187+
copy->left = dfs(root->left, mp);
188+
copy->right = dfs(root->right, mp);
189+
copy->random = dfs(root->random, mp);
190+
return copy;
191+
}
192+
};
193+
```
93194

195+
### **Go**
196+
197+
```go
198+
/**
199+
* Definition for a Node.
200+
* type Node struct {
201+
* Val int
202+
* Left *Node
203+
* Right *Node
204+
* Random *Node
205+
* }
206+
*/
207+
208+
func copyRandomBinaryTree(root *Node) *NodeCopy {
209+
mp := make(map[*Node]*NodeCopy)
210+
var dfs func(root *Node) *NodeCopy
211+
dfs = func(root *Node) *NodeCopy {
212+
if root == nil {
213+
return nil
214+
}
215+
if v, ok := mp[root]; ok {
216+
return v
217+
}
218+
copy := &NodeCopy{Val: root.Val}
219+
mp[root] = copy
220+
copy.Left = dfs(root.Left)
221+
copy.Right = dfs(root.Right)
222+
copy.Random = dfs(root.Random)
223+
return copy
224+
}
225+
return dfs(root)
226+
}
94227
```
95228

96229
### **...**

‎solution/1400-1499/1485.Clone Binary Tree With Random Pointer/README_EN.md

Lines changed: 134 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -73,13 +73,146 @@ The random pointer of node 7 is node 1, so it is represented as [7, 0] where 0 i
7373
### **Python3**
7474

7575
```python
76-
76+
# Definition for Node.
77+
# class Node:
78+
# def __init__(self, val=0, left=None, right=None, random=None):
79+
# self.val = val
80+
# self.left = left
81+
# self.right = right
82+
# self.random = random
83+
84+
class Solution:
85+
def copyRandomBinaryTree(self, root: 'Optional[Node]') -> 'Optional[NodeCopy]':
86+
def dfs(root):
87+
if root is None:
88+
return None
89+
if root in mp:
90+
return mp[root]
91+
copy = NodeCopy(root.val)
92+
mp[root] = copy
93+
copy.left = dfs(root.left)
94+
copy.right = dfs(root.right)
95+
copy.random = dfs(root.random)
96+
return copy
97+
98+
mp = {}
99+
return dfs(root)
77100
```
78101

79102
### **Java**
80103

81104
```java
105+
/**
106+
* Definition for Node.
107+
* public class Node {
108+
* int val;
109+
* Node left;
110+
* Node right;
111+
* Node random;
112+
* Node() {}
113+
* Node(int val) { this.val = val; }
114+
* Node(int val, Node left, Node right, Node random) {
115+
* this.val = val;
116+
* this.left = left;
117+
* this.right = right;
118+
* this.random = random;
119+
* }
120+
* }
121+
*/
122+
123+
class Solution {
124+
private Map<Node, NodeCopy> mp;
125+
126+
public NodeCopy copyRandomBinaryTree(Node root) {
127+
mp = new HashMap<>();
128+
return dfs(root);
129+
}
130+
131+
private NodeCopy dfs(Node root) {
132+
if (root == null) {
133+
return null;
134+
}
135+
if (mp.containsKey(root)) {
136+
return mp.get(root);
137+
}
138+
NodeCopy copy = new NodeCopy(root.val);
139+
mp.put(root, copy);
140+
copy.left = dfs(root.left);
141+
copy.right = dfs(root.right);
142+
copy.random = dfs(root.random);
143+
return copy;
144+
}
145+
}
146+
```
147+
148+
### **C++**
149+
150+
```cpp
151+
/**
152+
* Definition for a Node.
153+
* struct Node {
154+
* int val;
155+
* Node *left;
156+
* Node *right;
157+
* Node *random;
158+
* Node() : val(0), left(nullptr), right(nullptr), random(nullptr) {}
159+
* Node(int x) : val(x), left(nullptr), right(nullptr), random(nullptr) {}
160+
* Node(int x, Node *left, Node *right, Node *random) : val(x), left(left), right(right), random(random) {}
161+
* };
162+
*/
163+
164+
class Solution {
165+
public:
166+
NodeCopy* copyRandomBinaryTree(Node* root) {
167+
unordered_map<Node*, NodeCopy*> mp;
168+
return dfs(root, mp);
169+
}
170+
171+
NodeCopy* dfs(Node* root, unordered_map<Node*, NodeCopy*>& mp) {
172+
if (!root) return nullptr;
173+
if (mp.count(root)) return mp[root];
174+
NodeCopy* copy = new NodeCopy(root->val);
175+
mp[root] = copy;
176+
copy->left = dfs(root->left, mp);
177+
copy->right = dfs(root->right, mp);
178+
copy->random = dfs(root->random, mp);
179+
return copy;
180+
}
181+
};
182+
```
82183

184+
### **Go**
185+
186+
```go
187+
/**
188+
* Definition for a Node.
189+
* type Node struct {
190+
* Val int
191+
* Left *Node
192+
* Right *Node
193+
* Random *Node
194+
* }
195+
*/
196+
197+
func copyRandomBinaryTree(root *Node) *NodeCopy {
198+
mp := make(map[*Node]*NodeCopy)
199+
var dfs func(root *Node) *NodeCopy
200+
dfs = func(root *Node) *NodeCopy {
201+
if root == nil {
202+
return nil
203+
}
204+
if v, ok := mp[root]; ok {
205+
return v
206+
}
207+
copy := &NodeCopy{Val: root.Val}
208+
mp[root] = copy
209+
copy.Left = dfs(root.Left)
210+
copy.Right = dfs(root.Right)
211+
copy.Random = dfs(root.Random)
212+
return copy
213+
}
214+
return dfs(root)
215+
}
83216
```
84217

85218
### **...**

‎solution/1400-1499/1485.Clone Binary Tree With Random Pointer/Solution.cpp

Lines changed: 31 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,31 @@
1+
/**
2+
* Definition for a Node.
3+
* struct Node {
4+
* int val;
5+
* Node *left;
6+
* Node *right;
7+
* Node *random;
8+
* Node() : val(0), left(nullptr), right(nullptr), random(nullptr) {}
9+
* Node(int x) : val(x), left(nullptr), right(nullptr), random(nullptr) {}
10+
* Node(int x, Node *left, Node *right, Node *random) : val(x), left(left), right(right), random(random) {}
11+
* };
12+
*/
13+
14+
class Solution {
15+
public:
16+
NodeCopy* copyRandomBinaryTree(Node* root) {
17+
unordered_map<Node*, NodeCopy*> mp;
18+
return dfs(root, mp);
19+
}
20+
21+
NodeCopy* dfs(Node* root, unordered_map<Node*, NodeCopy*>& mp) {
22+
if (!root) return nullptr;
23+
if (mp.count(root)) return mp[root];
24+
NodeCopy* copy = new NodeCopy(root->val);
25+
mp[root] = copy;
26+
copy->left = dfs(root->left, mp);
27+
copy->right = dfs(root->right, mp);
28+
copy->random = dfs(root->random, mp);
29+
return copy;
30+
}
31+
};

‎solution/1400-1499/1485.Clone Binary Tree With Random Pointer/Solution.go

Lines changed: 29 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,29 @@
1+
/**
2+
* Definition for a Node.
3+
* type Node struct {
4+
* Val int
5+
* Left *Node
6+
* Right *Node
7+
* Random *Node
8+
* }
9+
*/
10+
11+
func copyRandomBinaryTree(root *Node) *NodeCopy {
12+
mp := make(map[*Node]*NodeCopy)
13+
var dfs func(root *Node) *NodeCopy
14+
dfs = func(root *Node) *NodeCopy {
15+
if root == nil {
16+
return nil
17+
}
18+
if v, ok := mp[root]; ok {
19+
return v
20+
}
21+
copy := &NodeCopy{Val: root.Val}
22+
mp[root] = copy
23+
copy.Left = dfs(root.Left)
24+
copy.Right = dfs(root.Right)
25+
copy.Random = dfs(root.Random)
26+
return copy
27+
}
28+
return dfs(root)
29+
}

0 commit comments

Comments
 (0)