Rust嵌套遍历同一向量遇所有权与借用冲突如何解决

你遇到的两个编译错误本质都是Rust借用规则的限制：

• 第一种写法for operator in operators直接获取了operators的所有权，循环内部再尝试对operators做可变修改时，所有权已经被移动进循环迭代器，因此会报变量已移动的错误。
• 第二种改成外层循环不可变借用的写法，相当于在整个外层循环周期内持有了operators的不可变引用，此时内部循环再申请operators的可变引用，就违反了Rust「同一时刻同一数据只能存在一个可变引用，或任意数量不可变引用」的核心借用规则，直接触发借用冲突。

以下两种方案都可以实现原有逻辑，你可以根据场景选择：

方案1：按索引遍历，避免长期持有向量引用 #

不直接迭代向量本身，改为通过索引访问元素，每次访问时仅临时拷贝需要的字段值，避免长期持有向量的引用，就不会触发借用冲突：

for op_idx in 0..operators.len() {
    // 拷贝当前operator的字段值，不持有operators的长期引用
    let current_index = operators[op_idx].index;
    // 挂载左节点
    let left_node = nodes[current_index - 1].clone();
    nodes[current_index].children.push(left_node);
    // 挂载右节点
    let right_node = nodes[current_index + 1].clone();
    nodes[current_index].children.push(right_node);
    // 删除已合并的左右节点
    nodes.remove(current_index + 1);
    nodes.remove(current_index - 1);
    // 更新所有后续operator的索引偏移
    for op in operators.iter_mut() {
        if op.index > current_index {
            op.index -= 2;
        }
    }
}

该方案完全保留你原有的处理顺序，逻辑改动最小，适合向量长度较短的场景。

方案2：预存操作列表，批量处理减少重复遍历 #

提前把所有需要的操作参数拷贝为独立副本，处理过程中不依赖原向量的引用，同时把重复的索引修正逻辑合并为单次遍历，性能更好：

// 提前拷贝所有operator的初始索引，生成独立的操作序列，不持有原向量引用
let initial_indices: Vec<usize> = operators.iter().map(|op| op.index).collect();
for (processed_count, &original_idx) in initial_indices.iter().enumerate() {
    // 每处理完一个operator，后续节点的实际索引会偏移2
    let real_pos = original_idx - 2 * processed_count;
    // 挂载左右节点
    let left = nodes[real_pos - 1].clone();
    nodes[real_pos].children.push(left);
    let right = nodes[real_pos + 1].clone();
    nodes[real_pos].children.push(right);
    // 删除已合并节点
    nodes.remove(real_pos + 1);
    nodes.remove(real_pos - 1);
}
// 所有节点处理完成后，批量更新operators的索引值
let mut offset = 0;
for (idx, op) in operators.iter_mut().enumerate() {
    op.index = initial_indices[idx] - offset;
    offset += 2;
}

该方案不需要在每次处理单个operator时遍历整个operators列表修正索引，在operators向量长度较大时性能优势明显。

内容的提问来源于stack exchange，提问作者GoatPonny