Question

如何重构这个执行深度优先搜索并返回匹配节点的父节点的函数？

我知道此问题的变体经常出现（例如Multiple mutable borrows when generating a tree structure with a recursive function in Rust，Mut borrow not ending where expected），但我仍然无法弄清楚如何将其修改为有效。我尝试过使用切片，std::mem::drop和添加生命周期参数where 'a: 'b的变体，但我仍然没有想到在没有条件地可变地在一个分支中借用变量然后在另一个分支中使用该变量的情况下编写它。

#[derive(Clone, Debug)]
struct TreeNode {
    id: i32,
    children: Vec<TreeNode>,
}

// Returns a mutable reference to the parent of the node that matches the given id.
fn find_parent_mut<'a>(root: &'a mut TreeNode, id: i32) -> Option<&'a mut TreeNode> {
    for child in root.children.iter_mut() {
        if child.id == id {
            return Some(root);
        } else {
            let descendent_result = find_parent_mut(child, id);
            if descendent_result.is_some() {
                return descendent_result;
            }
        }
    }
    None
}

fn main() {
    let mut tree = TreeNode {
        id: 1,
        children: vec![TreeNode {
                           id: 2,
                           children: vec![TreeNode {
                                              id: 3,
                                              children: vec![],
                                          }],
                       }],
    };
    let a: Option<&mut TreeNode> = find_parent_mut(&mut tree, 3);
    assert_eq!(a.unwrap().id, 2);
}

error[E0499]: cannot borrow `*root` as mutable more than once at a time
  --> src/main.rs:11:25
   |
9  |     for child in root.children.iter_mut() {
   |                  ------------- first mutable borrow occurs here
10 |         if child.id == id {
11 |             return Some(root);
   |                         ^^^^ second mutable borrow occurs here
...
20 | }
   | - first borrow ends here

这是@ huon的建议和持续的编译器错误：

fn find_parent_mut<'a>(root: &'a mut TreeNode, id: i32) -> Option<&'a mut TreeNode> {
    for child in root.children {
        if child.id == id {
            return Some(root);
        }
    }
    for i in 0..root.children.len() {
        let child: &'a mut TreeNode = &mut root.children[i];
        let descendent_result = find_parent_mut(child, id);
        if descendent_result.is_some() {
            return descendent_result;
        }
    }
    None
}

error[E0507]: cannot move out of borrowed content
 --> src/main.rs:9:18
  |
9 |     for child in root.children {
  |                  ^^^^ cannot move out of borrowed content

error[E0499]: cannot borrow `root.children` as mutable more than once at a time
  --> src/main.rs:15:44
   |
15 |         let child: &'a mut TreeNode = &mut root.children[i];
   |                                            ^^^^^^^^^^^^^
   |                                            |
   |                                            second mutable borrow occurs here
   |                                            first mutable borrow occurs here
...
22 | }
   | - first borrow ends here

Answer 1

通过执行搜索，从中记录一些数据，然后在循环外有效地计算返回值，可以在一次传递中执行此操作：

let mut found = Err(());
for (i, child) in root.children.iter_mut().enumerate() {
    if child.id == id {
        found = Ok(None);
        break;
    }  else find_parent_mut(child, id).is_some() {
        found = Ok(Some(i));
        break;
    }
}
match found {
    Ok(Some(i)) => Some(&mut root.children[i]),
    Ok(None) => Some(root),
    Err(()) => None,
}

通过完全避免内循环内部的返回，这可以避免因有条件地返回可变变量（这是你和我的答案在下面遇到的问题）所引起的问题。

陈旧/错误答案：

我目前无法测试我的建议，但我认为解决此问题的最佳方法是将root退回到循环之外。

for child in &mut root.children {
    if child.id == id {
        found = true;
        break
    } ...
}
if found {
    Some(root)
} else {
    None
}

这（希望如此）确保root在被操纵时不会通过children借用。

但是我怀疑主循环中的早期返回可能会干扰，在这种情况下，可能只需要回退到整数和索引：

for i in 0..root.children.len() {
    if root.children[i].id == id {
        return Some(root)
    ...
}

Answer 2

我设法以这种方式工作：

fn find_parent_mut<'a>(root: &'a mut TreeNode, id: i32)
        -> Option<&'a mut TreeNode> {
    if root.children.iter().any(|child| {child.id == id}) {
        return Some(root); 
    }
    for child in &mut root.children {
        match find_parent_mut(child, id) {
            Some(result) => return Some(result),
            None => {}
        }
    }
    None
}

首先在你的第二次尝试中，你写了for child in root.children而不是for child in &mut root.children（注意缺少&mut），这导致root.children被循环使用而不是仅仅迭代结束，因此cannot move out of borrowed content错误。

我还使用any(..)函数以更迭代器的方式折叠它。

对于第二个循环，我并不完全确定发生了什么，显然绑定对变量的引用会使借用检查器混乱。我删除了任何临时变量，现在它编译。</ p>

在深度优先树搜索期间多次可变借用

2 个答案: