Skip to content

Commit 01a20fb

Browse files
YangFongYangFong
committed
feat: add solutions to lc problem: No.0572
No.0572.Subtree of Another Tree
1 parent 9497430 commit 01a20fb

File tree

4 files changed

+284
-0
lines changed

4 files changed

+284
-0
lines changed

‎solution/0500-0599/0572.Subtree of Another Tree/README.md

+98
Original file line numberDiff line numberDiff line change
@@ -209,6 +209,104 @@ var isSubtree = function (root, subRoot) {
209209
};
210210
```
211211

212+
### **TypeScript**
213+
214+
```ts
215+
/**
216+
* Definition for a binary tree node.
217+
* class TreeNode {
218+
* val: number
219+
* left: TreeNode | null
220+
* right: TreeNode | null
221+
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
222+
* this.val = (val===undefined ? 0 : val)
223+
* this.left = (left===undefined ? null : left)
224+
* this.right = (right===undefined ? null : right)
225+
* }
226+
* }
227+
*/
228+
229+
const dfs = (root: TreeNode | null, subRoot: TreeNode | null) => {
230+
if (root == null && subRoot == null) {
231+
return true;
232+
}
233+
if (root == null || subRoot == null || root.val !== subRoot.val) {
234+
return false;
235+
}
236+
return dfs(root.left, subRoot.left) && dfs(root.right, subRoot.right);
237+
};
238+
239+
function isSubtree(root: TreeNode | null, subRoot: TreeNode | null): boolean {
240+
if (root == null) {
241+
return false;
242+
}
243+
return (
244+
dfs(root, subRoot) ||
245+
isSubtree(root.left, subRoot) ||
246+
isSubtree(root.right, subRoot)
247+
);
248+
}
249+
```
250+
251+
### **Rust**
252+
253+
```rust
254+
// Definition for a binary tree node.
255+
// #[derive(Debug, PartialEq, Eq)]
256+
// pub struct TreeNode {
257+
// pub val: i32,
258+
// pub left: Option<Rc<RefCell<TreeNode>>>,
259+
// pub right: Option<Rc<RefCell<TreeNode>>>,
260+
// }
261+
//
262+
// impl TreeNode {
263+
// #[inline]
264+
// pub fn new(val: i32) -> Self {
265+
// TreeNode {
266+
// val,
267+
// left: None,
268+
// right: None
269+
// }
270+
// }
271+
// }
272+
use std::rc::Rc;
273+
use std::cell::RefCell;
274+
impl Solution {
275+
fn dfs(root: &Option<Rc<RefCell<TreeNode>>>, sub_root: &Option<Rc<RefCell<TreeNode>>>) -> bool {
276+
if root.is_none() && sub_root.is_none() {
277+
return true;
278+
}
279+
if root.is_none() || sub_root.is_none() {
280+
return false;
281+
}
282+
let root = root.as_ref().unwrap().borrow();
283+
let sub_root = sub_root.as_ref().unwrap().borrow();
284+
root.val == sub_root.val
285+
&& Self::dfs(&root.left, &sub_root.left)
286+
&& Self::dfs(&root.right, &sub_root.right)
287+
}
288+
289+
fn help(
290+
root: &Option<Rc<RefCell<TreeNode>>>,
291+
sub_root: &Option<Rc<RefCell<TreeNode>>>,
292+
) -> bool {
293+
if root.is_none() {
294+
return false;
295+
}
296+
Self::dfs(root, sub_root)
297+
|| Self::help(&root.as_ref().unwrap().borrow().left, sub_root)
298+
|| Self::help(&root.as_ref().unwrap().borrow().right, sub_root)
299+
}
300+
301+
pub fn is_subtree(
302+
root: Option<Rc<RefCell<TreeNode>>>,
303+
sub_root: Option<Rc<RefCell<TreeNode>>>,
304+
) -> bool {
305+
Self::help(&root, &sub_root)
306+
}
307+
}
308+
```
309+
212310
### **...**
213311

214312
```

‎solution/0500-0599/0572.Subtree of Another Tree/README_EN.md

+98
Original file line numberDiff line numberDiff line change
@@ -195,6 +195,104 @@ var isSubtree = function (root, subRoot) {
195195
};
196196
```
197197

198+
### **TypeScript**
199+
200+
```ts
201+
/**
202+
* Definition for a binary tree node.
203+
* class TreeNode {
204+
* val: number
205+
* left: TreeNode | null
206+
* right: TreeNode | null
207+
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
208+
* this.val = (val===undefined ? 0 : val)
209+
* this.left = (left===undefined ? null : left)
210+
* this.right = (right===undefined ? null : right)
211+
* }
212+
* }
213+
*/
214+
215+
const dfs = (root: TreeNode | null, subRoot: TreeNode | null) => {
216+
if (root == null && subRoot == null) {
217+
return true;
218+
}
219+
if (root == null || subRoot == null || root.val !== subRoot.val) {
220+
return false;
221+
}
222+
return dfs(root.left, subRoot.left) && dfs(root.right, subRoot.right);
223+
};
224+
225+
function isSubtree(root: TreeNode | null, subRoot: TreeNode | null): boolean {
226+
if (root == null) {
227+
return false;
228+
}
229+
return (
230+
dfs(root, subRoot) ||
231+
isSubtree(root.left, subRoot) ||
232+
isSubtree(root.right, subRoot)
233+
);
234+
}
235+
```
236+
237+
### **Rust**
238+
239+
```rust
240+
// Definition for a binary tree node.
241+
// #[derive(Debug, PartialEq, Eq)]
242+
// pub struct TreeNode {
243+
// pub val: i32,
244+
// pub left: Option<Rc<RefCell<TreeNode>>>,
245+
// pub right: Option<Rc<RefCell<TreeNode>>>,
246+
// }
247+
//
248+
// impl TreeNode {
249+
// #[inline]
250+
// pub fn new(val: i32) -> Self {
251+
// TreeNode {
252+
// val,
253+
// left: None,
254+
// right: None
255+
// }
256+
// }
257+
// }
258+
use std::rc::Rc;
259+
use std::cell::RefCell;
260+
impl Solution {
261+
fn dfs(root: &Option<Rc<RefCell<TreeNode>>>, sub_root: &Option<Rc<RefCell<TreeNode>>>) -> bool {
262+
if root.is_none() && sub_root.is_none() {
263+
return true;
264+
}
265+
if root.is_none() || sub_root.is_none() {
266+
return false;
267+
}
268+
let root = root.as_ref().unwrap().borrow();
269+
let sub_root = sub_root.as_ref().unwrap().borrow();
270+
root.val == sub_root.val
271+
&& Self::dfs(&root.left, &sub_root.left)
272+
&& Self::dfs(&root.right, &sub_root.right)
273+
}
274+
275+
fn help(
276+
root: &Option<Rc<RefCell<TreeNode>>>,
277+
sub_root: &Option<Rc<RefCell<TreeNode>>>,
278+
) -> bool {
279+
if root.is_none() {
280+
return false;
281+
}
282+
Self::dfs(root, sub_root)
283+
|| Self::help(&root.as_ref().unwrap().borrow().left, sub_root)
284+
|| Self::help(&root.as_ref().unwrap().borrow().right, sub_root)
285+
}
286+
287+
pub fn is_subtree(
288+
root: Option<Rc<RefCell<TreeNode>>>,
289+
sub_root: Option<Rc<RefCell<TreeNode>>>,
290+
) -> bool {
291+
Self::help(&root, &sub_root)
292+
}
293+
}
294+
```
295+
198296
### **...**
199297

200298
```

‎solution/0500-0599/0572.Subtree of Another Tree/Solution.rs

+54
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,54 @@
1+
// Definition for a binary tree node.
2+
// #[derive(Debug, PartialEq, Eq)]
3+
// pub struct TreeNode {
4+
// pub val: i32,
5+
// pub left: Option<Rc<RefCell<TreeNode>>>,
6+
// pub right: Option<Rc<RefCell<TreeNode>>>,
7+
// }
8+
//
9+
// impl TreeNode {
10+
// #[inline]
11+
// pub fn new(val: i32) -> Self {
12+
// TreeNode {
13+
// val,
14+
// left: None,
15+
// right: None
16+
// }
17+
// }
18+
// }
19+
use std::rc::Rc;
20+
use std::cell::RefCell;
21+
impl Solution {
22+
fn dfs(root: &Option<Rc<RefCell<TreeNode>>>, sub_root: &Option<Rc<RefCell<TreeNode>>>) -> bool {
23+
if root.is_none() && sub_root.is_none() {
24+
return true;
25+
}
26+
if root.is_none() || sub_root.is_none() {
27+
return false;
28+
}
29+
let root = root.as_ref().unwrap().borrow();
30+
let sub_root = sub_root.as_ref().unwrap().borrow();
31+
root.val == sub_root.val
32+
&& Self::dfs(&root.left, &sub_root.left)
33+
&& Self::dfs(&root.right, &sub_root.right)
34+
}
35+
36+
fn help(
37+
root: &Option<Rc<RefCell<TreeNode>>>,
38+
sub_root: &Option<Rc<RefCell<TreeNode>>>,
39+
) -> bool {
40+
if root.is_none() {
41+
return false;
42+
}
43+
Self::dfs(root, sub_root)
44+
|| Self::help(&root.as_ref().unwrap().borrow().left, sub_root)
45+
|| Self::help(&root.as_ref().unwrap().borrow().right, sub_root)
46+
}
47+
48+
pub fn is_subtree(
49+
root: Option<Rc<RefCell<TreeNode>>>,
50+
sub_root: Option<Rc<RefCell<TreeNode>>>,
51+
) -> bool {
52+
Self::help(&root, &sub_root)
53+
}
54+
}

‎solution/0500-0599/0572.Subtree of Another Tree/Solution.ts

+34
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,34 @@
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+
const dfs = (root: TreeNode | null, subRoot: TreeNode | null) => {
16+
if (root == null && subRoot == null) {
17+
return true;
18+
}
19+
if (root == null || subRoot == null || root.val !== subRoot.val) {
20+
return false;
21+
}
22+
return dfs(root.left, subRoot.left) && dfs(root.right, subRoot.right);
23+
};
24+
25+
function isSubtree(root: TreeNode | null, subRoot: TreeNode | null): boolean {
26+
if (root == null) {
27+
return false;
28+
}
29+
return (
30+
dfs(root, subRoot) ||
31+
isSubtree(root.left, subRoot) ||
32+
isSubtree(root.right, subRoot)
33+
);
34+
}

0 commit comments

Comments
 (0)