如何将原子链表的递归插入转为迭代形式？解决临时值销毁编译错误

问题根源 #

你之前的迭代代码编译失败，是因为borrow_mut()/lock()返回的临时 guard 对象（RefMut或MutexGuard）会在语句结束后立即销毁，而你试图让node变量持有依赖该 guard 的可变引用，导致生命周期不匹配。

Rc 版本实现 #

use std::rc::Rc;
use std::cell::RefCell;

struct Node {
    val: i32,
    next: Option<Rc<RefCell<Node>>>
}

fn insert_node(node: &mut Option<Rc<RefCell<Node>>>, val: i32) {
    let mut current = node;
    
    while let Some(e) = current {
        let mut node_ref = e.borrow_mut();
        // 找到尾节点，插入新元素
        if node_ref.next.is_none() {
            node_ref.next = Some(Rc::new(RefCell::new(Node { val, next: None })));
            return;
        }
        // 移动到下一个节点的可变引用
        current = &mut node_ref.next;
    }
    
    // 如果初始链表为空，直接插入
    *current = Some(Rc::new(RefCell::new(Node { val, next: None })));
}

Arc 版本实现 #

use std::sync::{Arc, Mutex};

struct Elem {
    val: i32,
    next: Option<Arc<Mutex<Elem>>>,
}

fn insert(elem: &mut Option<Arc<Mutex<Elem>>>, val: i32) {
    let mut current = elem;
    
    while let Some(e) = current {
        let mut node_lock = e.lock().unwrap();
        // 找到尾节点，插入新元素
        if node_lock.next.is_none() {
            node_lock.next = Some(Arc::new(Mutex::new(Elem { val, next: None })));
            return;
        }
        // 移动到下一个节点的可变引用
        current = &mut node_lock.next;
    }
    
    // 如果初始链表为空，直接插入
    *current = Some(Arc::new(Mutex::new(Elem { val, next: None })));
}

实现说明 #

• 每次循环中，我们持有RefMut/MutexGuard直到完成current的更新，确保可变引用的生命周期与 guard 一致，避免临时值销毁后引用失效的问题。
• 通过while let循环遍历链表，直到找到尾节点（next为None），然后插入新元素；如果初始链表为空，则直接插入。

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