Rust单链表尾部pop函数实现遇阻，是否需用Rc与RefCell？

是否需要使用Rc和RefCell？ #

不需要。你当前用Box实现的是独占所有权的单向链表，完全能满足基础的头/尾插入、头/尾弹出需求。Rc用于共享所有权（多个地方需要持有同一节点的引用），RefCell用于在不可变引用下修改内部数据——这两个工具是解决复杂场景的（比如双向链表、多引用访问的链表），对于入门级单链表来说，只会增加不必要的复杂度，用Box就足够了。

不过你的代码有个小问题：把链表节点和链表容器合并成了一个List结构体，这会让头部弹出操作变得别扭。建议拆分出Node结构体，用List作为容器持有头节点，结构更清晰。

实现pop from front（头部弹出） #

调整结构后，头部弹出非常简单：取出当前头节点，将链表的头更新为原头节点的next，返回原头节点的值。需要处理空链表的情况（返回None）。

实现pop from end（尾部弹出） #

单链表的尾部弹出需要遍历到倒数第二个节点：

1. 如果链表为空，返回None；
2. 如果链表只有一个节点，取出头节点并清空链表，返回值；
3. 遍历节点，直到找到next是最后一个节点的位置，将该节点的next置为None，取出最后一个节点的值返回。

完整重构后的代码 #

#![allow(warnings)]

use std::fmt;

// 链表节点
#[derive(Clone)]
struct Node {
    el: i32,
    next: Option<Box<Node>>,
}

impl Node {
    fn new(val: i32) -> Self {
        Node {
            el: val,
            next: None,
        }
    }
}

// 链表容器
struct List {
    head: Option<Box<Node>>,
}

impl List {
    fn new() -> Self {
        List { head: None }
    }

    // 从数组创建链表
    fn from(arr: &[i32]) -> Self {
        let mut list = List::new();
        for &val in arr {
            list.append(val);
        }
        list
    }

    // 尾部添加元素
    fn append(&mut self, val: i32) {
        let new_node = Box::new(Node::new(val));
        match &mut self.head {
            None => self.head = Some(new_node),
            Some(mut current) => {
                while let Some(ref mut next_node) = current.next {
                    current = next_node;
                }
                current.next = Some(new_node);
            }
        }
    }

    // 头部添加元素
    fn prepend(&mut self, val: i32) {
        let mut new_node = Box::new(Node::new(val));
        new_node.next = self.head.take();
        self.head = Some(new_node);
    }

    // 头部弹出
    fn pop_front(&mut self) -> Option<i32> {
        self.head.take().map(|mut node| {
            self.head = node.next.take();
            node.el
        })
    }

    // 尾部弹出
    fn pop_back(&mut self) -> Option<i32> {
        // 处理空链表
        let Some(mut head) = self.head.take() else {
            return None;
        };

        // 处理只有一个节点的情况
        if head.next.is_none() {
            return Some(head.el);
        }

        // 遍历到倒数第二个节点
        let mut current = &mut head;
        while current.next.as_ref().unwrap().next.is_some() {
            current = current.next.as_mut().unwrap();
        }

        // 取出最后一个节点的值
        let last_node = current.next.take().unwrap();
        self.head = Some(head);
        Some(last_node.el)
    }
}

// 实现Display trait以便打印链表
impl fmt::Display for List {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let mut current = &self.head;
        write!(f, "[")?;
        let mut first = true;
        while let Some(node) = current {
            if !first {
                write!(f, ", ")?;
            }
            write!(f, "{}", node.el)?;
            current = &node.next;
            first = false;
        }
        write!(f, "]")
    }
}

fn main() {
    let mut list = List::new();
    list.append(42);
    list.append(32);
    list.append(2321);
    list.append(2839);
    list.prepend(69);
    println!("弹出尾部元素: {}", list.pop_back().unwrap()); // 2839
    println!("当前链表: {}", list);

    let mut list = List::from(&[1, 2, 3]);
    list.prepend(0);
    println!("弹出头部元素: {}", list.pop_front().unwrap()); // 0
    println!("当前链表: {}", list);
}

代码说明 #

• 拆分Node和List后，链表的操作逻辑更清晰，List作为容器统一管理头节点；
• pop_front利用Option::take安全地取出头节点，避免所有权问题；
• pop_back通过遍历找到倒数第二个节点，修改其next来移除尾部节点，同时正确处理空链表和单节点的边界情况；
• 实现了Display trait，可以直接打印链表内容。

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