Squash the language code blocks and fix list.md (#865)

This commit is contained in:
Yudong Jin
2023-10-16 12:06:00 -05:00
committed by GitHub
parent 346c8451de
commit faa44fecd2
52 changed files with 409 additions and 10482 deletions

View File

@ -123,77 +123,9 @@
在数组中访问元素是非常高效的,我们可以在 $O(1)$ 时间内随机访问数组中的任意一个元素。
=== "Python"
```python title="array.py"
[class]{}-[func]{random_access}
```
=== "C++"
```cpp title="array.cpp"
[class]{}-[func]{randomAccess}
```
=== "Java"
```java title="array.java"
[class]{array}-[func]{randomAccess}
```
=== "C#"
```csharp title="array.cs"
[class]{array}-[func]{RandomAccess}
```
=== "Go"
```go title="array.go"
[class]{}-[func]{randomAccess}
```
=== "Swift"
```swift title="array.swift"
[class]{}-[func]{randomAccess}
```
=== "JS"
```javascript title="array.js"
[class]{}-[func]{randomAccess}
```
=== "TS"
```typescript title="array.ts"
[class]{}-[func]{randomAccess}
```
=== "Dart"
```dart title="array.dart"
[class]{}-[func]{randomAccess}
```
=== "Rust"
```rust title="array.rs"
[class]{}-[func]{random_access}
```
=== "C"
```c title="array.c"
[class]{}-[func]{randomAccess}
```
=== "Zig"
```zig title="array.zig"
[class]{}-[func]{randomAccess}
```
```src
[file]{array}-[class]{}-[func]{random_access}
```
### 插入元素
@ -203,77 +135,9 @@
值得注意的是,由于数组的长度是固定的,因此插入一个元素必定会导致数组尾部元素的“丢失”。我们将这个问题的解决方案留在列表章节中讨论。
=== "Python"
```python title="array.py"
[class]{}-[func]{insert}
```
=== "C++"
```cpp title="array.cpp"
[class]{}-[func]{insert}
```
=== "Java"
```java title="array.java"
[class]{array}-[func]{insert}
```
=== "C#"
```csharp title="array.cs"
[class]{array}-[func]{Insert}
```
=== "Go"
```go title="array.go"
[class]{}-[func]{insert}
```
=== "Swift"
```swift title="array.swift"
[class]{}-[func]{insert}
```
=== "JS"
```javascript title="array.js"
[class]{}-[func]{insert}
```
=== "TS"
```typescript title="array.ts"
[class]{}-[func]{insert}
```
=== "Dart"
```dart title="array.dart"
[class]{}-[func]{insert}
```
=== "Rust"
```rust title="array.rs"
[class]{}-[func]{insert}
```
=== "C"
```c title="array.c"
[class]{}-[func]{insert}
```
=== "Zig"
```zig title="array.zig"
[class]{}-[func]{insert}
```
```src
[file]{array}-[class]{}-[func]{insert}
```
### 删除元素
@ -283,77 +147,9 @@
请注意,删除元素完成后,原先末尾的元素变得“无意义”了,所以我们无须特意去修改它。
=== "Python"
```python title="array.py"
[class]{}-[func]{remove}
```
=== "C++"
```cpp title="array.cpp"
[class]{}-[func]{remove}
```
=== "Java"
```java title="array.java"
[class]{array}-[func]{remove}
```
=== "C#"
```csharp title="array.cs"
[class]{array}-[func]{Remove}
```
=== "Go"
```go title="array.go"
[class]{}-[func]{remove}
```
=== "Swift"
```swift title="array.swift"
[class]{}-[func]{remove}
```
=== "JS"
```javascript title="array.js"
[class]{}-[func]{remove}
```
=== "TS"
```typescript title="array.ts"
[class]{}-[func]{remove}
```
=== "Dart"
```dart title="array.dart"
[class]{}-[func]{remove}
```
=== "Rust"
```rust title="array.rs"
[class]{}-[func]{remove}
```
=== "C"
```c title="array.c"
[class]{}-[func]{removeItem}
```
=== "Zig"
```zig title="array.zig"
[class]{}-[func]{remove}
```
```src
[file]{array}-[class]{}-[func]{remove}
```
总的来看,数组的插入与删除操作有以下缺点。
@ -365,77 +161,9 @@
在大多数编程语言中,我们既可以通过索引遍历数组,也可以直接遍历获取数组中的每个元素。
=== "Python"
```python title="array.py"
[class]{}-[func]{traverse}
```
=== "C++"
```cpp title="array.cpp"
[class]{}-[func]{traverse}
```
=== "Java"
```java title="array.java"
[class]{array}-[func]{traverse}
```
=== "C#"
```csharp title="array.cs"
[class]{array}-[func]{Traverse}
```
=== "Go"
```go title="array.go"
[class]{}-[func]{traverse}
```
=== "Swift"
```swift title="array.swift"
[class]{}-[func]{traverse}
```
=== "JS"
```javascript title="array.js"
[class]{}-[func]{traverse}
```
=== "TS"
```typescript title="array.ts"
[class]{}-[func]{traverse}
```
=== "Dart"
```dart title="array.dart"
[class]{}-[func]{traverse}
```
=== "Rust"
```rust title="array.rs"
[class]{}-[func]{traverse}
```
=== "C"
```c title="array.c"
[class]{}-[func]{traverse}
```
=== "Zig"
```zig title="array.zig"
[class]{}-[func]{traverse}
```
```src
[file]{array}-[class]{}-[func]{traverse}
```
### 查找元素
@ -443,77 +171,9 @@
因为数组是线性数据结构,所以上述查找操作被称为“线性查找”。
=== "Python"
```python title="array.py"
[class]{}-[func]{find}
```
=== "C++"
```cpp title="array.cpp"
[class]{}-[func]{find}
```
=== "Java"
```java title="array.java"
[class]{array}-[func]{find}
```
=== "C#"
```csharp title="array.cs"
[class]{array}-[func]{Find}
```
=== "Go"
```go title="array.go"
[class]{}-[func]{find}
```
=== "Swift"
```swift title="array.swift"
[class]{}-[func]{find}
```
=== "JS"
```javascript title="array.js"
[class]{}-[func]{find}
```
=== "TS"
```typescript title="array.ts"
[class]{}-[func]{find}
```
=== "Dart"
```dart title="array.dart"
[class]{}-[func]{find}
```
=== "Rust"
```rust title="array.rs"
[class]{}-[func]{find}
```
=== "C"
```c title="array.c"
[class]{}-[func]{find}
```
=== "Zig"
```zig title="array.zig"
[class]{}-[func]{find}
```
```src
[file]{array}-[class]{}-[func]{find}
```
### 扩容数组
@ -521,77 +181,9 @@
如果我们希望扩容数组,则需重新建立一个更大的数组,然后把原数组元素依次拷贝到新数组。这是一个 $O(n)$ 的操作,在数组很大的情况下是非常耗时的。
=== "Python"
```python title="array.py"
[class]{}-[func]{extend}
```
=== "C++"
```cpp title="array.cpp"
[class]{}-[func]{extend}
```
=== "Java"
```java title="array.java"
[class]{array}-[func]{extend}
```
=== "C#"
```csharp title="array.cs"
[class]{array}-[func]{Extend}
```
=== "Go"
```go title="array.go"
[class]{}-[func]{extend}
```
=== "Swift"
```swift title="array.swift"
[class]{}-[func]{extend}
```
=== "JS"
```javascript title="array.js"
[class]{}-[func]{extend}
```
=== "TS"
```typescript title="array.ts"
[class]{}-[func]{extend}
```
=== "Dart"
```dart title="array.dart"
[class]{}-[func]{extend}
```
=== "Rust"
```rust title="array.rs"
[class]{}-[func]{extend}
```
=== "C"
```c title="array.c"
[class]{}-[func]{extend}
```
=== "Zig"
```zig title="array.zig"
[class]{}-[func]{extend}
```
```src
[file]{array}-[class]{}-[func]{extend}
```
## 数组优点与局限性

View File

@ -405,77 +405,9 @@
![链表插入节点示例](linked_list.assets/linkedlist_insert_node.png)
=== "Python"
```python title="linked_list.py"
[class]{}-[func]{insert}
```
=== "C++"
```cpp title="linked_list.cpp"
[class]{}-[func]{insert}
```
=== "Java"
```java title="linked_list.java"
[class]{linked_list}-[func]{insert}
```
=== "C#"
```csharp title="linked_list.cs"
[class]{linked_list}-[func]{Insert}
```
=== "Go"
```go title="linked_list.go"
[class]{}-[func]{insertNode}
```
=== "Swift"
```swift title="linked_list.swift"
[class]{}-[func]{insert}
```
=== "JS"
```javascript title="linked_list.js"
[class]{}-[func]{insert}
```
=== "TS"
```typescript title="linked_list.ts"
[class]{}-[func]{insert}
```
=== "Dart"
```dart title="linked_list.dart"
[class]{}-[func]{insert}
```
=== "Rust"
```rust title="linked_list.rs"
[class]{}-[func]{insert}
```
=== "C"
```c title="linked_list.c"
[class]{}-[func]{insert}
```
=== "Zig"
```zig title="linked_list.zig"
[class]{}-[func]{insert}
```
```src
[file]{linked_list}-[class]{}-[func]{insert}
```
### 删除节点
@ -485,229 +417,25 @@
![链表删除节点](linked_list.assets/linkedlist_remove_node.png)
=== "Python"
```python title="linked_list.py"
[class]{}-[func]{remove}
```
=== "C++"
```cpp title="linked_list.cpp"
[class]{}-[func]{remove}
```
=== "Java"
```java title="linked_list.java"
[class]{linked_list}-[func]{remove}
```
=== "C#"
```csharp title="linked_list.cs"
[class]{linked_list}-[func]{Remove}
```
=== "Go"
```go title="linked_list.go"
[class]{}-[func]{removeItem}
```
=== "Swift"
```swift title="linked_list.swift"
[class]{}-[func]{remove}
```
=== "JS"
```javascript title="linked_list.js"
[class]{}-[func]{remove}
```
=== "TS"
```typescript title="linked_list.ts"
[class]{}-[func]{remove}
```
=== "Dart"
```dart title="linked_list.dart"
[class]{}-[func]{remove}
```
=== "Rust"
```rust title="linked_list.rs"
[class]{}-[func]{remove}
```
=== "C"
```c title="linked_list.c"
[class]{}-[func]{removeItem}
```
=== "Zig"
```zig title="linked_list.zig"
[class]{}-[func]{remove}
```
```src
[file]{linked_list}-[class]{}-[func]{remove}
```
### 访问节点
**在链表访问节点的效率较低**。如上节所述,我们可以在 $O(1)$ 时间下访问数组中的任意元素。链表则不然,程序需要从头节点出发,逐个向后遍历,直至找到目标节点。也就是说,访问链表的第 $i$ 个节点需要循环 $i - 1$ 轮,时间复杂度为 $O(n)$ 。
=== "Python"
```python title="linked_list.py"
[class]{}-[func]{access}
```
=== "C++"
```cpp title="linked_list.cpp"
[class]{}-[func]{access}
```
=== "Java"
```java title="linked_list.java"
[class]{linked_list}-[func]{access}
```
=== "C#"
```csharp title="linked_list.cs"
[class]{linked_list}-[func]{Access}
```
=== "Go"
```go title="linked_list.go"
[class]{}-[func]{access}
```
=== "Swift"
```swift title="linked_list.swift"
[class]{}-[func]{access}
```
=== "JS"
```javascript title="linked_list.js"
[class]{}-[func]{access}
```
=== "TS"
```typescript title="linked_list.ts"
[class]{}-[func]{access}
```
=== "Dart"
```dart title="linked_list.dart"
[class]{}-[func]{access}
```
=== "Rust"
```rust title="linked_list.rs"
[class]{}-[func]{access}
```
=== "C"
```c title="linked_list.c"
[class]{}-[func]{access}
```
=== "Zig"
```zig title="linked_list.zig"
[class]{}-[func]{access}
```
```src
[file]{linked_list}-[class]{}-[func]{access}
```
### 查找节点
遍历链表,查找链表内值为 `target` 的节点,输出节点在链表中的索引。此过程也属于线性查找。
=== "Python"
```python title="linked_list.py"
[class]{}-[func]{find}
```
=== "C++"
```cpp title="linked_list.cpp"
[class]{}-[func]{find}
```
=== "Java"
```java title="linked_list.java"
[class]{linked_list}-[func]{find}
```
=== "C#"
```csharp title="linked_list.cs"
[class]{linked_list}-[func]{Find}
```
=== "Go"
```go title="linked_list.go"
[class]{}-[func]{findNode}
```
=== "Swift"
```swift title="linked_list.swift"
[class]{}-[func]{find}
```
=== "JS"
```javascript title="linked_list.js"
[class]{}-[func]{find}
```
=== "TS"
```typescript title="linked_list.ts"
[class]{}-[func]{find}
```
=== "Dart"
```dart title="linked_list.dart"
[class]{}-[func]{find}
```
=== "Rust"
```rust title="linked_list.rs"
[class]{}-[func]{find}
```
=== "C"
```c title="linked_list.c"
[class]{}-[func]{find}
```
=== "Zig"
```zig title="linked_list.zig"
[class]{}-[func]{find}
```
```src
[file]{linked_list}-[class]{}-[func]{find}
```
## 数组 VS 链表

View File

@ -1,8 +1,15 @@
# 列表
**数组长度不可变导致实用性降低**。在实际中,我们可能事先无法确定需要存储多少数据,这使数组长度的选择变得困难。若长度过小,需要在持续添加数据时频繁扩容数组;若长度过大,则会造成内存空间的浪费
「列表 list」是一个抽象的数据结构概念它表示元素的有序集合支持元素访问、修改、添加、删除和遍历等操作无需使用者考虑容量限制的问题。列表可以基于链表或数组实现
为解决此问题,出现了一种被称为「动态数组 dynamic array」的数据结构即长度可变的数组也常被称为「列表 list」。列表基于数组实现继承了数组的优点并且可以在程序运行过程中动态扩容。我们可以在列表中自由地添加元素而无须担心超过容量限制
- 链表天然可以被看作是一个列表,其支持元素增删查改操作,并且可以灵活动态扩容
- 数组也支持元素增删查改,但由于其长度不可变,因此只能被看作是一个具有长度限制的列表。
当使用数组实现列表时,**长度不可变的性质会导致列表的实用性降低**。这是因为我们通常无法事先确定需要存储多少数据,从而难以选择合适的列表长度。若长度过小,则很可能无法满足使用需求;若长度过大,则会造成内存空间的浪费。
为解决此问题,我们可以使用「动态数组 dynamic array」来实现列表。它继承了数组的各项优点并且可以在程序运行过程中进行动态扩容。
实际上,**许多编程语言中的标准库提供的列表都是基于动态数组实现的**,例如 Python 中的 `list` 、Java 中的 `ArrayList` 、C++ 中的 `vector` 和 C# 中的 `List` 等。在接下来的讨论中,我们将把“列表”和“动态数组”视为等同的概念。
## 列表常用操作
@ -860,74 +867,6 @@
- **数量记录**:声明一个变量 `size` ,用于记录列表当前元素数量,并随着元素插入和删除实时更新。根据此变量,我们可以定位列表尾部,以及判断是否需要扩容。
- **扩容机制**:若插入元素时列表容量已满,则需要进行扩容。首先根据扩容倍数创建一个更大的数组,再将当前数组的所有元素依次移动至新数组。在本示例中,我们规定每次将数组扩容至之前的 2 倍。
=== "Python"
```python title="my_list.py"
[class]{MyList}-[func]{}
```
=== "C++"
```cpp title="my_list.cpp"
[class]{MyList}-[func]{}
```
=== "Java"
```java title="my_list.java"
[class]{MyList}-[func]{}
```
=== "C#"
```csharp title="my_list.cs"
[class]{MyList}-[func]{}
```
=== "Go"
```go title="my_list.go"
[class]{myList}-[func]{}
```
=== "Swift"
```swift title="my_list.swift"
[class]{MyList}-[func]{}
```
=== "JS"
```javascript title="my_list.js"
[class]{MyList}-[func]{}
```
=== "TS"
```typescript title="my_list.ts"
[class]{MyList}-[func]{}
```
=== "Dart"
```dart title="my_list.dart"
[class]{MyList}-[func]{}
```
=== "Rust"
```rust title="my_list.rs"
[class]{MyList}-[func]{}
```
=== "C"
```c title="my_list.c"
[class]{myList}-[func]{}
```
=== "Zig"
```zig title="my_list.zig"
[class]{MyList}-[func]{}
```
```src
[file]{my_list}-[class]{my_list}-[func]{}
```