Skip to content

Commit 8cdca7c

Browse files
yanglbmeyanglbme
committed
feat: update leetcode solutions: No.0144, No.0145
1 parent d9c8ead commit 8cdca7c

File tree

4 files changed

+297
-2
lines changed

4 files changed

+297
-2
lines changed

‎solution/0100-0199/0144.Binary Tree Preorder Traversal/README.md

+79-1
Original file line numberDiff line numberDiff line change
@@ -25,14 +25,25 @@
2525

2626
<!-- 这里可写通用的实现逻辑 -->
2727

28-
递归遍历。
28+
递归遍历或利用栈实现非递归遍历。
29+
30+
非递归的思路如下：
31+
32+
1. 定义一个栈，先将根节点压入栈
33+
2. 若栈不为空，每次从栈中弹出一个节点
34+
3. 处理该节点
35+
4. 先把节点右孩子压入栈，接着把节点左孩子压入栈（如果有孩子节点）
36+
5. 重复 2-4
37+
6. 返回结果
2938

3039
<!-- tabs:start -->
3140

3241
### **Python3**
3342

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

45+
递归：
46+
3647
```python
3748
# Definition for a binary tree node.
3849
# class TreeNode:
@@ -52,10 +63,36 @@ class Solution:
5263
return res
5364
```
5465

66+
非递归：
67+
68+
```python
69+
# Definition for a binary tree node.
70+
# class TreeNode:
71+
# def __init__(self, val=0, left=None, right=None):
72+
# self.val = val
73+
# self.left = left
74+
# self.right = right
75+
class Solution:
76+
def preorderTraversal(self, root: TreeNode) -> List[int]:
77+
res = []
78+
if root:
79+
s = [root]
80+
while s:
81+
node = s.pop()
82+
res.append(node.val)
83+
if node.right:
84+
s.append(node.right)
85+
if node.left:
86+
s.append(node.left)
87+
return res
88+
```
89+
5590
### **Java**
5691

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

94+
递归：
95+
5996
```java
6097
/**
6198
* Definition for a binary tree node.
@@ -92,6 +129,47 @@ class Solution {
92129
}
93130
```
94131

132+
非递归：
133+
134+
```java
135+
/**
136+
* Definition for a binary tree node.
137+
* public class TreeNode {
138+
* int val;
139+
* TreeNode left;
140+
* TreeNode right;
141+
* TreeNode() {}
142+
* TreeNode(int val) { this.val = val; }
143+
* TreeNode(int val, TreeNode left, TreeNode right) {
144+
* this.val = val;
145+
* this.left = left;
146+
* this.right = right;
147+
* }
148+
* }
149+
*/
150+
class Solution {
151+
public List<Integer> preorderTraversal(TreeNode root) {
152+
if (root == null) {
153+
return Collections.emptyList();
154+
}
155+
List<Integer> res = new ArrayList<>();
156+
Deque<TreeNode> s = new ArrayDeque<>();
157+
s.push(root);
158+
while (!s.isEmpty()) {
159+
TreeNode node = s.pop();
160+
res.add(node.val);
161+
if (node.right != null) {
162+
s.push(node.right);
163+
}
164+
if (node.left != null) {
165+
s.push(node.left);
166+
}
167+
}
168+
return res;
169+
}
170+
}
171+
```
172+
95173
### **...**
96174

97175
```

‎solution/0100-0199/0144.Binary Tree Preorder Traversal/README_EN.md

+69
Original file line numberDiff line numberDiff line change
@@ -36,6 +36,8 @@
3636

3737
### **Python3**
3838

39+
Recursive:
40+
3941
```python
4042
# Definition for a binary tree node.
4143
# class TreeNode:
@@ -55,8 +57,34 @@ class Solution:
5557
return res
5658
```
5759

60+
Non-recursive:
61+
62+
```python
63+
# Definition for a binary tree node.
64+
# class TreeNode:
65+
# def __init__(self, val=0, left=None, right=None):
66+
# self.val = val
67+
# self.left = left
68+
# self.right = right
69+
class Solution:
70+
def preorderTraversal(self, root: TreeNode) -> List[int]:
71+
res = []
72+
if root:
73+
s = [root]
74+
while s:
75+
node = s.pop()
76+
res.append(node.val)
77+
if node.right:
78+
s.append(node.right)
79+
if node.left:
80+
s.append(node.left)
81+
return res
82+
```
83+
5884
### **Java**
5985

86+
Recursive:
87+
6088
```java
6189
/**
6290
* Definition for a binary tree node.
@@ -93,6 +121,47 @@ class Solution {
93121
}
94122
```
95123

124+
Non-recursive:
125+
126+
```java
127+
/**
128+
* Definition for a binary tree node.
129+
* public class TreeNode {
130+
* int val;
131+
* TreeNode left;
132+
* TreeNode right;
133+
* TreeNode() {}
134+
* TreeNode(int val) { this.val = val; }
135+
* TreeNode(int val, TreeNode left, TreeNode right) {
136+
* this.val = val;
137+
* this.left = left;
138+
* this.right = right;
139+
* }
140+
* }
141+
*/
142+
class Solution {
143+
public List<Integer> preorderTraversal(TreeNode root) {
144+
if (root == null) {
145+
return Collections.emptyList();
146+
}
147+
List<Integer> res = new ArrayList<>();
148+
Deque<TreeNode> s = new ArrayDeque<>();
149+
s.push(root);
150+
while (!s.isEmpty()) {
151+
TreeNode node = s.pop();
152+
res.add(node.val);
153+
if (node.right != null) {
154+
s.push(node.right);
155+
}
156+
if (node.left != null) {
157+
s.push(node.left);
158+
}
159+
}
160+
return res;
161+
}
162+
}
163+
```
164+
96165
### **...**
97166

98167
```

‎solution/0100-0199/0145.Binary Tree Postorder Traversal/README.md

+78-1
Original file line numberDiff line numberDiff line change
@@ -24,14 +24,22 @@
2424

2525
<!-- 这里可写通用的实现逻辑 -->
2626

27-
递归遍历。
27+
递归遍历或利用栈实现非递归遍历。
28+
29+
非递归的思路如下：
30+
31+
先序遍历的顺序是：头、左、右，如果我们改变左右孩子的顺序，就能将顺序变成：头、右、左。
32+
33+
我们先不打印头节点，而是存放到另一个收集栈 s2 中，最后遍历结束，输出收集栈元素，即是后序遍历：左、右、头。
2834

2935
<!-- tabs:start -->
3036

3137
### **Python3**
3238

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

41+
递归：
42+
3543
```python
3644
# Definition for a binary tree node.
3745
# class TreeNode:
@@ -51,10 +59,37 @@ class Solution:
5159
return res
5260
```
5361

62+
非递归：
63+
64+
```python
65+
# Definition for a binary tree node.
66+
# class TreeNode:
67+
# def __init__(self, val=0, left=None, right=None):
68+
# self.val = val
69+
# self.left = left
70+
# self.right = right
71+
class Solution:
72+
def postorderTraversal(self, root: TreeNode) -> List[int]:
73+
if not root:
74+
return []
75+
s1 = [root]
76+
s2 = []
77+
while s1:
78+
node = s1.pop()
79+
s2.append(node.val)
80+
if node.left:
81+
s1.append(node.left)
82+
if node.right:
83+
s1.append(node.right)
84+
return s2[::-1]
85+
```
86+
5487
### **Java**
5588

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

91+
递归：
92+
5893
```java
5994
/**
6095
* Definition for a binary tree node.
@@ -91,6 +126,48 @@ class Solution {
91126
}
92127
```
93128

129+
非递归：
130+
131+
```java
132+
/**
133+
* Definition for a binary tree node.
134+
* public class TreeNode {
135+
* int val;
136+
* TreeNode left;
137+
* TreeNode right;
138+
* TreeNode() {}
139+
* TreeNode(int val) { this.val = val; }
140+
* TreeNode(int val, TreeNode left, TreeNode right) {
141+
* this.val = val;
142+
* this.left = left;
143+
* this.right = right;
144+
* }
145+
* }
146+
*/
147+
class Solution {
148+
public List<Integer> postorderTraversal(TreeNode root) {
149+
if (root == null) {
150+
return Collections.emptyList();
151+
}
152+
Deque<TreeNode> s1 = new ArrayDeque<>();
153+
List<Integer> s2 = new ArrayList<>();
154+
s1.push(root);
155+
while (!s1.isEmpty()) {
156+
TreeNode node = s1.pop();
157+
s2.add(node.val);
158+
if (node.left != null) {
159+
s1.push(node.left);
160+
}
161+
if (node.right != null) {
162+
s1.push(node.right);
163+
}
164+
}
165+
Collections.reverse(s2);
166+
return s2;
167+
}
168+
}
169+
```
170+
94171
### **...**
95172

96173
```

0 commit comments

Comments
 (0)