xmengnet/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2024-12-24 09:46:29 +08:00
Code Issues Projects Releases Packages Wiki Activity Actions

Fix the code of preorder_traversal_iii_compact

Browse source
This commit is contained in:
krahets 2023-07-21 22:08:26 +08:00
parent 075c3abf88
commit bba62bbe75
11 changed files with 19 additions and 10 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
codes/cpp/chapter_backtracking/preorder_traversal_iii_compact.cpp
View file

@ -20,6 +20,7 @@ void preOrder(TreeNode *root) {
if (root->val == 7) {
// 记录解
res.push_back(path);
path.pop_back();
return;
}
preOrder(root->left);

3
codes/csharp/chapter_backtracking/preorder_traversal_iii_compact.cs
View file

@ -21,6 +21,7 @@ public class preorder_traversal_iii_compact {
if (root.val == 7) {
// 记录解
res.Add(new List<TreeNode>(path));
path.RemoveAt(path.Count - 1);
return;
}
preOrder(root.left);
@ -40,7 +41,7 @@ public class preorder_traversal_iii_compact {
res = new List<List<TreeNode>>();
preOrder(root);
Console.WriteLine("\n输出所有根节点到节点 7 的路径，且路径中不包含值为 3 的节点");
Console.WriteLine("\n输出所有根节点到节点 7 的路径，路径中不包含值为 3 的节点，仅包含一个值为 7 的节点");
foreach (List<TreeNode> path in res) {
PrintUtil.PrintList(path.Select(p => p.val).ToList());
}

1
codes/go/chapter_backtracking/preorder_traversal_iii_compact.go
View file

@ -19,6 +19,7 @@ func preOrderIII(root *TreeNode, res *[][]*TreeNode, path *[]*TreeNode) {
if int(root.Val) == 7 {
// 记录解
*res = append(*res, *path)
*path = (*path)[:len(*path)-1]
return
}
preOrderIII(root.Left, res, path)

4
codes/go/chapter_backtracking/preorder_traversal_test.go
View file

@ -59,7 +59,7 @@ func TestPreorderTraversalIIICompact(t *testing.T) {
res := make([][]*TreeNode, 0)
preOrderIII(root, &res, &path)
fmt.Println("\n输出所有根节点到节点 7 的路径，且路径中不包含值为 3 的节点")
fmt.Println("\n输出所有根节点到节点 7 的路径，路径中不包含值为 3 的节点，仅包含一个值为 7 的节点")
for _, path := range res {
for _, node := range path {
fmt.Printf("%v ", node.Val)
@ -81,7 +81,7 @@ func TestPreorderTraversalIIITemplate(t *testing.T) {
choices = append(choices, root)
backtrackIII(&state, &choices, &res)
fmt.Println("\n输出所有根节点到节点 7 的路径，且路径中不包含值为 3 的节点")
fmt.Println("\n输出所有根节点到节点 7 的路径，路径中不包含值为 3 的节点，仅包含一个值为 7 的节点")
for _, path := range res {
for _, node := range path {
fmt.Printf("%v ", node.Val)

3
codes/java/chapter_backtracking/preorder_traversal_iii_compact.java
View file

@ -24,6 +24,7 @@ public class preorder_traversal_iii_compact {
if (root.val == 7) {
// 记录解
res.add(new ArrayList<>(path));
path.remove(path.size() - 1);
return;
}
preOrder(root.left);
@ -42,7 +43,7 @@ public class preorder_traversal_iii_compact {
res = new ArrayList<>();
preOrder(root);
System.out.println("\n输出所有根节点到节点 7 的路径，且路径中不包含值为 3 的节点");
System.out.println("\n输出所有根节点到节点 7 的路径，路径中不包含值为 3 的节点，仅包含一个值为 7 的节点");
for (List<TreeNode> path : res) {
List<Integer> vals = new ArrayList<>();
for (TreeNode node : path) {

3
codes/javascript/chapter_backtracking/preorder_traversal_iii_compact.js
View file

@ -18,6 +18,7 @@ function preOrder(root, path, res) {
if (root.val === 7) {
// 记录解
res.push([...path]);
path.pop();
return;
}
preOrder(root.left, path, res);
@ -36,7 +37,7 @@ const path = [];
const res = [];
preOrder(root, path, res);
console.log('\n输出所有根节点到节点 7 的路径，且路径中不包含值为 3 的节点');
console.log('\n输出所有根节点到节点 7 的路径，路径中不包含值为 3 的节点，仅包含一个值为 7 的节点');
res.forEach((path) => {
console.log(path.map((node) => node.val));
});

3
codes/python/chapter_backtracking/preorder_traversal_iii_compact.py
View file

@ -20,6 +20,7 @@ def pre_order(root: TreeNode) -> None:
if root.val == 7:
# 记录解
res.append(list(path))
path.pop()
return
pre_order(root.left)
pre_order(root.right)
@ -38,6 +39,6 @@ if __name__ == "__main__":
res = list[list[TreeNode]]()
pre_order(root)
print("\n输出所有根节点到节点 7 的路径，且路径中不包含值为 3 的节点")
print("\n输出所有根节点到节点 7 的路径，路径中不包含值为 3 的节点，仅包含一个值为 7 的节点")
for path in res:
print([node.val for node in path])

3
codes/rust/chapter_backtracking/preorder_traversal_iii_compact.rs
View file

@ -21,6 +21,7 @@ fn pre_order(res: &mut Vec<Vec<Rc<RefCell<TreeNode>>>>, path: &mut Vec<Rc<RefCel
if node.borrow().val == 7 {
// 记录解
res.push(path.clone());
path.remove(path.len() - 1);
return;
}
pre_order(res, path, node.borrow().left.clone());
@ -41,7 +42,7 @@ pub fn main() {
let mut res = Vec::new();
pre_order(&mut res, &mut path, root);
println!("\n输出所有根节点到节点 7 的路径，且路径中不包含值为 3 的节点");
println!("\n输出所有根节点到节点 7 的路径，路径中不包含值为 3 的节点，仅包含一个值为 7 的节点");
for path in res {
let mut vals = Vec::new();
for node in path {

3
codes/swift/chapter_backtracking/preorder_traversal_iii_compact.swift
View file

@ -20,6 +20,7 @@ func preOrder(root: TreeNode?) {
if root.val == 7 {
// 记录解
res.append(path)
path.removeLast()
return
}
preOrder(root: root.left)
@ -41,7 +42,7 @@ enum PreorderTraversalIIICompact {
res = []
preOrder(root: root)
print("\n输出所有根节点到节点 7 的路径，且路径中不包含值为 3 的节点")
print("\n输出所有根节点到节点 7 的路径，路径中不包含值为 3 的节点，仅包含一个值为 7 的节点")
for path in res {
var vals: [Int] = []
for node in path {

2
codes/swift/chapter_backtracking/preorder_traversal_iii_template.swift
View file

@ -65,7 +65,7 @@ enum PreorderTraversalIIITemplate {
var res: [[TreeNode]] = []
backtrack(state: &state, choices: [root].compactMap { $0 }, res: &res)
print("\n输出所有根节点到节点 7 的路径，且路径中不包含值为 3 的节点")
print("\n输出所有根节点到节点 7 的路径，路径中不包含值为 3 的节点，仅包含一个值为 7 的节点")
for path in res {
var vals: [Int] = []
for node in path {

3
codes/typescript/chapter_backtracking/preorder_traversal_iii_compact.ts
View file

@ -23,6 +23,7 @@ function preOrder(
if (root.val === 7) {
// 记录解
res.push([...path]);
path.pop();
return;
}
preOrder(root.left, path, res);
@ -41,7 +42,7 @@ const path: TreeNode[] = [];
const res: TreeNode[][] = [];
preOrder(root, path, res);
console.log('\n输出所有根节点到节点 7 的路径，且路径中不包含值为 3 的节点');
console.log('\n输出所有根节点到节点 7 的路径，路径中不包含值为 3 的节点，仅包含一个值为 7 的节点');
res.forEach((path) => {
console.log(path.map((node) => node.val));
});