CS_learn/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-04-05 11:41:22 +08:00
Code Issues Packages Projects Releases Wiki Activity

build

Browse Source
This commit is contained in:
krahets
2023-07-26 10:57:40 +08:00
parent 6381f16506
commit f8f7086196
52 changed files with 4032 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

92
chapter_array_and_linkedlist/array.md
View File

@@ -106,6 +106,12 @@ comments: true
List<int> nums = [1, 3, 2, 5, 4];
```
=== "Rust"
```rust title="array.rs"
```
## 4.1.1. &nbsp; 数组优点
**在数组中访问元素非常高效**。由于数组元素被存储在连续的内存空间中，因此计算数组元素的内存地址非常容易。给定数组首个元素的地址和某个元素的索引，我们可以使用以下公式计算得到该元素的内存地址，从而直接访问此元素。
@@ -270,6 +276,19 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
}
```
=== "Rust"
```rust title="array.rs"
/* 随机返回一个数组元素 */
fn random_access(nums: &[i32]) -> i32 {
// 在区间 [0, nums.len()) 中随机抽取一个数字
let random_index = rand::thread_rng().gen_range(0..nums.len());
// 获取并返回随机元素
let random_num = nums[random_index];
random_num
}
```
## 4.1.2. &nbsp; 数组缺点
**数组在初始化后长度不可变**。由于系统无法保证数组之后的内存空间是可用的，因此数组长度无法扩展。而若希望扩容数组，则需新建一个数组，然后把原数组元素依次拷贝到新数组，在数组很大的情况下，这是非常耗时的。
@@ -457,6 +476,22 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
}
```
=== "Rust"
```rust title="array.rs"
/* 扩展数组长度 */
fn extend(nums: Vec<i32>, enlarge: usize) -> Vec<i32> {
// 初始化一个扩展长度后的数组
let mut res: Vec<i32> = vec![0; nums.len() + enlarge];
// 将原数组中的所有元素复制到新
for i in 0..nums.len() {
res[i] = nums[i];
}
// 返回扩展后的新数组
res
}
```
**数组中插入或删除元素效率低下**。如果我们想要在数组中间插入一个元素，由于数组元素在内存中是“紧挨着的”，它们之间没有空间再放任何数据。因此，我们不得不将此索引之后的所有元素都向后移动一位，然后再把元素赋值给该索引。
![数组插入元素](array.assets/array_insert_element.png)
@@ -616,6 +651,20 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
}
```
=== "Rust"
```rust title="array.rs"
/* 在数组的索引 index 处插入元素 num */
fn insert(nums: &mut Vec<i32>, num: i32, index: usize) {
// 把索引 index 以及之后的所有元素向后移动一位
for i in (index + 1..nums.len()).rev() {
nums[i] = nums[i - 1];
}
// 将 num 赋给 index 处元素
nums[index] = num;
}
```
删除元素也类似，如果我们想要删除索引 $i$ 处的元素，则需要把索引 $i$ 之后的元素都向前移动一位。值得注意的是，删除元素后，原先末尾的元素变得“无意义”了，我们无需特意去修改它。
![数组删除元素](array.assets/array_remove_element.png)
@@ -755,6 +804,18 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
}
```
=== "Rust"
```rust title="array.rs"
/* 删除索引 index 处元素 */
fn remove(nums: &mut Vec<i32>, index: usize) {
// 把索引 index 之后的所有元素向前移动一位
for i in index..nums.len() - 1 {
nums[i] = nums[i + 1];
}
}
```
总结来看，数组的插入与删除操作有以下缺点：
- **时间复杂度高**：数组的插入和删除的平均时间复杂度均为 $O(n)$ ，其中 $n$ 为数组长度。
@@ -951,6 +1012,23 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
}
```
=== "Rust"
```rust title="array.rs"
/* 遍历数组 */
fn traverse(nums: &[i32]) {
let mut _count = 0;
// 通过索引遍历数组
for _ in 0..nums.len() {
_count += 1;
}
// 直接遍历数组
for _ in nums {
_count += 1;
}
}
```
**数组查找**。通过遍历数组，查找数组内的指定元素，并输出对应索引。
=== "Java"
@@ -1096,6 +1174,20 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
}
```
=== "Rust"
```rust title="array.rs"
/* 在数组中查找指定元素 */
fn find(nums: &[i32], target: i32) -> Option<usize> {
for i in 0..nums.len() {
if nums[i] == target {
return Some(i);
}
}
None
}
```
## 4.1.4. &nbsp; 数组典型应用
数组是最基础的数据结构，在各类数据结构和算法中都有广泛应用。

72
chapter_array_and_linkedlist/linked_list.md
View File

@@ -169,6 +169,12 @@ comments: true
}
```
=== "Rust"
```rust title=""
```
!!! question "尾节点指向什么？"
我们将链表的最后一个节点称为「尾节点」，其指向的是“空”，在 Java, C++, Python 中分别记为 $\text{null}$ , $\text{nullptr}$ , $\text{None}$ 。在不引起歧义的前提下，本书都使用 $\text{None}$ 来表示空。
@@ -366,6 +372,12 @@ comments: true
n3.next = n4;
```
=== "Rust"
```rust title="linked_list.rs"
```
## 4.2.1. &nbsp; 链表优点
**链表中插入与删除节点的操作效率高**。例如，如果我们想在链表中间的两个节点 `A` , `B` 之间插入一个新节点 `P` ，我们只需要改变两个节点指针即可，时间复杂度为 $O(1)$ ；相比之下，数组的插入操作效率要低得多。
@@ -494,6 +506,18 @@ comments: true
}
```
=== "Rust"
```rust title="linked_list.rs"
/* 在链表的节点 n0 之后插入节点 P */
#[allow(non_snake_case)]
pub fn insert<T>(n0: &Rc<RefCell<ListNode<T>>>, P: Rc<RefCell<ListNode<T>>>) {
let n1 = n0.borrow_mut().next.take();
P.borrow_mut().next = n1;
n0.borrow_mut().next = Some(P);
}
```
在链表中删除节点也非常方便，只需改变一个节点的指针即可。如下图所示，尽管在删除操作完成后，节点 `P` 仍然指向 `n1` ，但实际上 `P` 已经不再属于此链表，因为遍历此链表时无法访问到 `P` 。
![链表删除节点](linked_list.assets/linkedlist_remove_node.png)
@@ -659,6 +683,22 @@ comments: true
}
```
=== "Rust"
```rust title="linked_list.rs"
/* 删除链表的节点 n0 之后的首个节点 */
#[allow(non_snake_case)]
pub fn remove<T>(n0: &Rc<RefCell<ListNode<T>>>) {
if n0.borrow().next.is_none() {return};
// n0 -> P -> n1
let P = n0.borrow_mut().next.take();
if let Some(node) = P {
let n1 = node.borrow_mut().next.take();
n0.borrow_mut().next = n1;
}
}
```
## 4.2.2. &nbsp; 链表缺点
**链表访问节点效率较低**。如上节所述，数组可以在 $O(1)$ 时间下访问任意元素。然而，链表无法直接访问任意节点，这是因为系统需要从头节点出发，逐个向后遍历直至找到目标节点。例如，若要访问链表索引为 `index`（即第 `index + 1` 个）的节点，则需要向后遍历 `index` 轮。
@@ -819,6 +859,19 @@ comments: true
}
```
=== "Rust"
```rust title="linked_list.rs"
/* 访问链表中索引为 index 的节点 */
pub fn access<T>(head: Rc<RefCell<ListNode<T>>>, index: i32) -> Rc<RefCell<ListNode<T>>> {
if index <= 0 {return head};
if let Some(node) = &head.borrow_mut().next {
return access(node.clone(), index - 1);
}
return head;
}
```
**链表的内存占用较大**。链表以节点为单位，每个节点除了保存值之外，还需额外保存指针（引用）。这意味着在相同数据量的情况下，链表比数组需要占用更多的内存空间。
## 4.2.3. &nbsp; 链表常用操作
@@ -1005,6 +1058,19 @@ comments: true
}
```
=== "Rust"
```rust title="linked_list.rs"
/* 在链表中查找值为 target 的首个节点 */
pub fn find<T: PartialEq>(head: Rc<RefCell<ListNode<T>>>, target: T, index: i32) -> i32 {
if head.borrow().val == target {return index};
if let Some(node) = &head.borrow_mut().next {
return find(node.clone(), target, index + 1);
}
return -1;
}
```
## 4.2.4. &nbsp; 常见链表类型
**单向链表**。即上述介绍的普通链表。单向链表的节点包含值和指向下一节点的指针（引用）两项数据。我们将首个节点称为头节点，将最后一个节点成为尾节点，尾节点指向空 $\text{None}$ 。
@@ -1184,6 +1250,12 @@ comments: true
}
```
=== "Rust"
```rust title=""
```
![常见链表种类](linked_list.assets/linkedlist_common_types.png)
<p align="center"> Fig. 常见链表种类 </p>

147
chapter_array_and_linkedlist/list.md
View File

@@ -120,6 +120,12 @@ comments: true
List<int> list = [1, 3, 2, 5, 4];
```
=== "Rust"
```rust title="list.rs"
```
**访问与更新元素**。由于列表的底层数据结构是数组，因此可以在 $O(1)$ 时间内访问和更新元素，效率很高。
=== "Java"
@@ -228,6 +234,12 @@ comments: true
list[1] = 0; // 将索引 1 处的元素更新为 0
```
=== "Rust"
```rust title="list.rs"
```
**在列表中添加、插入、删除元素**。相较于数组，列表可以自由地添加与删除元素。在列表尾部添加元素的时间复杂度为 $O(1)$ ，但插入和删除元素的效率仍与数组相同，时间复杂度为 $O(N)$ 。
=== "Java"
@@ -436,6 +448,12 @@ comments: true
list.removeAt(3); // 删除索引 3 处的元素
```
=== "Rust"
```rust title="list.rs"
```
**遍历列表**。与数组一样，列表可以根据索引遍历，也可以直接遍历各元素。
=== "Java"
@@ -603,6 +621,12 @@ comments: true
}
```
=== "Rust"
```rust title="list.rs"
```
**拼接两个列表**。给定一个新列表 `list1` ，我们可以将该列表拼接到原列表的尾部。
=== "Java"
@@ -694,6 +718,12 @@ comments: true
list.addAll(list1); // 将列表 list1 拼接到 list 之后
```
=== "Rust"
```rust title="list.rs"
```
**排序列表**。排序也是常用的方法之一。完成列表排序后，我们便可以使用在数组类算法题中经常考察的「二分查找」和「双指针」算法。
=== "Java"
@@ -772,6 +802,12 @@ comments: true
list.sort(); // 排序后，列表元素从小到大排列
```
=== "Rust"
```rust title="list.rs"
```
## 4.3.2. &nbsp; 列表实现 *
为了帮助加深对列表的理解，我们在此提供一个简易版列表实现。需要关注三个核心点：
@@ -1918,3 +1954,114 @@ comments: true
}
}
```
=== "Rust"
```rust title="my_list.rs"
/* 列表类简易实现 */
#[allow(dead_code)]
struct MyList {
nums: Vec<i32>, // 数组（存储列表元素）
capacity: usize, // 列表容量
size: usize, // 列表长度（即当前元素数量）
extend_ratio: usize, // 每次列表扩容的倍数
}
#[allow(unused,unused_comparisons)]
impl MyList {
/* 构造方法 */
pub fn new(capacity: usize) -> Self {
let mut vec = Vec::new();
vec.resize(capacity, 0);
Self {
nums: vec,
capacity,
size: 0,
extend_ratio: 2,
}
}
/* 获取列表长度（即当前元素数量）*/
pub fn size(&self) -> usize {
return self.size;
}
/* 获取列表容量 */
pub fn capacity(&self) -> usize {
return self.capacity;
}
/* 访问元素 */
pub fn get(&self, index: usize) -> i32 {
// 索引如果越界则抛出异常，下同
if index < 0 || index >= self.size {panic!("索引越界")};
return self.nums[index];
}
/* 更新元素 */
pub fn set(&mut self, index: usize, num: i32) {
if index < 0 || index >= self.size {panic!("索引越界")};
self.nums[index] = num;
}
/* 尾部添加元素 */
pub fn add(&mut self, num: i32) {
// 元素数量超出容量时，触发扩容机制
if self.size == self.capacity() {
self.extend_capacity();
}
self.nums[self.size] = num;
// 更新元素数量
self.size += 1;
}
/* 中间插入元素 */
pub fn insert(&mut self, index: usize, num: i32) {
if index < 0 || index >= self.size() {panic!("索引越界")};
// 元素数量超出容量时，触发扩容机制
if self.size == self.capacity() {
self.extend_capacity();
}
// 将索引 index 以及之后的元素都向后移动一位
for j in (index..self.size).rev() {
self.nums[j + 1] = self.nums[j];
}
self.nums[index] = num;
// 更新元素数量
self.size += 1;
}
/* 删除元素 */
pub fn remove(&mut self, index: usize) -> i32 {
if index < 0 || index >= self.size() {panic!("索引越界")};
let num = self.nums[index];
// 将索引 index 之后的元素都向前移动一位
for j in (index..self.size - 1) {
self.nums[j] = self.nums[j + 1];
}
// 更新元素数量
self.size -= 1;
// 返回被删除元素
return num;
}
/* 列表扩容 */
pub fn extend_capacity(&mut self) {
// 新建一个长度为原数组 extend_ratio 倍的新数组，并将原数组拷贝到新数组
let new_capacity = self.capacity * self.extend_ratio;
self.nums.resize(new_capacity, 0);
// 更新列表容量
self.capacity = new_capacity;
}
/* 将列表转换为数组 */
pub fn to_array(&mut self) -> Vec<i32> {
// 仅转换有效长度范围内的列表元素
let mut nums = Vec::new();
for i in 0..self.size {
nums.push(self.get(i));
}
nums
}
}
```