CS_learn/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-04-13 17:09:46 +08:00
Code Issues Packages Projects Releases Wiki Activity

build

Browse Source
This commit is contained in:
krahets
2023-06-02 02:38:24 +08:00
parent 874e75d92d
commit 2a85d796e6
35 changed files with 2354 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

109
chapter_array_and_linkedlist/array.md
View File

@@ -98,6 +98,12 @@ comments: true
var nums = [_]i32{ 1, 3, 2, 5, 4 };
```
=== "Dart"
```dart title="array.dart"
```
## 4.1.1.   数组优点
**在数组中访问元素非常高效**。由于数组元素被存储在连续的内存空间中，因此计算数组元素的内存地址非常容易。给定数组首个元素的地址和某个元素的索引，我们可以使用以下公式计算得到该元素的内存地址，从而直接访问此元素。
@@ -249,6 +255,19 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
}
```
=== "Dart"
```dart title="array.dart"
/* 随机返回一个 数组元素 */
int randomAccess(List nums) {
// 在区间[0,size) 中随机抽取一个数字
int randomIndex = Random().nextInt(nums.length);
// 获取并返回随机元素
int randomNum = nums[randomIndex];
return randomNum;
}
```
## 4.1.2.   数组缺点
**数组在初始化后长度不可变**。由于系统无法保证数组之后的内存空间是可用的，因此数组长度无法扩展。而若希望扩容数组，则需新建一个数组，然后把原数组元素依次拷贝到新数组，在数组很大的情况下，这是非常耗时的。
@@ -420,6 +439,23 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
}
```
=== "Dart"
```dart title="array.dart"
/* 扩展数组长度 */
List extend(List nums, int enlarge) {
// 初始化一个扩展长度后的数组，元素初始值为0
List<int> res = List.filled(nums.length + enlarge, 0);
// 将原数组中的所有元素复制到新数组
for (var i = 0; i < nums.length; i++) {
res[i] = nums[i];
}
// 返回扩展后的新数组
return res;
}
```
**数组中插入或删除元素效率低下**。如果我们想要在数组中间插入一个元素，由于数组元素在内存中是“紧挨着的”，它们之间没有空间再放任何数据。因此，我们不得不将此索引之后的所有元素都向后移动一位，然后再把元素赋值给该索引。
![数组插入元素](array.assets/array_insert_element.png)
@@ -550,6 +586,35 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
}
```
=== "Zig"
```zig title="array.zig"
// 在数组的索引 index 处插入元素 num
fn insert(nums: []i32, num: i32, index: usize) void {
// 把索引 index 以及之后的所有元素向后移动一位
var i = nums.len - 1;
while (i > index) : (i -= 1) {
nums[i] = nums[i - 1];
}
// 将 num 赋给 index 处元素
nums[index] = num;
}
```
=== "Dart"
```dart title="array.dart"
/* 在数组的索引 index 处插入元素 num */
void insert(List nums, int num, int index) {
// 把索引index以及之后的所有元素向后移动一位
for (var i = nums.length - 1; i > index; i--) {
nums[i] = nums[i - 1];
}
// 将 num 赋给 index 处元素
nums[index] = num;
}
```
删除元素也类似，如果我们想要删除索引 $i$ 处的元素，则需要把索引 $i$ 之后的元素都向前移动一位。值得注意的是，删除元素后，原先末尾的元素变得“无意义”了，我们无需特意去修改它。
![数组删除元素](array.assets/array_remove_element.png)
@@ -677,6 +742,17 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
}
```
=== "Dart"
```dart title="array.dart"
/* 删除索引 index 处元素 */
void remove(List nums, int index) {
for (var i = index; i < nums.length - 1; i++) {
nums[i] = nums[i + 1];
}
}
```
总结来看，数组的插入与删除操作有以下缺点：
- **时间复杂度高**：数组的插入和删除的平均时间复杂度均为 $O(n)$ ，其中 $n$ 为数组长度。
@@ -852,6 +928,27 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
}
```
=== "Dart"
```dart title="array.dart"
/* 遍历数组元素 */
void traverse(List nums) {
var count = 0;
// 通过索引遍历数组
for (var i = 0; i < nums.length; i++) {
count++;
}
// 直接遍历数组
for (var num in nums) {
count++;
}
// 通过forEach方法遍历数组
nums.forEach((element) {
count++;
});
}
```
**数组查找**。通过遍历数组，查找数组内的指定元素，并输出对应索引。
=== "Java"
@@ -985,6 +1082,18 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
}
```
=== "Dart"
```dart title="array.dart"
/* 在数组中查找指定元素 */
int find(List nums, int target) {
for (var i = 0; i < nums.length; i++) {
if (nums[i] == target) return i;
}
return -1;
}
```
## 4.1.4. &nbsp; 数组典型应用
**随机访问**。如果我们想要随机抽取一些样本，那么可以用数组存储，并生成一个随机序列，根据索引实现样本的随机抽取。

71
chapter_array_and_linkedlist/linked_list.md
View File

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

129
chapter_array_and_linkedlist/list.md
View File

@@ -110,6 +110,12 @@ comments: true
try list.appendSlice(&[_]i32{ 1, 3, 2, 5, 4 });
```
=== "Dart"
```dart title="list.dart"
```
**访问与更新元素**。由于列表的底层数据结构是数组，因此可以在 $O(1)$ 时间内访问和更新元素，效率很高。
=== "Java"
@@ -208,6 +214,12 @@ comments: true
list.items[1] = 0; // 将索引 1 处的元素更新为 0
```
=== "Dart"
```dart title="list.dart"
```
**在列表中添加、插入、删除元素**。相较于数组，列表可以自由地添加与删除元素。在列表尾部添加元素的时间复杂度为 $O(1)$ ，但插入和删除元素的效率仍与数组相同，时间复杂度为 $O(N)$ 。
=== "Java"
@@ -396,6 +408,12 @@ comments: true
_ = list.orderedRemove(3); // 删除索引 3 处的元素
```
=== "Dart"
```dart title="list.dart"
```
**遍历列表**。与数组一样，列表可以根据索引遍历，也可以直接遍历各元素。
=== "Java"
@@ -549,6 +567,12 @@ comments: true
}
```
=== "Dart"
```dart title="list.dart"
```
**拼接两个列表**。给定一个新列表 `list1` ，我们可以将该列表拼接到原列表的尾部。
=== "Java"
@@ -632,6 +656,12 @@ comments: true
try list.insertSlice(list.items.len, list1.items); // 将列表 list1 拼接到 list 之后
```
=== "Dart"
```dart title="list.dart"
```
**排序列表**。排序也是常用的方法之一。完成列表排序后，我们便可以使用在数组类算法题中经常考察的「二分查找」和「双指针」算法。
=== "Java"
@@ -703,6 +733,12 @@ comments: true
std.sort.sort(i32, list.items, {}, comptime std.sort.asc(i32));
```
=== "Dart"
```dart title="list.dart"
```
## 4.3.2. &nbsp; 列表实现 *
为了帮助加深对列表的理解，我们在此提供一个简易版列表实现。需要关注三个核心点：
@@ -1756,3 +1792,96 @@ comments: true
};
}
```
=== "Dart"
```dart title="my_list.dart"
/* 列表类简易实现 */
class MyList {
late List<int> _nums; // 数组（存储列表元素）
int _capacity = 10; // 列表容量
int _size = 0; // 列表长度（即当前元素数量）
int _extendRatio = 2; // 每次列表扩容的倍数
/* 构造方法 */
MyList() {
_nums = List.filled(_capacity, 0);
}
/* 获取列表长度（即当前元素数量）*/
int size() => _size;
/* 获取列表容量 */
int capacity() => _capacity;
/* 访问元素 */
int get(int index) {
if (index >= _size) throw RangeError('索引越界');
return _nums[index];
}
/* 更新元素 */
void set(int index, int num) {
if (index >= _size) throw RangeError('索引越界');
_nums[index] = num;
}
/* 尾部添加元素 */
void add(int num) {
// 元素数量超出容量时，触发扩容机制
if (_size == _capacity) extendCapacity();
_nums[_size] = num;
// 更新元素数量
_size++;
}
/* 中间插入元素 */
void insert(int index, int num) {
if (index >= _size) throw RangeError('索引越界');
// 元素数量超出容量时，触发扩容机制
if (_size == _capacity) extendCapacity();
// 将索引 index 以及之后的元素都向后移动一位
for (var j = _size - 1; j >= index; j--) {
_nums[j + 1] = _nums[j];
}
_nums[index] = num;
// 更新元素数量
_size++;
}
/* 删除元素 */
int remove(int index) {
if (index >= _size) throw RangeError('索引越界');
int num = _nums[index];
// 将索引 index 之后的元素都向前移动一位
for (var j = index; j < _size - 1; j++) {
_nums[j] = _nums[j + 1];
}
// 更新元素数量
_size--;
// 返回被删除元素
return num;
}
/* 列表扩容 */
void extendCapacity() {
// 新建一个长度为 _capacity * _extendRatio 的数组
final _newNums = List.filled(_capacity * _extendRatio, 0);
// 将原数组拷贝到新数组
List.copyRange(_newNums, 0, _nums);
// 更新 _nums 的引用
_nums = _newNums;
// 更新列表容量
_capacity = _nums.length;
}
/* 将列表转换为数组 */
List<int> toArray() {
List<int> nums = [];
for (var i = 0; i < _size; i++) {
nums.add(get(i));
}
return nums;
}
}
```