3 持久化单向链表栈 on 编程那些事儿

3.1 数据布局

Sun, 23 Aug 2026 16:06:00 +0800

原文链接: https://rust-unofficial.github.io/too-many-lists/third-layout.html

好，重新考虑布局。

持久化链表最重要的是，你可以几乎免费地操纵链表尾部：

例如，持久化链表上常见的工作负载是这样的：

1
2
3


list1 = A -> B -> C -> D
list2 = tail(list1) = B -> C -> D
list3 = push(list2, X) = X -> B -> C -> D

但最后我们希望内存看起来像这样：

3.2 基本操作

Sun, 23 Aug 2026 16:06:00 +0800

原文链接: https://rust-unofficial.github.io/too-many-lists/third-basics.html

我们已经懂不少 Rust 基础了，很多简单的事可以再来一遍。

构造函数又可以复制粘贴：

1
2
3
4
5


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

push 和 pop 不再合适。可以提供 prepend 和 tail，大致提供类似功能。

3.3 Drop

Sun, 23 Aug 2026 16:06:00 +0800

原文链接: https://rust-unofficial.github.io/too-many-lists/third-drop.html

和可变链表一样，我们有递归析构问题。对不可变链表来说这没那么糟：若遇到某处另一链表的头节点，我们不会递归 drop 它。但仍值得关注，而且怎么处理不那么明显。之前是这样解决的：

3.4 Arc

Sun, 23 Aug 2026 16:06:00 +0800

原文链接: https://rust-unofficial.github.io/too-many-lists/third-arc.html

用不可变链表的一个理由是在线程间共享数据。毕竟共享可变状态是万恶之源，一种解决办法是永远干掉可变部分。

但我们的链表根本不是线程安全的。要做到线程安全，得原子地修改引用计数。否则两个线程可能同时增加引用计数，只有一个会成功。链表就可能过早释放！

3.5 最终代码

Sun, 23 Aug 2026 16:06:00 +0800

原文链接: https://rust-unofficial.github.io/too-many-lists/third-final.html

关于不可变栈我就讲这些。我们现在实现链表越来越熟练了！

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102


use std::rc::Rc;

pub struct List<T> {
 head: Link<T>,
}

type Link<T> = Option<Rc<Node<T>>>;

struct Node<T> {
 elem: T,
 next: Link<T>,
}

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

 pub fn prepend(&self, elem: T) -> List<T> {
 List { head: Some(Rc::new(Node {
 elem: elem,
 next: self.head.clone(),
 }))}
 }

 pub fn tail(&self) -> List<T> {
 List { head: self.head.as_ref().and_then(|node| node.next.clone()) }
 }

 pub fn head(&self) -> Option<&T> {
 self.head.as_ref().map(|node| &node.elem)
 }

 pub fn iter(&self) -> Iter<'_, T> {
 Iter { next: self.head.as_deref() }
 }
}

impl<T> Drop for List<T> {
 fn drop(&mut self) {
 let mut head = self.head.take();
 while let Some(node) = head {
 if let Ok(mut node) = Rc::try_unwrap(node) {
 head = node.next.take();
 } else {
 break;
 }
 }
 }
}

pub struct Iter<'a, T> {
 next: Option<&'a Node<T>>,
}

impl<'a, T> Iterator for Iter<'a, T> {
 type Item = &'a T;

 fn next(&mut self) -> Option<Self::Item> {
 self.next.map(|node| {
 self.next = node.next.as_deref();
 &node.elem
 })
 }
}

#[cfg(test)]
mod test {
 use super::List;

 #[test]
 fn basics() {
 let list = List::new();
 assert_eq!(list.head(), None);

 let list = list.prepend(1).prepend(2).prepend(3);
 assert_eq!(list.head(), Some(&3));

 let list = list.tail();
 assert_eq!(list.head(), Some(&2));

 let list = list.tail();
 assert_eq!(list.head(), Some(&1));

 let list = list.tail();
 assert_eq!(list.head(), None);

 // 确保空 tail 也能工作
 let list = list.tail();
 assert_eq!(list.head(), None);
 }

 #[test]
 fn iter() {
 let list = List::new().prepend(1).prepend(2).prepend(3);

 let mut iter = list.iter();
 assert_eq!(iter.next(), Some(&3));
 assert_eq!(iter.next(), Some(&2));
 assert_eq!(iter.next(), Some(&1));
 }
}