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

Sort the coding languages by applications. (#721)

Browse Source
This commit is contained in:
Yudong Jin
2023-09-04 03:19:08 +08:00
committed by GitHub
parent 8d5e84f70a
commit 9c3b7b6422
55 changed files with 6826 additions and 6826 deletions
Download Patch File Download Diff File Expand all files Collapse all files

442
docs/chapter_array_and_linkedlist/array.md
View File

@@ -10,12 +10,12 @@
我们可以根据需求选用数组的两种初始化方式：无初始值、给定初始值。在未指定初始值的情况下，大多数编程语言会将数组元素初始化为 $0$ 。
=== "Java"
=== "Python"
```java title="array.java"
/* 初始化数组 */
int[] arr = new int[5]; // { 0, 0, 0, 0, 0 }
int[] nums = { 1, 3, 2, 5, 4 };
```python title="array.py"
# 初始化数组
arr: list[int] = [0] * 5 # [ 0, 0, 0, 0, 0 ]
nums: list[int] = [1, 3, 2, 5, 4]
```
=== "C++"
@@ -30,12 +30,20 @@
int* nums1 = new int[5] { 1, 3, 2, 5, 4 };
```
=== "Python"
=== "Java"
```python title="array.py"
# 初始化数组
arr: list[int] = [0] * 5 # [ 0, 0, 0, 0, 0 ]
nums: list[int] = [1, 3, 2, 5, 4]
```java title="array.java"
/* 初始化数组 */
int[] arr = new int[5]; // { 0, 0, 0, 0, 0 }
int[] nums = { 1, 3, 2, 5, 4 };
```
=== "C#"
```csharp title="array.cs"
/* 初始化数组 */
int[] arr = new int[5]; // { 0, 0, 0, 0, 0 }
int[] nums = { 1, 3, 2, 5, 4 };
```
=== "Go"
@@ -49,6 +57,14 @@
nums := []int{1, 3, 2, 5, 4}
```
=== "Swift"
```swift title="array.swift"
/* 初始化数组 */
let arr = Array(repeating: 0, count: 5) // [0, 0, 0, 0, 0]
let nums = [1, 3, 2, 5, 4]
```
=== "JS"
```javascript title="array.js"
@@ -65,37 +81,6 @@
let nums: number[] = [1, 3, 2, 5, 4];
```
=== "C"
```c title="array.c"
int arr[5] = { 0 }; // { 0, 0, 0, 0, 0 }
int nums[5] = { 1, 3, 2, 5, 4 };
```
=== "C#"
```csharp title="array.cs"
/* 初始化数组 */
int[] arr = new int[5]; // { 0, 0, 0, 0, 0 }
int[] nums = { 1, 3, 2, 5, 4 };
```
=== "Swift"
```swift title="array.swift"
/* 初始化数组 */
let arr = Array(repeating: 0, count: 5) // [0, 0, 0, 0, 0]
let nums = [1, 3, 2, 5, 4]
```
=== "Zig"
```zig title="array.zig"
// 初始化数组
var arr = [_]i32{0} ** 5; // { 0, 0, 0, 0, 0 }
var nums = [_]i32{ 1, 3, 2, 5, 4 };
```
=== "Dart"
```dart title="array.dart"
@@ -112,6 +97,21 @@
let nums: Vec<i32> = vec![1, 3, 2, 5, 4];
```
=== "C"
```c title="array.c"
int arr[5] = { 0 }; // { 0, 0, 0, 0, 0 }
int nums[5] = { 1, 3, 2, 5, 4 };
```
=== "Zig"
```zig title="array.zig"
// 初始化数组
var arr = [_]i32{0} ** 5; // { 0, 0, 0, 0, 0 }
var nums = [_]i32{ 1, 3, 2, 5, 4 };
```
### 访问元素
数组元素被存储在连续的内存空间中，这意味着计算数组元素的内存地址非常容易。给定数组内存地址（即首元素内存地址）和某个元素的索引，我们可以使用下图所示的公式计算得到该元素的内存地址，从而直接访问此元素。
@@ -122,10 +122,10 @@
在数组中访问元素是非常高效的，我们可以在 $O(1)$ 时间内随机访问数组中的任意一个元素。
=== "Java"
=== "Python"
```java title="array.java"
[class]{array}-[func]{randomAccess}
```python title="array.py"
[class]{}-[func]{random_access}
```
=== "C++"
@@ -134,10 +134,16 @@
[class]{}-[func]{randomAccess}
```
=== "Python"
=== "Java"
```python title="array.py"
[class]{}-[func]{random_access}
```java title="array.java"
[class]{array}-[func]{randomAccess}
```
=== "C#"
```csharp title="array.cs"
[class]{array}-[func]{randomAccess}
```
=== "Go"
@@ -146,6 +152,12 @@
[class]{}-[func]{randomAccess}
```
=== "Swift"
```swift title="array.swift"
[class]{}-[func]{randomAccess}
```
=== "JS"
```javascript title="array.js"
@@ -158,30 +170,6 @@
[class]{}-[func]{randomAccess}
```
=== "C"
```c title="array.c"
[class]{}-[func]{randomAccess}
```
=== "C#"
```csharp title="array.cs"
[class]{array}-[func]{randomAccess}
```
=== "Swift"
```swift title="array.swift"
[class]{}-[func]{randomAccess}
```
=== "Zig"
```zig title="array.zig"
[class]{}-[func]{randomAccess}
```
=== "Dart"
```dart title="array.dart"
@@ -194,6 +182,18 @@
[class]{}-[func]{random_access}
```
=== "C"
```c title="array.c"
[class]{}-[func]{randomAccess}
```
=== "Zig"
```zig title="array.zig"
[class]{}-[func]{randomAccess}
```
### 插入元素
数组元素在内存中是“紧挨着的”，它们之间没有空间再存放任何数据。如下图所示，如果想要在数组中间插入一个元素，则需要将该元素之后的所有元素都向后移动一位，之后再把元素赋值给该索引。
@@ -202,10 +202,10 @@
值得注意的是，由于数组的长度是固定的，因此插入一个元素必定会导致数组尾部元素的“丢失”。我们将这个问题的解决方案留在列表章节中讨论。
=== "Java"
=== "Python"
```java title="array.java"
[class]{array}-[func]{insert}
```python title="array.py"
[class]{}-[func]{insert}
```
=== "C++"
@@ -214,10 +214,16 @@
[class]{}-[func]{insert}
```
=== "Python"
=== "Java"
```python title="array.py"
[class]{}-[func]{insert}
```java title="array.java"
[class]{array}-[func]{insert}
```
=== "C#"
```csharp title="array.cs"
[class]{array}-[func]{insert}
```
=== "Go"
@@ -226,6 +232,12 @@
[class]{}-[func]{insert}
```
=== "Swift"
```swift title="array.swift"
[class]{}-[func]{insert}
```
=== "JS"
```javascript title="array.js"
@@ -238,30 +250,6 @@
[class]{}-[func]{insert}
```
=== "C"
```c title="array.c"
[class]{}-[func]{insert}
```
=== "C#"
```csharp title="array.cs"
[class]{array}-[func]{insert}
```
=== "Swift"
```swift title="array.swift"
[class]{}-[func]{insert}
```
=== "Zig"
```zig title="array.zig"
[class]{}-[func]{insert}
```
=== "Dart"
```dart title="array.dart"
@@ -274,6 +262,18 @@
[class]{}-[func]{insert}
```
=== "C"
```c title="array.c"
[class]{}-[func]{insert}
```
=== "Zig"
```zig title="array.zig"
[class]{}-[func]{insert}
```
### 删除元素
同理，如下图所示，若想要删除索引 $i$ 处的元素，则需要把索引 $i$ 之后的元素都向前移动一位。
@@ -282,10 +282,10 @@
请注意，删除元素完成后，原先末尾的元素变得“无意义”了，所以我们无须特意去修改它。
=== "Java"
=== "Python"
```java title="array.java"
[class]{array}-[func]{remove}
```python title="array.py"
[class]{}-[func]{remove}
```
=== "C++"
@@ -294,10 +294,16 @@
[class]{}-[func]{remove}
```
=== "Python"
=== "Java"
```python title="array.py"
[class]{}-[func]{remove}
```java title="array.java"
[class]{array}-[func]{remove}
```
=== "C#"
```csharp title="array.cs"
[class]{array}-[func]{remove}
```
=== "Go"
@@ -306,6 +312,12 @@
[class]{}-[func]{remove}
```
=== "Swift"
```swift title="array.swift"
[class]{}-[func]{remove}
```
=== "JS"
```javascript title="array.js"
@@ -318,30 +330,6 @@
[class]{}-[func]{remove}
```
=== "C"
```c title="array.c"
[class]{}-[func]{removeItem}
```
=== "C#"
```csharp title="array.cs"
[class]{array}-[func]{remove}
```
=== "Swift"
```swift title="array.swift"
[class]{}-[func]{remove}
```
=== "Zig"
```zig title="array.zig"
[class]{}-[func]{remove}
```
=== "Dart"
```dart title="array.dart"
@@ -354,6 +342,18 @@
[class]{}-[func]{remove}
```
=== "C"
```c title="array.c"
[class]{}-[func]{removeItem}
```
=== "Zig"
```zig title="array.zig"
[class]{}-[func]{remove}
```
总的来看，数组的插入与删除操作有以下缺点。
- **时间复杂度高**：数组的插入和删除的平均时间复杂度均为 $O(n)$ ，其中 $n$ 为数组长度。
@@ -364,10 +364,10 @@
在大多数编程语言中，我们既可以通过索引遍历数组，也可以直接遍历获取数组中的每个元素。
=== "Java"
=== "Python"
```java title="array.java"
[class]{array}-[func]{traverse}
```python title="array.py"
[class]{}-[func]{traverse}
```
=== "C++"
@@ -376,10 +376,16 @@
[class]{}-[func]{traverse}
```
=== "Python"
=== "Java"
```python title="array.py"
[class]{}-[func]{traverse}
```java title="array.java"
[class]{array}-[func]{traverse}
```
=== "C#"
```csharp title="array.cs"
[class]{array}-[func]{traverse}
```
=== "Go"
@@ -388,6 +394,12 @@
[class]{}-[func]{traverse}
```
=== "Swift"
```swift title="array.swift"
[class]{}-[func]{traverse}
```
=== "JS"
```javascript title="array.js"
@@ -400,30 +412,6 @@
[class]{}-[func]{traverse}
```
=== "C"
```c title="array.c"
[class]{}-[func]{traverse}
```
=== "C#"
```csharp title="array.cs"
[class]{array}-[func]{traverse}
```
=== "Swift"
```swift title="array.swift"
[class]{}-[func]{traverse}
```
=== "Zig"
```zig title="array.zig"
[class]{}-[func]{traverse}
```
=== "Dart"
```dart title="array.dart"
@@ -436,16 +424,28 @@
[class]{}-[func]{traverse}
```
=== "C"
```c title="array.c"
[class]{}-[func]{traverse}
```
=== "Zig"
```zig title="array.zig"
[class]{}-[func]{traverse}
```
### 查找元素
在数组中查找指定元素需要遍历数组，每轮判断元素值是否匹配，若匹配则输出对应索引。
因为数组是线性数据结构，所以上述查找操作被称为“线性查找”。
=== "Java"
=== "Python"
```java title="array.java"
[class]{array}-[func]{find}
```python title="array.py"
[class]{}-[func]{find}
```
=== "C++"
@@ -454,10 +454,16 @@
[class]{}-[func]{find}
```
=== "Python"
=== "Java"
```python title="array.py"
[class]{}-[func]{find}
```java title="array.java"
[class]{array}-[func]{find}
```
=== "C#"
```csharp title="array.cs"
[class]{array}-[func]{find}
```
=== "Go"
@@ -466,6 +472,12 @@
[class]{}-[func]{find}
```
=== "Swift"
```swift title="array.swift"
[class]{}-[func]{find}
```
=== "JS"
```javascript title="array.js"
@@ -478,30 +490,6 @@
[class]{}-[func]{find}
```
=== "C"
```c title="array.c"
[class]{}-[func]{find}
```
=== "C#"
```csharp title="array.cs"
[class]{array}-[func]{find}
```
=== "Swift"
```swift title="array.swift"
[class]{}-[func]{find}
```
=== "Zig"
```zig title="array.zig"
[class]{}-[func]{find}
```
=== "Dart"
```dart title="array.dart"
@@ -514,16 +502,28 @@
[class]{}-[func]{find}
```
=== "C"
```c title="array.c"
[class]{}-[func]{find}
```
=== "Zig"
```zig title="array.zig"
[class]{}-[func]{find}
```
### 扩容数组
在复杂的系统环境中，程序难以保证数组之后的内存空间是可用的，从而无法安全地扩展数组容量。因此在大多数编程语言中，**数组的长度是不可变的**。
如果我们希望扩容数组，则需重新建立一个更大的数组，然后把原数组元素依次拷贝到新数组。这是一个 $O(n)$ 的操作，在数组很大的情况下是非常耗时的。
=== "Java"
=== "Python"
```java title="array.java"
[class]{array}-[func]{extend}
```python title="array.py"
[class]{}-[func]{extend}
```
=== "C++"
@@ -532,10 +532,16 @@
[class]{}-[func]{extend}
```
=== "Python"
=== "Java"
```python title="array.py"
[class]{}-[func]{extend}
```java title="array.java"
[class]{array}-[func]{extend}
```
=== "C#"
```csharp title="array.cs"
[class]{array}-[func]{extend}
```
=== "Go"
@@ -544,6 +550,12 @@
[class]{}-[func]{extend}
```
=== "Swift"
```swift title="array.swift"
[class]{}-[func]{extend}
```
=== "JS"
```javascript title="array.js"
@@ -556,30 +568,6 @@
[class]{}-[func]{extend}
```
=== "C"
```c title="array.c"
[class]{}-[func]{extend}
```
=== "C#"
```csharp title="array.cs"
[class]{array}-[func]{extend}
```
=== "Swift"
```swift title="array.swift"
[class]{}-[func]{extend}
```
=== "Zig"
```zig title="array.zig"
[class]{}-[func]{extend}
```
=== "Dart"
```dart title="array.dart"
@@ -592,6 +580,18 @@
[class]{}-[func]{extend}
```
=== "C"
```c title="array.c"
[class]{}-[func]{extend}
```
=== "Zig"
```zig title="array.zig"
[class]{}-[func]{extend}
```
## 数组优点与局限性
数组存储在连续的内存空间内，且元素类型相同。这种做法包含丰富的先验信息，系统可以利用这些信息来优化数据结构的操作效率。