一次不能多次借用可变 + 变量是可变队列

在：run_subsequent_scripts

• 更改为 .let mut child_node: ScriptTreelet child_node: ScriptTree
  • 声明而不初始化它，这允许稍后分配给它而无需可变借用它。child_node
• 更改为 .queue.push(&mut root)queue.push(root)
  • 将对 root 的不可变引用传递给队列，这应该允许我们稍后可变地借用它。
• 更改为 .let mut neighbor_nodes: Vec<ScriptTree> = Vec::new()let mut neighbor_nodes = Vec::with_capacity(neighbors.len())
  • 预先分配具有足够容量的neighbor_nodes向量以容纳所有邻居，这应该避免任何可能导致借贷问题的重新分配。
• 更改循环访问要改用的向量。neighbor_nodesfor child_node in node_neighbors.into_iter()
  • 使用向量，并允许在不借用它们的情况下将值移出其中。node_neighborsScriptTree

在：update_tree

• 更改为 .for mut child in &subtree.childrenfor child in &mut subtree.children
  • 允许可变地借用子树的子级，这是更新子树所必需的。

更新了包含示例输入的代码 （Rust Playground）：

use std::collections::HashMap;

#[derive(Debug, Clone, Hash, PartialEq, Eq)]
struct NodeId(u32);

#[derive(Debug)]
struct PageGraph;

#[derive(Debug, Clone)]
struct ScriptInfo(u32, u32, u32);

#[derive(Debug, Clone)]
struct ScriptTree {
    script_info: ScriptInfo,
    children: Vec<ScriptTree>,
}

impl ScriptTree {
    fn new(a: u32, b: u32, c: u32) -> Self {
        ScriptTree {
            script_info: ScriptInfo(a, b, c),
            children: Vec::new(),
        }
    }

    fn add_child(&mut self, child: ScriptTree) {
        self.children.push(child);
    }
}

enum Action {
    Script,
}

fn get_injected_scripts(
    _graph: &PageGraph,
    _node_id: u32,
    _action: &Action,
) -> Vec<NodeId> {
    vec![NodeId(1), NodeId(2), NodeId(3)]
}

fn get_script_info(_graph: &PageGraph, _node_id: NodeId) -> ScriptInfo {
    ScriptInfo(1, 2, 3)
}

struct Query {
    id: NodeId,
}

struct Example {
    query: Query,
}

impl Example {
    fn run_subsequent_scripts(&self, graph: &PageGraph, depth: usize) -> ScriptTree {
        let mut level: usize = 0;
        let mut visited: HashMap<NodeId, bool> = HashMap::new();
        let mut queue = vec![];
        let script_info = get_script_info(graph, self.query.id.clone());
        let mut root = ScriptTree::new(script_info.0, script_info.1, script_info.2);

        visited.insert(self.query.id.clone(), true);
        queue.push(root.clone());

        let mut level_meter: Vec<NodeId> = Vec::new();

        while !queue.is_empty() && level < depth {
            let level_size = queue.len();

            for _ in 0..level_size {
                let mut neighbor_nodes = Vec::new();
                let parent_node = queue.remove(0);
                let neighbors = get_injected_scripts(&graph, parent_node.script_info.0, &Action::Script);

                for child_id in neighbors {
                    if !visited.contains_key(&child_id) {
                        visited.insert(child_id.clone(), true);
                        let child_script_info = get_script_info(graph, child_id.clone());
                        let child_node = ScriptTree::new(
                            child_script_info.0,
                            child_script_info.1,
                            child_script_info.2,
                        );
                        queue.push(child_node.clone());
                        neighbor_nodes.push(child_node);
                        level_meter.push(child_id);
                    }
                }
                self.update_tree(&mut root, &parent_node, neighbor_nodes);
            }
            level += 1;
        }
        root
    }

    fn update_tree(
        &self,
        subtree: &mut ScriptTree,
        parent_node: &ScriptTree,
        node_neighbors: Vec<ScriptTree>,
    ) {
        if subtree.script_info.0 == parent_node.script_info.0 {
            for child_node in node_neighbors {
                subtree.add_child(child_node);
            }
        } else {
            for child in &mut subtree.children {
                self.update_tree(child, parent_node, node_neighbors.clone());
            }
        }
    }
}

fn main() {
    let graph = PageGraph;
    let example = Example {
        query: Query { id: NodeId(1) },
    };
    let depth = 1;
    let script_tree = example.run_subsequent_scripts(&graph, depth);
    println!("{:#?}", script_tree);
}

最佳实践：提供可由其他人执行的最小可行示例代码（有问题）。