# Rust Vector 练习题

> 建议先手动写出每道题的答案，再运行代码验证。

## 目录

- [一、概念辨析题](#一概念辨析题)
- [二、填空题：补充代码](#二填空题补充代码)
- [三、找出并修复错误](#三找出并修复错误)
- [四、编程题](#四编程题)
- [五、综合思考题](#五综合思考题)
- [参考答案](#参考答案)

---

## 一、概念辨析题

判断以下说法是否正确，并简要说明原因。

### 题目 1-1

> `Vec<T>` 只能存储相同类型的数据。

### 题目 1-2

> 从空 Vec 中 `pop()` 会引发 panic。

### 题目 1-3

> 以下两种创建 Vec 的方式完全等价，没有性能差异：
> ```rust
> let v1 = Vec::new();
> let v2 = vec![];
> ```

### 题目 1-4

> 使用索引 `v[3]` 访问 Vec 元素和使用 `v.get(3)` 的行为完全一致。

### 题目 1-5

> 对 Vec 进行 `for` 循环遍历会消耗 Vec 的所有权，遍历后 Vec 不再可用。

### 题目 1-6

> 当 Vec 的容量满了再 `push` 新元素时，Rust 会自动重新分配一块更大的内存并将原数据拷贝过去。

### 题目 1-7

> `Vec::with_capacity(n)` 创建的 Vec 的长度也为 `n`。

### 题目 1-8

> 可以在遍历 Vec 的同时向其中添加元素。

---

## 二、填空题：补充代码

补全下列代码使其能通过编译并达到期望输出。

### 题目 2-1：基本创建和操作

```rust
fn main() {
    // 填空：创建一个包含元素 1, 2, 3, 4, 5 的 Vec
    let mut v = ________;

    // 填空：向末尾添加元素 6
    v.________(6);

    // 填空：移除并返回最后一个元素
    let last = v.________();
    println!("移除的元素是: {}", last);

    // 填空：获取当前长度
    println!("当前长度: {}", ________);

    // 填空：获取指定位置元素的值（安全方式）
    match v.________(2) {
        Some(value) => println!("索引 2 的值是: {}", value),
        None => println!("没有该元素"),
    }
}
// 期望输出：
// 移除的元素是: 6
// 当前长度: 5
// 索引 2 的值是: 3
```

### 题目 2-2：遍历 Vec

```rust
fn main() {
    let v = vec![10, 20, 30, 40, 50];

    // 填空：不可变遍历，打印每个元素
    for ________ in ________ {
        print!("{} ", i);
    }
    println!();

    // 填空：可变遍历，每个元素翻倍
    let mut v2 = vec![1, 2, 3, 4, 5];
    for ________ in ________ {
        *i ________ 2;
    }
    println!("翻倍后: {:?}", v2);
}
// 期望输出：
// 10 20 30 40 50
// 翻倍后: [2, 4, 6, 8, 10]
```

### 题目 2-3：插入和删除

```rust
fn main() {
    let mut v = vec![1, 2, 4, 5];

    // 填空：在索引 2 处插入元素 3
    v.________(2, 3);

    // 填空：删除索引 4 处的元素
    v.________(4);
    // 填空：删除索引 0 处的元素
    v.________(0);

    println!("结果: {:?}", v);
}
// 期望输出：结果: [2, 3, 4]
```

### 题目 2-4：枚举实现不同类型存储

```rust
// 填空：定义一个枚举，包含整数、浮点数、文本三种变体
________ Value {
    Integer(i32),
    Float(f64),
    ________(String),
}

fn main() {
    // 填空：使用宏创建一个包含不同变体的 Vec
    let row = ________;
        Value::Integer(3),
        Value::Float(3.14),
        Value::Text(String::from("Hello")),
    ];

    for v in &row {
        match v {
            Value::Integer(n) => print!("Int:{} ", n),
            Value::Float(f) => print!("Float:{} ", f),
            Value::Text(s) => print!("Text:{} ", s),
        }
    }
}
// 期望输出：Int:3 Float:3.14 Text:Hello
```

### 题目 2-5：切片操作

```rust
fn main() {
    let v = vec![1, 2, 3, 4, 5, 6, 7, 8];

    // 填空：获取 v[1..4] 的切片
    let slice1 = ________;
    println!("slice1: {:?}", slice1);

    // 填空：获取前 3 个元素的切片
    let slice2 = ________;
    println!("slice2: {:?}", slice2);

    // 填空：获取从索引 5 到末尾的切片
    let slice3 = ________;
    println!("slice3: {:?}", slice3);
}
// 期望输出：
// slice1: [2, 3, 4]
// slice2: [1, 2, 3]
// slice3: [6, 7, 8]
```

### 题目 2-6：容量管理

```rust
fn main() {
    // 填空：预分配容量为 100 的空 Vec
    let mut v: Vec<i32> = Vec::________(100);

    println!("创建后 - 长度: {}，容量: {}", v.len(), v.capacity());

    for i in 0..50 {
        v.push(i);
    }
    println!("添加 50 个元素后 - 长度: {}，容量: {}", v.len(), v.capacity());

    // 填空：收缩容量以匹配长度（使用合适的方法）
    v.________();
    println!("收缩后 - 长度: {}，容量: {}", v.len(), v.capacity());
}
```

### 题目 2-7：常用方法组合

```rust
fn main() {
    let mut v = vec![5, 2, 8, 1, 9, 3];

    // 填空：排序（升序）
    v.________();

    // 填空：检查是否包含某个值
    let has_five = v.________(&5);

    // 填空：反转顺序
    v.________();

    println!("排序并反转后: {:?}", v);
    println!("是否包含 5: {}", has_five);
}
// 期望输出：
// 排序并反转后: [9, 8, 5, 3, 2, 1]
// 是否包含 5: true
```

### 题目 2-8：extend 和 drain

```rust
fn main() {
    let mut v1 = vec![1, 2, 3];
    let v2 = vec![4, 5, 6];

    // 填空：将 v2 的所有元素追加到 v1
    v1.________(&v2);
    println!("追加后: {:?}", v1);

    let mut v = vec![10, 20, 30, 40, 50];
    // 填空：移除索引 1..4 的元素，返回被移除元素的迭代器
    let drained: Vec<_> = v.________(1..4).collect();
    println!("被移除的: {:?}", drained);
    println!("剩余的: {:?}", v);
}
// 期望输出：
// 追加后: [1, 2, 3, 4, 5, 6]
// 被移除的: [20, 30, 40]
// 剩余的: [10, 50]
```

### 题目 2-9：迭代器适配器

```rust
fn main() {
    let v = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

    // 填空：过滤出偶数，映射为平方，收集到新 Vec
    let result: Vec<i32> = v.________()
        .________(|x| x % 2 == 0)
        .________(|x| x * x)
        .collect();

    println!("偶数的平方: {:?}", result);

    // 填空：求和
    let sum: i32 = v.iter().________();
    println!("总和: {}", sum);
}
// 期望输出：
// 偶数的平方: [4, 16, 36, 64, 100]
// 总和: 55
```

---

## 三、找出并修复错误

以下每段代码都有编译错误，请指出错误并写出修正后的代码。

### 题目 3-1

```rust
fn main() {
    let mut v = vec![1, 2, 3];
    let first = &v[0];    // 不可变借用
    v.push(4);            // 可变借用
    println!("{}", first); // 使用不可变借用
}
```

### 题目 3-2

```rust
fn main() {
    let v = vec![1, 2, 3, 4, 5];
    let third = v[10];
    println!("{}", third);
}
```

### 题目 3-3

```rust
fn main() {
    let mut v = Vec::new();
    v.push("hello");
    v.push(42);
    println!("{:?}", v);
}
```

### 题目 3-4

```rust
fn main() {
    let mut v = vec![1, 2, 3];
    for i in v.iter_mut() {
        v.push(4);  // 同时修改
    }
    println!("{:?}", v);
}
```

### 题目 3-5

```rust
fn main() {
    let mut v = vec![1, 2, 3, 4, 5];
    for i in 0..v.len() {
        if v[i] % 2 == 0 {
            v.remove(i);
        }
    }
    println!("{:?}", v);
}
```

### 题目 3-6

```rust
fn main() {
    let v = vec![String::from("hello")];
    let s = &v[0];   // 借用了 v 中的元素
    drop(v);         // 显式释放 v
    println!("{}", s); // 使用了 s
}
```

### 题目 3-7

```rust
fn main() {
    let v = vec![1, 2, 3];
    // 想要获得 [1, 4, 9]
    let squared: Vec<i32> = v.iter().map(|x| x * x);
    println!("{:?}", squared);
}
```

### 题目 3-8

```rust
fn main() {
    let mut v: Vec<u32> = Vec::new();
    v.push(1);
    let popped = v.pop();
    println!("{:?}", popped);   // 期望打印 1
    let popped2 = v.pop();      // Vec 已空
    println!("{}", popped2);    // 这行会怎样？
}
```

### 题目 3-9

```rust
fn main() {
    let v = vec![1, 2, 3, 4, 5];
    for item in v {
        println!("{}", item);
    }
    println!("v 还有 {} 个元素", v.len()); // 再次使用 v
}
```

### 题目 3-10

```rust
fn main() {
    let mut v = vec![1, 2, 3];
    let slice = &mut v[0..2];  // 可变借用切片
    v.push(4);                 // 尝试修改原 Vec
    slice[0] = 10;
    println!("{:?}", v);
}
```

---

## 四、编程题

请在 `main.rs` 中编写以下程序，并实际运行验证。

### 题目 4-1：成绩统计分析器

编写一个程序，完成以下功能：

1. 创建一个包含 10 个学生成绩的 `Vec<i32>`（成绩范围 0~100）
2. 计算并打印：最高分、最低分、平均分
3. 找出所有不及格（< 60）的成绩，存入新 Vec 并打印
4. 判断是否有满分（100 分），打印结果
5. 将所有成绩从高到低排序后打印

**期望输出示例（成绩不同则输出不同）：**
```
成绩列表: [85, 42, 96, 78, 55, 88, 91, 63, 100, 74]
最高分: 100
最低分: 42
平均分: 77.2
不及格成绩: [42, 55]
有满分: 是
排序后(高到低): [100, 96, 91, 88, 85, 78, 74, 63, 55, 42]
```

### 题目 4-2：斐波那契数列生成器

编写一个函数 `fibonacci(n: usize) -> Vec<u64>`，接收项数 `n`，返回一个包含前 `n` 项斐波那契数列的 Vec。

- n = 0 时返回空 Vec
- n = 1 时返回 `[1]`
- n = 2 时返回 `[1, 1]`
- n >= 3 时正常生成

在 `main` 中调用并打印前 20 项。

**期望输出（前 20 项）：**
```
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]
```

### 题目 4-3：购物车模拟

编写一个模拟购物车的程序：

1. 定义一个 `Item` 结构体，包含 `name: String` 和 `price: f64`
2. 创建一个购物车 `Vec<Item>`，提供以下功能：
   - `add_item(cart: &mut Vec<Item>, name: &str, price: f64)` — 添加商品
   - `remove_item(cart: &mut Vec<Item>, name: &str)` — 按名称移除商品（只移除第一个匹配项）
   - `total_price(cart: &Vec<Item>) -> f64` — 计算总价
   - `list_items(cart: &Vec<Item>)` — 列出所有商品
3. 在 `main` 中演示完整流程：添加 5 个商品，列出清单，计算总价，移除一个商品，再次列出清单和计算总价

**期望输出示例：**
```
购物车清单:
  - 苹果: ¥3.50
  - 香蕉: ¥2.00
  - 牛奶: ¥6.80
  - 面包: ¥5.00
  - 鸡蛋: ¥12.00
当前总价: ¥29.30

移除"香蕉"后:
购物车清单:
  - 苹果: ¥3.50
  - 牛奶: ¥6.80
  - 面包: ¥5.00
  - 鸡蛋: ¥12.00
当前总价: ¥27.30
```

### 题目 4-4：单词统计器

编写一个程序，统计一段文本中每个单词出现的次数。

1. 定义输入文本：`"the quick brown fox jumps over the lazy dog the fox was quick"`
2. 将文本按空格分割成单词，存入 `Vec<&str>`
3. 使用一个辅助的 Vec（或使用 `HashMap`，但核心流程用 Vec 实现）统计每个不重复单词及其出现次数
4. 打印所有不重复单词及其出现次数（按单词字母顺序排序）

**提示：**
- 可以用 `Vec<(String, i32)>` 存储"单词-次数"对
- 遍历单词 Vec，如果在统计 Vec 中找到该单词则计数+1，否则追加新纪录

**期望输出：**
```
单词统计结果:
  brown: 1
  dog: 1
  fox: 2
  jumps: 1
  lazy: 1
  over: 1
  quick: 2
  the: 3
  was: 1
```

### 题目 4-5：矩阵转置

使用 `Vec<Vec<i32>>` 表示一个二维矩阵，编写一个函数 `transpose(matrix: &Vec<Vec<i32>>) -> Vec<Vec<i32>>` 实现矩阵转置。

- 输入：一个 m×n 的矩阵
- 输出：一个 n×m 的转置矩阵
- 使用迭代器方法实现，避免使用显式的 C 风格循环

在 `main` 中测试：
```
原始矩阵:
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]

转置后:
[1, 4, 7]
[2, 5, 8]
[3, 6, 9]
```

### 题目 4-6：简易栈（Stack）实现

只使用 `Vec` 实现一个 `Stack<T>` 结构体，封装栈操作：

- `fn new() -> Self`
- `fn push(&mut self, item: T)`
- `fn pop(&mut self) -> Option<T>`
- `fn peek(&self) -> Option<&T>`
- `fn is_empty(&self) -> bool`
- `fn len(&self) -> usize`

在 `main` 中测试括号匹配功能：编写函数 `is_balanced(s: &str) -> bool`，利用你实现的 `Stack` 判断字符串中的 `()`、`[]`、`{}` 是否正确匹配。

测试用例：
```
测试用例:
"()"         -> true
"()[]{}"     -> true
"(]"         -> false
"([)]"       -> false
"{[]}"       -> true
"((("        -> false
""           -> true
```

---

## 五、综合思考题

### 题目 5-1

阅读以下代码：

```rust
fn main() {
    let mut v = vec![String::from("Rust"), String::from("is"), String::from("awesome")];

    let first = &v[0];      // ①
    v.push(String::from("!")); // ②
    println!("{}", first);  // ③
}
```

1. 这段代码能编译吗？为什么？
2. 如果改成 `let first = &v[0].clone();`，会怎样？为什么？
3. `v[0]` 和 `v.get(0)` 的区别在哪里？分别适用于什么场景？
4. 如果 `v` 的类型是 `Vec<i32>`，问题 1 的代码是否能编译？为什么？

### 题目 5-2

分析以下两种删除 Vec 中所有偶数元素的方式：

**方式 A：**
```rust
fn remove_evens_a(v: &mut Vec<i32>) {
    let mut i = 0;
    while i < v.len() {
        if v[i] % 2 == 0 {
            v.remove(i);
        } else {
            i += 1;
        }
    }
}
```

**方式 B：**
```rust
fn remove_evens_b(v: &mut Vec<i32>) {
    v.retain(|x| x % 2 != 0);
}
```

1. 两种方式的时间复杂度分别是多少？为什么？
2. 方式 A 中的 `i += 1` 放在 `else` 分支中，如果去掉这个条件（每次循环都 `i += 1`）会发生什么？
3. `retain` 方法的底层原理是什么？它比手动 `remove` 高效在哪里？

### 题目 5-3

```rust
fn first_n_even(n: usize) -> Vec<i32> {
    let mut result = Vec::new();
    let mut num = 2;
    while result.len() < n {
        if num % 2 == 0 {
            result.push(num);
        }
        num += 1;
    }
    result
}
```

1. 上述代码有没有更好的 Rust 风格写法？请使用迭代器重写。
2. 如果 `n` 非常大（比如 10000000），从性能角度应该如何优化？（提示：`Vec::with_capacity` 和迭代器）

### 题目 5-4

阅读以下代码，回答：

```rust
fn append_vector(v: &mut Vec<i32>, other: &mut Vec<i32>) {
    v.append(other);
}

fn main() {
    let mut v1 = vec![1, 2, 3];
    let mut v2 = vec![4, 5, 6];

    append_vector(&mut v1, &mut v2);

    println!("v1: {:?}", v1);
    println!("v2: {:?}", v2);
}
```

1. `v2` 在 `append` 调用后会变成什么？为什么？
2. `append` 和 `extend` 有什么区别？各适用于什么场景？
3. 如果希望 `v2` 在追加后保持不变（即"复制追加"），应该使用什么方法？

### 题目 5-5

假设你正在实现一个游戏中的物品栏系统：

```rust
#[derive(Debug)]
struct Inventory {
    items: Vec<Item>,
    capacity: usize,
}

#[derive(Debug, Clone)]
struct Item {
    name: String,
    count: u32,
}

impl Inventory {
    fn new(capacity: usize) -> Self {
        Inventory {
            items: Vec::new(),
            capacity,
        }
    }

    fn add_item(&mut self, item: Item) -> Result<(), String> {
        // 待实现
        todo!()
    }

    fn remove_item(&mut self, name: &str, count: u32) -> Result<(), String> {
        // 待实现
        todo!()
    }
}
```

1. 实现 `add_item`：如果物品已存在则叠加数量；如果背包已满则返回错误信息。注意借用检查器的约束。
2. 实现 `remove_item`：如果数量足够则减少，如果降至 0 则移除整个条目；如果物品不存在或数量不足则返回错误信息。
3. 这个设计中有一个潜在的问题：当背包容量已满但要添加的是已有物品时，叠加数量并不需要新增槽位。如何修改 `add_item` 的逻辑来正确处理这种情况？

---

## 参考答案

> 请独立完成再查看答案。

<details>
<summary>点击展开答案</summary>

### 一、概念辨析题

**1-1**：✅ 正确。`Vec<T>` 是泛型容器，所有元素必须是相同类型 `T`。如果要存储不同类型，需要使用枚举（如 `Vec<MyEnum>`）或 trait 对象（`Vec<Box<dyn MyTrait>>`）。

**1-2**：❌ 错误。空 Vec 调用 `pop()` 不会 panic，而是返回 `None`。`pop` 的返回类型是 `Option<T>`，在空 Vec 上返回 `None`。

**1-3**：❌ 错误。`Vec::new()` 创建一个容量为 0 的 Vec（不分配堆内存），`vec![]` 同样不分配。两者在这种情况下等价。但如果使用 `vec![1, 2, 3]` 和手动 `new` 后 `push` 三次，`vec![]` 可能预先分配合适的容量，性能略好。

**1-4**：❌ 错误。`v[3]` 索引越界时会 **panic**（程序崩溃），而 `v.get(3)` 返回 `Option<&T>`，越界时返回 `None`，不会崩溃。`get` 是安全的访问方式。

**1-5**：❌ 错误。`for item in v` 会消耗 Vec 的所有权，但 `for item in &v` 仅不可变借用，`for item in &mut v` 仅可变借用。只有转移所有权的遍历才会使 Vec 之后不可用。

**1-6**：✅ 正确。当 `len == capacity` 时再 push，Vec 会自动分配一块更大的内存（通常是当前容量的两倍），将旧元素移动/拷贝到新内存，然后释放旧内存。

**1-7**：❌ 错误。`Vec::with_capacity(n)` 创建的 Vec **长度**为 0，**容量**为 n。需要通过 `push` 等方法添加元素后长度才会增加。

**1-8**：❌ 错误。在遍历 Vec 时不能同时修改 Vec 本身（添加或删除元素），这违反了借用规则。遍历时持有的是对 Vec 或其元素的借用，而修改需要可变借用，两者不能共存。

### 二、填空题

**2-1**：
```rust
let mut v = vec![1, 2, 3, 4, 5];
v.push(6);
let last = v.pop().unwrap();
println!("当前长度: {}", v.len());
match v.get(2) {
```

**2-2**：
```rust
for i in &v {
    print!("{} ", i);
}
// 可变遍历
for i in &mut v2 {
    *i *= 2;
}
```

**2-3**：
```rust
v.insert(2, 3);
v.remove(4);
v.remove(0);
```

**2-4**：
```rust
enum Value {
    Integer(i32),
    Float(f64),
    Text(String),
}
let row = vec![
    Value::Integer(3),
    Value::Float(3.14),
    Value::Text(String::from("Hello")),
];
```

**2-5**：
```rust
let slice1 = &v[1..4];
let slice2 = &v[..3];
let slice3 = &v[5..];
```

**2-6**：
```rust
let mut v: Vec<i32> = Vec::with_capacity(100);
// ... 添加元素后
v.shrink_to_fit();
```

**2-7**：
```rust
v.sort();
let has_five = v.contains(&5);
v.reverse();
```

**2-8**：
```rust
v1.extend(&v2);
let drained: Vec<_> = v.drain(1..4).collect();
```

**2-9**：
```rust
let result: Vec<i32> = v.iter()
    .filter(|x| *x % 2 == 0)
    .map(|x| x * x)
    .collect();
let sum: i32 = v.iter().sum();
```

### 三、修复错误

**3-1**：不可变借用和可变借用冲突。`first` 是 `v` 的不可变引用，而 `push` 需要 `v` 的可变引用。修复：调整顺序，先使用 `first` 再 `push`，或在 push 前不保留引用。
```rust
let mut v = vec![1, 2, 3];
let first = v[0];      // 直接拷贝值（i32 实现了 Copy）
v.push(4);
println!("{}", first);
```
对于非 Copy 类型，可以：
```rust
let first = v[0].clone();  // 克隆值
v.push(4);
println!("{}", first);
```

**3-2**：索引越界，Vec 只有 5 个元素（索引 0~4），访问 `v[10]` 会 panic。修复：
```rust
let third = v.get(10);  // 返回 None，不会 panic
match third {
    Some(val) => println!("{}", val),
    None => println!("索引越界"),
}
```

**3-3**：`Vec::new()` 无法推断类型，需要显式标注。且同一个 Vec 不能混装 `&str` 和 `i32`。修复：使用枚举：
```rust
enum Value<'a> {
    Text(&'a str),
    Number(i32),
}
let mut v: Vec<Value> = Vec::new();
v.push(Value::Text("hello"));
v.push(Value::Number(42));
```

**3-4**：在遍历 Vec 的同时修改 Vec 的大小，违反借用规则。修复：先收集要添加的元素，再 `extend`：
```rust
let mut v = vec![1, 2, 3];
v.extend(vec![4, 4, 4]);
println!("{:?}", v);
```

**3-5**：一边按索引遍历一边删除元素会导致跳过元素（因为删除后后续元素前移）。修复：使用 `retain` 或从后往前遍历：
```rust
let mut v = vec![1, 2, 3, 4, 5];
v.retain(|x| x % 2 != 0);
println!("{:?}", v); // [1, 3, 5]
```

**3-6**：`s` 借用了 `v` 中的元素，`drop(v)` 释放 `v` 后 `s` 变成悬垂引用。修复：先 `clone` 再释放：
```rust
let v = vec![String::from("hello")];
let s = v[0].clone();  // 获取独立的所有权
drop(v);
println!("{}", s);
```

**3-7**：`map` 返回迭代器，需要 `.collect()` 消费才能得到 Vec。修复：
```rust
let squared: Vec<i32> = v.iter().map(|x| x * x).collect();
```

**3-8**：`pop` 返回 `Option<u32>`，不能直接用 `println!("{}", popped2)` 打印（类型不匹配，且值为 `None`）。修复：
```rust
println!("{:?}", popped);   // Some(1)
println!("{:?}", popped2);  // None
```

**3-9**：`for item in v` 消耗了 `v` 的所有权，之后不能再用 `v`。修复：使用引用遍历：
```rust
for item in &v {
    println!("{}", item);
}
println!("v 还有 {} 个元素", v.len());
```

**3-10**：`slice` 是 `v` 的可变借用，`push` 需要另一个可变借用，冲突。修复：先操作切片，释放后再 push：
```rust
let mut v = vec![1, 2, 3];
{
    let slice = &mut v[0..2];
    slice[0] = 10;
}  // slice 的借用在此结束
v.push(4);
println!("{:?}", v);  // [10, 2, 3, 4]
```

### 四、编程题

**4-1 成绩统计分析器：**

```rust
fn main() {
    let scores = vec![85, 42, 96, 78, 55, 88, 91, 63, 100, 74];
    println!("成绩列表: {:?}", scores);

    let max = scores.iter().max().unwrap();
    let min = scores.iter().min().unwrap();
    let avg = scores.iter().sum::<i32>() as f64 / scores.len() as f64;

    println!("最高分: {}", max);
    println!("最低分: {}", min);
    println!("平均分: {:.1}", avg);

    let failing: Vec<i32> = scores.iter().filter(|&&s| s < 60).copied().collect();
    println!("不及格成绩: {:?}", failing);

    let has_perfect = scores.contains(&100);
    println!("有满分: {}", if has_perfect { "是" } else { "否" });

    let mut sorted = scores.clone();
    sorted.sort_by(|a, b| b.cmp(a));
    println!("排序后(高到低): {:?}", sorted);
}
```

**4-2 斐波那契数列生成器：**

```rust
fn fibonacci(n: usize) -> Vec<u64> {
    match n {
        0 => vec![],
        1 => vec![1],
        _ => {
            let mut fib = vec![1, 1];
            for _ in 2..n {
                let next = fib[fib.len() - 1] + fib[fib.len() - 2];
                fib.push(next);
            }
            fib
        }
    }
}

fn main() {
    let fib = fibonacci(20);
    println!("{:?}", fib);
}
```

**4-3 购物车模拟：**

```rust
struct Item {
    name: String,
    price: f64,
}

fn add_item(cart: &mut Vec<Item>, name: &str, price: f64) {
    cart.push(Item {
        name: name.to_string(),
        price,
    });
}

fn remove_item(cart: &mut Vec<Item>, name: &str) {
    if let Some(pos) = cart.iter().position(|item| item.name == name) {
        cart.remove(pos);
    }
}

fn total_price(cart: &Vec<Item>) -> f64 {
    cart.iter().map(|item| item.price).sum()
}

fn list_items(cart: &Vec<Item>) {
    for item in cart {
        println!("  - {}: ¥{:.2}", item.name, item.price);
    }
}

fn main() {
    let mut cart = Vec::new();

    add_item(&mut cart, "苹果", 3.50);
    add_item(&mut cart, "香蕉", 2.00);
    add_item(&mut cart, "牛奶", 6.80);
    add_item(&mut cart, "面包", 5.00);
    add_item(&mut cart, "鸡蛋", 12.00);

    println!("购物车清单:");
    list_items(&cart);
    println!("当前总价: ¥{:.2}", total_price(&cart));

    remove_item(&mut cart, "香蕉");

    println!("\n移除\"香蕉\"后:");
    println!("购物车清单:");
    list_items(&cart);
    println!("当前总价: ¥{:.2}", total_price(&cart));
}
```

**4-4 单词统计器：**

```rust
fn main() {
    let text = "the quick brown fox jumps over the lazy dog the fox was quick";
    let words: Vec<&str> = text.split_whitespace().collect();

    let mut stats: Vec<(String, i32)> = Vec::new();

    for word in &words {
        if let Some(pos) = stats.iter().position(|(w, _)| w == word) {
            stats[pos].1 += 1;
        } else {
            stats.push((word.to_string(), 1));
        }
    }

    stats.sort_by(|a, b| a.0.cmp(&b.0));

    println!("单词统计结果:");
    for (word, count) in &stats {
        println!("  {}: {}", word, count);
    }
}
```

**4-5 矩阵转置：**

```rust
fn transpose(matrix: &Vec<Vec<i32>>) -> Vec<Vec<i32>> {
    if matrix.is_empty() {
        return vec![];
    }

    let rows = matrix.len();
    let cols = matrix[0].len();

    (0..cols)
        .map(|col| {
            (0..rows)
                .map(|row| matrix[row][col])
                .collect()
        })
        .collect()
}

fn main() {
    let matrix = vec![
        vec![1, 2, 3],
        vec![4, 5, 6],
        vec![7, 8, 9],
    ];

    println!("原始矩阵:");
    for row in &matrix {
        println!("{:?}", row);
    }

    let transposed = transpose(&matrix);

    println!("\n转置后:");
    for row in &transposed {
        println!("{:?}", row);
    }
}
```

**4-6 简易栈实现：**

```rust
struct Stack<T> {
    data: Vec<T>,
}

impl<T> Stack<T> {
    fn new() -> Self {
        Stack { data: Vec::new() }
    }

    fn push(&mut self, item: T) {
        self.data.push(item);
    }

    fn pop(&mut self) -> Option<T> {
        self.data.pop()
    }

    fn peek(&self) -> Option<&T> {
        self.data.last()
    }

    fn is_empty(&self) -> bool {
        self.data.is_empty()
    }

    fn len(&self) -> usize {
        self.data.len()
    }
}

fn is_balanced(s: &str) -> bool {
    let mut stack = Stack::new();

    for ch in s.chars() {
        match ch {
            '(' | '[' | '{' => stack.push(ch),
            ')' => {
                if stack.pop() != Some('(') {
                    return false;
                }
            }
            ']' => {
                if stack.pop() != Some('[') {
                    return false;
                }
            }
            '}' => {
                if stack.pop() != Some('{') {
                    return false;
                }
            }
            _ => {}
        }
    }

    stack.is_empty()
}

fn main() {
    let tests = [
        ("()", true),
        ("()[]{}", true),
        ("(]", false),
        ("([)]", false),
        ("{[]}", true),
        ("(((", false),
        ("", true),
    ];

    println!("括号匹配测试:");
    for (input, expected) in tests {
        let result = is_balanced(input);
        let status = if result == expected { "✓" } else { "✗" };
        println!("  {} \"{}\" -> {} (期望: {})", status, input, result, expected);
    }
}
```

### 五、综合思考题

**5-1**：

1. 不能编译。`first` 是 `v[0]` 的不可变引用，而 `v.push()` 需要可变引用。即便 `push` 触发的内存重分配不影响索引 0 的元素（逻辑上 String 的数据在堆上），但 Rust 的借用规则在编译期不能精确判断这一点，因此直接拒绝在持有不可变引用时进行可变操作。

2. `v[0].clone()` 会创建一个新的 `String`，`first` 拥有这个新 String 的所有权，不再依赖 `v`。因此 `v.push()` 不受影响，可以编译。

3. `v[0]` 返回 `&T`，越界时 panic；`v.get(0)` 返回 `Option<&T>`，越界时返回 `None`。`v[0]` 适用于确定索引有效的场景，`v.get(0)` 适用于索引可能越界的场景。

4. 可以编译。因为 `i32` 实现了 `Copy` trait，`let first = &v[0]` 在后续使用中，由于 `first` 是 `&i32`，`println!` 打印时需要解引用为 `i32` 值。但关键是将 `let first = &v[0]` 改成 `let first = v[0]` 后，`first` 是 `i32` 值（Copy），与 `v` 无关，更安全。使用 `&v[0]` 仍然会有借用冲突。

**5-2**：

1. 方式 A 的时间复杂度是 O(n²)，因为每次 `remove(i)` 都需要将后续元素向前移动一位。方式 B 的 `retain` 是 O(n)，内部使用一次遍历 + 一次批量移动实现。

2. 如果每次都 `i += 1`，删除偶数元素后索引不会重新检查当前位置（因为后续元素前移了），会**跳过**紧随其后的元素。例如 `[2, 2, 1]`，删除索引 0 的元素 2 后，数组变为 `[2, 1]`，i 变成 1，第二个 2 被跳过。

3. `retain` 的底层原理类似于"双指针"：慢指针 `j` 指向下一个要保留的位置，快指针 `i` 遍历所有元素。当元素满足保留条件时，移动到 `j` 位置并使 `j++`；否则跳过。遍历完成后截断到 `j`。避免了每次删除都移动后续元素的 O(n²) 开销。

**5-3**：

1. 迭代器重写：
```rust
fn first_n_even(n: usize) -> Vec<i32> {
    (1..).filter(|x| x % 2 == 0).take(n).collect()
}
```

2. 优化：
```rust
fn first_n_even_optimized(n: usize) -> Vec<i32> {
    let mut result = Vec::with_capacity(n);  // 预分配
    (1..).filter(|x| x % 2 == 0).take(n).for_each(|x| result.push(x));
    result
}
// 或者更简单的：从 2 开始每次加 2
fn first_n_even_optimized(n: usize) -> Vec<i32> {
    (2..).step_by(2).take(n).collect()
}
```
使用 `Vec::with_capacity(n)` 预分配可以避免多次重分配的开销。

**5-4**：

1. `v2` 变成空 Vec `[]`。因为 `append` 方法将所有元素**移动**到目标 Vec，并清空源 Vec。这是 O(1) 时间，只交换了指针。

2. 区别：
   - `append`：移动所有元素，源 Vec 被清空。适用于需要转移所有权的场景。
   - `extend`：从迭代器克隆/复制元素到目标 Vec，源数据保持不变。适用于需要保留源的场景。
   - 性能上 `append` 只需交换内部指针，是 O(1)；`extend` 需要逐个复制，是 O(n)。

3. 使用 `extend` 或 `clone`：
```rust
v1.extend_from_slice(&v2);  // v2 保持不变
// 或
v1.extend(v2.iter().cloned()); // 迭代器方式
```

**5-5**：

```rust
fn add_item(&mut self, item: Item) -> Result<(), String> {
    // 先检查是否有同名物品
    if let Some(existing) = self.items.iter_mut().find(|i| i.name == item.name) {
        existing.count += item.count;
        return Ok(());
    }

    // 新增物品，检查容量
    if self.items.len() >= self.capacity {
        return Err(format!("背包已满（{}/{}）", self.items.len(), self.capacity));
    }

    self.items.push(item);
    Ok(())
}

fn remove_item(&mut self, name: &str, count: u32) -> Result<(), String> {
    let pos = self
        .items
        .iter()
        .position(|i| i.name == name)
        .ok_or(format!("物品「{}」不存在", name))?;

    if self.items[pos].count < count {
        return Err(format!(
            "物品「{}」数量不足（需要 {}，当前 {}）",
            name, count, self.items[pos].count
        ));
    }

    self.items[pos].count -= count;
    if self.items[pos].count == 0 {
        self.items.remove(pos);
    }

    Ok(())
}
```

关键点是先检查是否可以叠加已有物品（不需要新槽位），再检查容量限制。这样当物品已存在时，即使背包"已满"也能正确叠加数量。

</details>