Skip to content

Commit 8e88671

Browse files
YangFongYangFong
committed
feat: add solutions to lc problems: No.0101,0106,0116,0117
- No.0101.Symmetric Tree - No.0106.Construct Binary Tree from Inorder and Postorder Traversal - No.0116.Populating Next Right Pointers in Each Node - No.0117.Populating Next Right Pointers in Each Node II
1 parent ab46d51 commit 8e88671

File tree

14 files changed

+942
-41
lines changed

14 files changed

+942
-41
lines changed

‎solution/0100-0199/0101.Symmetric Tree/README.md

+105-5
Original file line numberDiff line numberDiff line change
@@ -148,13 +148,113 @@ public:
148148
* }
149149
*/
150150

151+
const dfs = (root1: TreeNode | null, root2: TreeNode | null) => {
152+
if (root1 == root2) {
153+
return true;
154+
}
155+
if (root1 == null || root2 == null || root1.val != root2.val) {
156+
return false;
157+
}
158+
return dfs(root1.left, root2.right) && dfs(root1.right, root2.left);
159+
};
160+
151161
function isSymmetric(root: TreeNode | null): boolean {
152-
function dfs(root1, root2) {
153-
if (!root1 && !root2) return true;
154-
if (!root1 || !root2 || root1.val != root2.val) return false;
155-
return dfs(root1.left, root2.right) && dfs(root1.right, root2.left);
162+
return dfs(root.left, root.right);
163+
}
164+
```
165+
166+
### **Rust**
167+
168+
```rust
169+
// Definition for a binary tree node.
170+
// #[derive(Debug, PartialEq, Eq)]
171+
// pub struct TreeNode {
172+
// pub val: i32,
173+
// pub left: Option<Rc<RefCell<TreeNode>>>,
174+
// pub right: Option<Rc<RefCell<TreeNode>>>,
175+
// }
176+
//
177+
// impl TreeNode {
178+
// #[inline]
179+
// pub fn new(val: i32) -> Self {
180+
// TreeNode {
181+
// val,
182+
// left: None,
183+
// right: None
184+
// }
185+
// }
186+
// }
187+
use std::rc::Rc;
188+
use std::cell::RefCell;
189+
impl Solution {
190+
fn dfs(root1: &Option<Rc<RefCell<TreeNode>>>, root2: &Option<Rc<RefCell<TreeNode>>>) -> bool {
191+
if root1.is_none() && root2.is_none() {
192+
return true;
193+
}
194+
if root1.is_none() || root2.is_none() {
195+
return false;
196+
}
197+
let node1 = root1.as_ref().unwrap().borrow();
198+
let node2 = root2.as_ref().unwrap().borrow();
199+
node1.val == node2.val
200+
&& Self::dfs(&node1.left, &node2.right)
201+
&& Self::dfs(&node1.right, &node2.left)
202+
}
203+
204+
pub fn is_symmetric(root: Option<Rc<RefCell<TreeNode>>>) -> bool {
205+
let node = root.as_ref().unwrap().borrow();
206+
Self::dfs(&node.left, &node.right)
207+
}
208+
}
209+
```
210+
211+
```rust
212+
// Definition for a binary tree node.
213+
// #[derive(Debug, PartialEq, Eq)]
214+
// pub struct TreeNode {
215+
// pub val: i32,
216+
// pub left: Option<Rc<RefCell<TreeNode>>>,
217+
// pub right: Option<Rc<RefCell<TreeNode>>>,
218+
// }
219+
//
220+
// impl TreeNode {
221+
// #[inline]
222+
// pub fn new(val: i32) -> Self {
223+
// TreeNode {
224+
// val,
225+
// left: None,
226+
// right: None
227+
// }
228+
// }
229+
// }
230+
use std::rc::Rc;
231+
use std::cell::RefCell;
232+
use std::collections::VecDeque;
233+
impl Solution {
234+
pub fn is_symmetric(root: Option<Rc<RefCell<TreeNode>>>) -> bool {
235+
let root = root.unwrap();
236+
let mut node = root.as_ref().borrow_mut();
237+
let mut queue = VecDeque::new();
238+
queue.push_back([node.left.take(), node.right.take()]);
239+
while let Some([root1, root2]) = queue.pop_front() {
240+
if root1.is_none() && root2.is_none() {
241+
continue;
242+
}
243+
if root1.is_none() || root2.is_none() {
244+
return false;
245+
}
246+
if let (Some(node1), Some(node2)) = (root1, root2) {
247+
let mut node1 = node1.as_ref().borrow_mut();
248+
let mut node2 = node2.as_ref().borrow_mut();
249+
if node1.val != node2.val {
250+
return false;
251+
}
252+
queue.push_back([node1.left.take(), node2.right.take()]);
253+
queue.push_back([node1.right.take(), node2.left.take()]);
254+
}
255+
}
256+
true
156257
}
157-
return dfs(root, root);
158258
}
159259
```
160260

‎solution/0100-0199/0101.Symmetric Tree/README_EN.md

+105-5
Original file line numberDiff line numberDiff line change
@@ -137,13 +137,113 @@ public:
137137
* }
138138
*/
139139

140+
const dfs = (root1: TreeNode | null, root2: TreeNode | null) => {
141+
if (root1 == root2) {
142+
return true;
143+
}
144+
if (root1 == null || root2 == null || root1.val != root2.val) {
145+
return false;
146+
}
147+
return dfs(root1.left, root2.right) && dfs(root1.right, root2.left);
148+
};
149+
140150
function isSymmetric(root: TreeNode | null): boolean {
141-
function dfs(root1, root2) {
142-
if (!root1 && !root2) return true;
143-
if (!root1 || !root2 || root1.val != root2.val) return false;
144-
return dfs(root1.left, root2.right) && dfs(root1.right, root2.left);
151+
return dfs(root.left, root.right);
152+
}
153+
```
154+
155+
### **Rust**
156+
157+
```rust
158+
// Definition for a binary tree node.
159+
// #[derive(Debug, PartialEq, Eq)]
160+
// pub struct TreeNode {
161+
// pub val: i32,
162+
// pub left: Option<Rc<RefCell<TreeNode>>>,
163+
// pub right: Option<Rc<RefCell<TreeNode>>>,
164+
// }
165+
//
166+
// impl TreeNode {
167+
// #[inline]
168+
// pub fn new(val: i32) -> Self {
169+
// TreeNode {
170+
// val,
171+
// left: None,
172+
// right: None
173+
// }
174+
// }
175+
// }
176+
use std::rc::Rc;
177+
use std::cell::RefCell;
178+
impl Solution {
179+
fn dfs(root1: &Option<Rc<RefCell<TreeNode>>>, root2: &Option<Rc<RefCell<TreeNode>>>) -> bool {
180+
if root1.is_none() && root2.is_none() {
181+
return true;
182+
}
183+
if root1.is_none() || root2.is_none() {
184+
return false;
185+
}
186+
let node1 = root1.as_ref().unwrap().borrow();
187+
let node2 = root2.as_ref().unwrap().borrow();
188+
node1.val == node2.val
189+
&& Self::dfs(&node1.left, &node2.right)
190+
&& Self::dfs(&node1.right, &node2.left)
191+
}
192+
193+
pub fn is_symmetric(root: Option<Rc<RefCell<TreeNode>>>) -> bool {
194+
let node = root.as_ref().unwrap().borrow();
195+
Self::dfs(&node.left, &node.right)
196+
}
197+
}
198+
```
199+
200+
```rust
201+
// Definition for a binary tree node.
202+
// #[derive(Debug, PartialEq, Eq)]
203+
// pub struct TreeNode {
204+
// pub val: i32,
205+
// pub left: Option<Rc<RefCell<TreeNode>>>,
206+
// pub right: Option<Rc<RefCell<TreeNode>>>,
207+
// }
208+
//
209+
// impl TreeNode {
210+
// #[inline]
211+
// pub fn new(val: i32) -> Self {
212+
// TreeNode {
213+
// val,
214+
// left: None,
215+
// right: None
216+
// }
217+
// }
218+
// }
219+
use std::rc::Rc;
220+
use std::cell::RefCell;
221+
use std::collections::VecDeque;
222+
impl Solution {
223+
pub fn is_symmetric(root: Option<Rc<RefCell<TreeNode>>>) -> bool {
224+
let root = root.unwrap();
225+
let mut node = root.as_ref().borrow_mut();
226+
let mut queue = VecDeque::new();
227+
queue.push_back([node.left.take(), node.right.take()]);
228+
while let Some([root1, root2]) = queue.pop_front() {
229+
if root1.is_none() && root2.is_none() {
230+
continue;
231+
}
232+
if root1.is_none() || root2.is_none() {
233+
return false;
234+
}
235+
if let (Some(node1), Some(node2)) = (root1, root2) {
236+
let mut node1 = node1.as_ref().borrow_mut();
237+
let mut node2 = node2.as_ref().borrow_mut();
238+
if node1.val != node2.val {
239+
return false;
240+
}
241+
queue.push_back([node1.left.take(), node2.right.take()]);
242+
queue.push_back([node1.right.take(), node2.left.take()]);
243+
}
244+
}
245+
true
145246
}
146-
return dfs(root, root);
147247
}
148248
```
149249

‎solution/0100-0199/0101.Symmetric Tree/Solution.rs

+40
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,40 @@
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(root1: &Option<Rc<RefCell<TreeNode>>>, root2: &Option<Rc<RefCell<TreeNode>>>) -> bool {
23+
if root1.is_none() && root2.is_none() {
24+
return true;
25+
}
26+
if root1.is_none() || root2.is_none() {
27+
return false;
28+
}
29+
let node1 = root1.as_ref().unwrap().borrow();
30+
let node2 = root2.as_ref().unwrap().borrow();
31+
node1.val == node2.val
32+
&& Self::dfs(&node1.left, &node2.right)
33+
&& Self::dfs(&node1.right, &node2.left)
34+
}
35+
36+
pub fn is_symmetric(root: Option<Rc<RefCell<TreeNode>>>) -> bool {
37+
let node = root.as_ref().unwrap().borrow();
38+
Self::dfs(&node.left, &node.right)
39+
}
40+
}

‎solution/0100-0199/0101.Symmetric Tree/Solution.ts

+11-6
Original file line numberDiff line numberDiff line change
@@ -12,11 +12,16 @@
1212
* }
1313
*/
1414

15-
function isSymmetric(root: TreeNode | null): boolean {
16-
function dfs(root1, root2) {
17-
if (!root1 && !root2) return true;
18-
if (!root1 || !root2 || root1.val != root2.val) return false;
19-
return dfs(root1.left, root2.right) && dfs(root1.right, root2.left);
15+
const dfs = (root1: TreeNode | null, root2: TreeNode | null) => {
16+
if (root1 == root2) {
17+
return true;
18+
}
19+
if (root1 == null || root2 == null || root1.val != root2.val) {
20+
return false;
2021
}
21-
return dfs(root, root);
22+
return dfs(root1.left, root2.right) && dfs(root1.right, root2.left);
23+
};
24+
25+
function isSymmetric(root: TreeNode | null): boolean {
26+
return dfs(root.left, root.right);
2227
}

0 commit comments

Comments
 (0)