2 还可以的单向链表栈 on 编程那些事儿

2.1 Option

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

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

眼尖的读者可能已经注意到，我们其实重新发明了一个很糟糕的 Option 版本：

1
2
3
4


enum Link {
 Empty,
 More(Box<Node>),
}

Link 其实就是 Option<Box<Node>>。当然，不必到处写 Option<Box<Node>> 也挺舒服；而且不像 pop，我们并没有把它暴露给外部，所以也许还能接受。不过 Option 有一些非常好用的方法，而我们一直在手动实现。咱们别这么干了，把所有东西都换成 Option。首先，我们天真地把所有名字改成 Some 和 None：

2.2 泛型

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

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

我们已经接触过 Option 和 Box 里的泛型。但到目前为止，我们还没声明过真正对任意元素泛型的新类型。

其实非常简单。现在就把所有类型都改成泛型：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


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

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

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

只要给所有东西加上尖括号，代码就泛型化了。当然，不能只这么做，否则编译器会大发雷霆。

2.3 Peek

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

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

上次我们甚至懒得实现 peek。现在来做一下。只需要在链表头存在元素时返回对它的引用。听起来简单，试试：

1
2
3
4
5


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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


> cargo build

error[E0515]: cannot return reference to local data `node.elem`
 --> src/second.rs:37:13
 |
37 | &node.elem
 | ^^^^^^^^^^ returns a reference to data owned by the current function

error[E0507]: cannot move out of borrowed content
 --> src/second.rs:36:9
 |
36 | self.head.map(|node| {
 | ^^^^^^^^^ cannot move out of borrowed content

唉。Rust，现在又怎么了？

2.4 IntoIter

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

原文链接: https://rust-unofficial.github.io/too-many-lists/second-into-iter.html

在 Rust 中，集合通过 Iterator trait 来迭代。它比 Drop 稍微复杂一点：

1
2
3
4


pub trait Iterator {
 type Item;
 fn next(&mut self) -> Option<Self::Item>;
}

这里的新面孔是 type Item。它声明每个 Iterator 实现都有一个名为 Item 的关联类型。在这里，就是调用 next 时能吐出的类型。

2.5 Iter

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

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

好，来实现 Iter。这次不能指望 List 提供我们想要的一切，得自己动手。基本思路是保存指向「下一个要 yield 的节点」的指针。因为该节点可能不存在（链表为空或迭代已结束），这个引用应该是 Option。yield 一个元素后，要前进到当前节点的 next 节点。

2.6 IterMut

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

原文链接: https://rust-unofficial.github.io/too-many-lists/second-iter-mut.html

说实话，IterMut 很狂野。这话本身听起来就很狂野；从语义上看，它和 Iter 一模一样吧！

语义上是的，但共享引用与可变引用的性质意味着 Iter 是「轻而易举」的，而 IterMut 则是正经的巫师魔法。

2.7 最终代码

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

原文链接: https://rust-unofficial.github.io/too-many-lists/second-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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190


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

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

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

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

 pub fn push(&mut self, elem: T) {
 let new_node = Box::new(Node {
 elem: elem,
 next: self.head.take(),
 });

 self.head = Some(new_node);
 }

 pub fn pop(&mut self) -> Option<T> {
 self.head.take().map(|node| {
 self.head = node.next;
 node.elem
 })
 }

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

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

 pub fn into_iter(self) -> IntoIter<T> {
 IntoIter(self)
 }

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

 pub fn iter_mut(&mut self) -> IterMut<'_, T> {
 IterMut { next: self.head.as_deref_mut() }
 }
}

impl<T> Drop for List<T> {
 fn drop(&mut self) {
 let mut cur_link = self.head.take();
 while let Some(mut boxed_node) = cur_link {
 cur_link = boxed_node.next.take();
 }
 }
}

pub struct IntoIter<T>(List<T>);

impl<T> Iterator for IntoIter<T> {
 type Item = T;
 fn next(&mut self) -> Option<Self::Item> {
 // 用数字索引访问元组结构体的字段
 self.0.pop()
 }
}

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
 })
 }
}

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

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

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

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

 #[test]
 fn basics() {
 let mut list = List::new();

 // 检查空链表行为正确
 assert_eq!(list.pop(), None);

 // 填充链表
 list.push(1);
 list.push(2);
 list.push(3);

 // 检查正常弹出
 assert_eq!(list.pop(), Some(3));
 assert_eq!(list.pop(), Some(2));

 // 再推几个，确保没有损坏
 list.push(4);
 list.push(5);

 // 检查正常弹出
 assert_eq!(list.pop(), Some(5));
 assert_eq!(list.pop(), Some(4));

 // 检查耗尽
 assert_eq!(list.pop(), Some(1));
 assert_eq!(list.pop(), None);
 }

 #[test]
 fn peek() {
 let mut list = List::new();
 assert_eq!(list.peek(), None);
 assert_eq!(list.peek_mut(), None);
 list.push(1); list.push(2); list.push(3);

 assert_eq!(list.peek(), Some(&3));
 assert_eq!(list.peek_mut(), Some(&mut 3));

 list.peek_mut().map(|value| {
 *value = 42
 });

 assert_eq!(list.peek(), Some(&42));
 assert_eq!(list.pop(), Some(42));
 }

 #[test]
 fn into_iter() {
 let mut list = List::new();
 list.push(1); list.push(2); list.push(3);

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

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

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

 #[test]
 fn iter_mut() {
 let mut list = List::new();
 list.push(1); list.push(2); list.push(3);

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

越来越壮实了！