在 while 循环中更新可变 HashMap

Question

我正在尝试在 Rust 中实现 Karger 算法，但在尝试在 while 循环中更新可变哈希映射时遇到了问题。

地图更新成功，但是在下一次克隆时，更新的值似乎没有改变。但是，从地图中删除元素会反映在以后的迭代中。

我已尝试调试和打印地图的值，但事件顺序对我来说没有意义。

use itertools::Itertools;  // 0.8.0
use rand::seq::{IteratorRandom, SliceRandom}; // 0.6.5
use std::collections::HashMap;

fn contract_edge(graph: &mut HashMap<i32, Vec<i32>>, num_trials: i32) {
    let mut count = 0;

    while graph.len() > 2 && count < num_trials {
        // clone graph so I can mutate graph later
        let imut_graph = graph.clone();

        // choose random node
        let from_value = imut_graph
            .keys()
            .choose(&mut rand::thread_rng())
            .unwrap()
            .clone();
        let values = imut_graph.get(&from_value);
        let to_value = values
            .unwrap()
            .choose(&mut rand::thread_rng())
            .unwrap()
            .clone();

        let from_edges = imut_graph[&from_value].iter().clone();

        // accessing to_value in imut_graph gives error here later
        let to_edges = imut_graph[&to_value]
            .iter()
            .clone()
            .filter(|&x| *x != from_value && *x != to_value);

        let new_edges = from_edges.chain(to_edges);

        // since I am mutating the graph I thought the next time is is clone it would be updated?
        graph.insert(from_value, new_edges.map(|v| v.clone()).collect());
        graph.remove(&to_value);
        for (_key, val) in graph.iter_mut() {
            *val = val
                .iter()
                .map(|v| if v == &to_value { &from_value } else { v })
                .unique()
                .cloned()
                .collect();
        }
        count += 1;
    }
}

当我尝试访问地图时，我得到 element not found 错误，但已删除的键此时不应存在于向量值中。

我确信这是我对 Rust 中的 (Im)mutability 不了解的地方。

Answer 1

我不太确定你想在这里实现什么，但根据我在上面看到的，你想改变你原来的graph（因为你把它作为一个可变借用传递到您的函数）并且您没有返回值，并且您的问题是关于变异哈希图 - 我假设您希望将更改反映在原始 HashMap 中。那你为什么要克隆它呢？

另一方面，如果您不想改变原始对象，则不要将其作为可变借用传递，而是作为不可变借用传递。然后在开始循环之前创建它的克隆，并在整个算法中使用该克隆版本。

您面临的问题正在发生，因为在每次迭代中，您都在克隆原始的graph，而不是克隆的imut_graph，即在每次迭代时，您都会创建一个新的HashMap，然后您正在变异，然后你开始一个新的循环，你仍在检查原始循环的长度，然后再次克隆原始循环。

所以你有两个选择：

use std::collections::HashMap;

fn mutated(map: &mut HashMap<i32, Vec<i32>>) {
    map.insert(1, vec![4, 5, 6]);
}

fn cloned(map: &HashMap<i32, Vec<i32>>) -> HashMap<i32, Vec<i32>> {
    let mut map = map.clone();
    map.insert(2, vec![7, 8, 9]);
    map
}

fn main() {
    let mut map = HashMap::new();
    map.insert(0, vec![1, 2, 3]);

    println!("{:?}", cloned(&map));

    mutated(&mut map);
    println!("{:?}", map);
}

这会给你：

{0: [1, 2, 3], 2: [7, 8, 9]}
{0: [1, 2, 3], 1: [4, 5, 6]}