3.4.1 解答

Tue, 11 Aug 2026 11:30:00 +0800
译文 · 基于 Comprehensive Rust
原文链接: https://google.github.io/comprehensive-rust/smart-pointers/solution.html
3.4.1 解答

 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


// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0
use std::cmp::Ordering;

/// 二叉树中的一个节点。
#[derive(Debug)]
struct Node<T: Ord> {
 value: T,
 left: Subtree<T>,
 right: Subtree<T>,
}

/// 可能为空的子树。
#[derive(Debug)]
struct Subtree<T: Ord>(Option<Box<Node<T>>>);

/// 用二叉树存储一组值的容器。
///
/// 若同一值被多次添加，也只存储一次。
#[derive(Debug)]
pub struct BinaryTree<T: Ord> {
 root: Subtree<T>,
}

impl<T: Ord> BinaryTree<T> {
 fn new() -> Self {
 Self { root: Subtree::new() }
 }

 fn insert(&mut self, value: T) {
 self.root.insert(value);
 }

 fn has(&self, value: &T) -> bool {
 self.root.has(value)
 }

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

impl<T: Ord> Subtree<T> {
 fn new() -> Self {
 Self(None)
 }

 fn insert(&mut self, value: T) {
 match &mut self.0 {
 None => self.0 = Some(Box::new(Node::new(value))),
 Some(n) => match value.cmp(&n.value) {
 Ordering::Less => n.left.insert(value),
 Ordering::Equal => {}
 Ordering::Greater => n.right.insert(value),
 },
 }
 }

 fn has(&self, value: &T) -> bool {
 match &self.0 {
 None => false,
 Some(n) => match value.cmp(&n.value) {
 Ordering::Less => n.left.has(value),
 Ordering::Equal => true,
 Ordering::Greater => n.right.has(value),
 },
 }
 }

 fn len(&self) -> usize {
 match &self.0 {
 None => 0,
 Some(n) => 1 + n.left.len() + n.right.len(),
 }
 }
}

impl<T: Ord> Node<T> {
 fn new(value: T) -> Self {
 Self { value, left: Subtree::new(), right: Subtree::new() }
 }
}

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

 #[test]
 fn len() {
 let mut tree = BinaryTree::new();
 assert_eq!(tree.len(), 0);
 tree.insert(2);
 assert_eq!(tree.len(), 1);
 tree.insert(1);
 assert_eq!(tree.len(), 2);
 tree.insert(2); // not a unique item
 assert_eq!(tree.len(), 2);
 tree.insert(3);
 assert_eq!(tree.len(), 3);
 }

 #[test]
 fn has() {
 let mut tree = BinaryTree::new();
 fn check_has(tree: &BinaryTree<i32>, exp: &[bool]) {
 let got: Vec<bool> =
 (0..exp.len()).map(|i| tree.has(&(i as i32))).collect();
 assert_eq!(&got, exp);
 }

 check_has(&tree, &[false, false, false, false, false]);
 tree.insert(0);
 check_has(&tree, &[true, false, false, false, false]);
 tree.insert(4);
 check_has(&tree, &[true, false, false, false, true]);
 tree.insert(4);
 check_has(&tree, &[true, false, false, false, true]);
 tree.insert(3);
 check_has(&tree, &[true, false, false, true, true]);
 }

 #[test]
 fn unbalanced() {
 let mut tree = BinaryTree::new();
 for i in 0..100 {
 tree.insert(i);
 }
 assert_eq!(tree.len(), 100);
 assert!(tree.has(&50));
 }
}
3.4 练习：二叉树 on 编程那些事儿

3.4.1 解答

3.4.1 解答
