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 30dabe0

Browse files
feat: update solutions to lc problem: No.0257 (doocs#1592)
No.0257.Binary Tree Paths
1 parent 2bacf12 commit 30dabe0

File tree

8 files changed

+314
-253
lines changed

8 files changed

+314
-253
lines changed

‎solution/0200-0299/0210.Course Schedule II/README.md‎

Lines changed: 7 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -57,13 +57,16 @@
5757

5858
**方法一:拓扑排序**
5959

60-
对于本题,我们可以将课程看作图中的节点,先修课程看作图中的边,那么我们可以将本题转化为判断有向图中是否存在环。
60+
我们创建一个邻接表 $g,ドル用于存储每个节点的后继节点,同时还需要一个数组 $indeg$ 存储每个节点的入度。在构建邻接表的同时,我们也统计每个节点的入度。当入度为 0ドル$ 的节点代表没有任何前置课程,可以直接学习,我们将其加入队列 $q$ 中。
6161

62-
具体地,我们可以使用拓扑排序的思想,对于每个入度为 0ドル$ 的节点,我们将其出度的节点的入度减 1ドル,ドル直到所有节点都被遍历到。
62+
当队列 $q$ 不为空的时候,我们取出队首的节点 $i$:
6363

64-
如果所有节点都被遍历到,说明图中不存在环,那么我们就可以完成所有课程的学习;否则,我们就无法完成所有课程的学习。
64+
- 我们将 $i$ 放入答案中;
65+
- 接下来,我们将 $i$ 的所有后继节点的入度减少 1ドル$。如果发现某个后继节点 $j$ 的入度变为 0ドル,ドル则将 $j$ 放入队列 $q$ 中。
6566

66-
时间复杂度 $O(n + m),ドル空间复杂度 $O(n + m)$。其中 $n$ 和 $m$ 分别为课程数和先修课程数。
67+
在广度优先搜索的结束时,如果答案中包含了这 $n$ 个节点,那么我们就找到了一种拓扑排序,否则说明图中存在环,也就不存在拓扑排序了。
68+
69+
时间复杂度 $O(n + m),ドル空间复杂度 $O(n + m)$。其中 $n$ 和 $m$ 分别是节点数和边数。
6770

6871
<!-- tabs:start -->
6972

‎solution/0200-0299/0257.Binary Tree Paths/README.md‎

Lines changed: 94 additions & 72 deletions
Original file line numberDiff line numberDiff line change
@@ -38,7 +38,11 @@
3838

3939
<!-- 这里可写通用的实现逻辑 -->
4040

41-
深度优先搜索+路径记录。
41+
**方法一:DFS**
42+
43+
我们可以使用深度优先搜索的方法遍历整棵二叉树,每一次我们将当前的节点添加到路径中。如果当前的节点是叶子节点,则我们将整个路径加入到答案中。否则我们继续递归遍历节点的孩子节点。最后当我们递归结束返回到当前节点时,我们需要将当前节点从路径中删除。
44+
45+
时间复杂度 $O(n^2),ドル空间复杂度 $O(n)$。其中 $n$ 是二叉树的节点数。
4246

4347
<!-- tabs:start -->
4448

@@ -54,19 +58,20 @@
5458
# self.left = left
5559
# self.right = right
5660
class Solution:
57-
def binaryTreePaths(self, root: TreeNode) -> List[str]:
58-
def dfs(root):
61+
def binaryTreePaths(self, root: Optional[TreeNode]) -> List[str]:
62+
def dfs(root: Optional[TreeNode]):
5963
if root is None:
6064
return
6165
t.append(str(root.val))
6266
if root.left is None and root.right is None:
63-
ans.append('->'.join(t))
64-
dfs(root.left)
65-
dfs(root.right)
67+
ans.append("->".join(t))
68+
else:
69+
dfs(root.left)
70+
dfs(root.right)
6671
t.pop()
6772

68-
t = []
6973
ans = []
74+
t = []
7075
dfs(root)
7176
return ans
7277
```
@@ -92,12 +97,10 @@ class Solution:
9297
* }
9398
*/
9499
class Solution {
95-
private List<String> ans;
96-
private List<String> t;
100+
private List<String> ans=newArrayList<>();
101+
private List<String> t=newArrayList<>();
97102

98103
public List<String> binaryTreePaths(TreeNode root) {
99-
ans = new ArrayList<>();
100-
t = new ArrayList<>();
101104
dfs(root);
102105
return ans;
103106
}
@@ -109,45 +112,62 @@ class Solution {
109112
t.add(root.val + "");
110113
if (root.left == null && root.right == null) {
111114
ans.add(String.join("->", t));
115+
} else {
116+
dfs(root.left);
117+
dfs(root.right);
112118
}
113-
dfs(root.left);
114-
dfs(root.right);
115119
t.remove(t.size() - 1);
116120
}
117121
}
118122
```
119123

120-
### **TypeScript**
124+
### **C++**
121125

122-
```ts
126+
```cpp
123127
/**
124128
* Definition for a binary tree node.
125-
* class TreeNode {
126-
* val: number
127-
* left: TreeNode | null
128-
* right: TreeNode | null
129-
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
130-
* this.val = (val===undefined ? 0 : val)
131-
* this.left = (left===undefined ? null : left)
132-
* this.right = (right===undefined ? null : right)
133-
* }
134-
* }
129+
* struct TreeNode {
130+
* int val;
131+
* TreeNode *left;
132+
* TreeNode *right;
133+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
134+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
135+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
136+
* };
135137
*/
138+
class Solution {
139+
public:
140+
vector<string> binaryTreePaths(TreeNode* root) {
141+
vector<string> ans;
142+
vector<string> t;
143+
function<void(TreeNode*)> dfs = [&](TreeNode* root) {
144+
if (!root) {
145+
return;
146+
}
147+
t.push_back(to_string(root->val));
148+
if (!root->left && !root->right) {
149+
ans.push_back(join(t));
150+
} else {
151+
dfs(root->left);
152+
dfs(root->right);
153+
}
154+
t.pop_back();
155+
};
156+
dfs(root);
157+
return ans;
158+
}
136159

137-
function binaryTreePaths(root: TreeNode | null): string[] {
138-
let ans = [];
139-
let t = [];
140-
function dfs(root) {
141-
if (!root) return;
142-
t.push(String(root.val));
143-
if (!root.left && !root.right) ans.push(t.join('->'));
144-
dfs(root.left);
145-
dfs(root.right);
146-
t.pop();
160+
string join(vector<string>& t, string sep = "->") {
161+
string ans;
162+
for (int i = 0; i < t.size(); ++i) {
163+
if (i > 0) {
164+
ans += sep;
165+
}
166+
ans += t[i];
167+
}
168+
return ans;
147169
}
148-
dfs(root);
149-
return ans;
150-
}
170+
};
151171
```
152172

153173
### **Go**
@@ -161,61 +181,63 @@ function binaryTreePaths(root: TreeNode | null): string[] {
161181
* Right *TreeNode
162182
* }
163183
*/
164-
func binaryTreePaths(root *TreeNode) []string {
165-
var ans []string
166-
var t []string
167-
var dfs func(root *TreeNode)
184+
func binaryTreePaths(root *TreeNode) (ans []string) {
185+
t := []string{}
186+
var dfs func(*TreeNode)
168187
dfs = func(root *TreeNode) {
169188
if root == nil {
170189
return
171190
}
172191
t = append(t, strconv.Itoa(root.Val))
173192
if root.Left == nil && root.Right == nil {
174193
ans = append(ans, strings.Join(t, "->"))
194+
} else {
195+
dfs(root.Left)
196+
dfs(root.Right)
175197
}
176-
dfs(root.Left)
177-
dfs(root.Right)
178198
t = t[:len(t)-1]
179199
}
180200
dfs(root)
181-
return ans
201+
return
182202
}
183203
```
184204

185-
### **C++**
205+
### **TypeScript**
186206

187-
```cpp
207+
```ts
188208
/**
189209
* Definition for a binary tree node.
190-
* struct TreeNode {
191-
* int val;
192-
* TreeNode *left;
193-
* TreeNode *right;
194-
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
195-
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
196-
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
197-
* };
210+
* class TreeNode {
211+
* val: number
212+
* left: TreeNode | null
213+
* right: TreeNode | null
214+
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
215+
* this.val = (val===undefined ? 0 : val)
216+
* this.left = (left===undefined ? null : left)
217+
* this.right = (right===undefined ? null : right)
218+
* }
219+
* }
198220
*/
199-
class Solution {
200-
public:
201-
vector<string> ans;
202221

203-
vector<string> binaryTreePaths(TreeNode* root) {
204-
dfs(root, "");
205-
return ans;
206-
}
207-
208-
void dfs(TreeNode* root, string t) {
209-
t += to_string(root->val);
210-
if (!root->left && !root->right) {
211-
ans.push_back(t);
222+
function binaryTreePaths(root: TreeNode | null): string[] {
223+
const ans: string[] = [];
224+
const t: number[] = [];
225+
const dfs = (root: TreeNode | null) => {
226+
if (!root) {
212227
return;
213228
}
214-
t += "->";
215-
if (root->left) dfs(root->left, t);
216-
if (root->right) dfs(root->right, t);
217-
}
218-
};
229+
t.push(root.val);
230+
if (!root.left && !root.right) {
231+
ans.push(t.join('->'));
232+
} else {
233+
dfs(root.left);
234+
dfs(root.right);
235+
}
236+
t.pop();
237+
};
238+
dfs(root);
239+
return ans;
240+
}
219241
```
220242

221243
### **...**

0 commit comments

Comments
(0)

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