xinyin025/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-07-13 23:56:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'krahets:master' into master

Browse Source
This commit is contained in:
Daniel
2023-01-09 11:05:01 +11:00
committed by GitHub
parent f29f6c460e 97ee638d31
commit 8154ba83a4
93 changed files with 2147 additions and 1124 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/chapter_array_and_linkedlist/array.md
+100 -9
View File
@@ -14,7 +14,7 @@ comments: true
观察上图，我们发现 **数组首元素的索引为 $0$** 。你可能会想，这并不符合日常习惯，首个元素的索引为什么不是 $1$ 呢，这不是更加自然吗？我认同你的想法，但请先记住这个设定，后面讲内存地址计算时，我会尝试解答这个问题。
**数组有多种初始化写法。** 根据实际需要，选代码最短的那一种就好。
**数组有多种初始化写法**。根据实际需要，选代码最短的那一种就好。
=== "Java"
@@ -81,9 +81,17 @@ comments: true
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]
```
## 数组优点
**在数组中访问元素非常高效。** 这是因为在数组中，计算元素的内存地址非常容易。给定数组首个元素的地址、和一个元素的索引，利用以下公式可以直接计算得到该元素的内存地址，从而直接访问此元素。
**在数组中访问元素非常高效**。这是因为在数组中，计算元素的内存地址非常容易。给定数组首个元素的地址、和一个元素的索引，利用以下公式可以直接计算得到该元素的内存地址，从而直接访问此元素。
![array_memory_location_calculation](array.assets/array_memory_location_calculation.png)
@@ -193,9 +201,22 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
}
```
=== "Swift"
```swift title="array.swift"
/* 随机返回一个数组元素 */
func randomAccess(nums: [Int]) -> Int {
// 在区间 [0, nums.count) 中随机抽取一个数字
let randomIndex = nums.indices.randomElement()!
// 获取并返回随机元素
let randomNum = nums[randomIndex]
return randomNum
}
```
## 数组缺点
**数组在初始化后长度不可变。** 由于系统无法保证数组之后的内存空间是可用的，因此数组长度无法扩展。而若希望扩容数组，则需新建一个数组，然后把原数组元素依次拷贝到新数组，在数组很大的情况下，这是非常耗时的。
**数组在初始化后长度不可变**。由于系统无法保证数组之后的内存空间是可用的，因此数组长度无法扩展。而若希望扩容数组，则需新建一个数组，然后把原数组元素依次拷贝到新数组，在数组很大的情况下，这是非常耗时的。
=== "Java"
@@ -317,7 +338,23 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
}
```
**数组中插入或删除元素效率低下。** 假设我们想要在数组中间某位置插入一个元素，由于数组元素在内存中是“紧挨着的”，它们之间没有空间再放任何数据。因此，我们不得不将此索引之后的所有元素都向后移动一位，然后再把元素赋值给该索引。删除元素也是类似，需要把此索引之后的元素都向前移动一位。总体看有以下缺点：
=== "Swift"
```swift title="array.swift"
/* 扩展数组长度 */
func extend(nums: [Int], enlarge: Int) -> [Int] {
// 初始化一个扩展长度后的数组
var res = Array(repeating: 0, count: nums.count + enlarge)
// 将原数组中的所有元素复制到新数组
for i in nums.indices {
res[i] = nums[i]
}
// 返回扩展后的新数组
return res
}
```
**数组中插入或删除元素效率低下**。假设我们想要在数组中间某位置插入一个元素，由于数组元素在内存中是“紧挨着的”，它们之间没有空间再放任何数据。因此，我们不得不将此索引之后的所有元素都向后移动一位，然后再把元素赋值给该索引。删除元素也是类似，需要把此索引之后的元素都向前移动一位。总体看有以下缺点：
- **时间复杂度高：** 数组的插入和删除的平均时间复杂度均为 $O(N)$ ，其中 $N$ 为数组长度。
- **丢失元素：** 由于数组的长度不可变，因此在插入元素后，超出数组长度范围的元素会被丢失。
@@ -486,9 +523,32 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
}
```
=== "Swift"
```swift title="array.swift"
/* 在数组的索引 index 处插入元素 num */
func insert(nums: inout [Int], num: Int, index: Int) {
// 把索引 index 以及之后的所有元素向后移动一位
for i in sequence(first: nums.count - 1, next: { $0 > index + 1 ? $0 - 1 : nil }) {
nums[i] = nums[i - 1]
}
// 将 num 赋给 index 处元素
nums[index] = num
}
/* 删除索引 index 处元素 */
func remove(nums: inout [Int], index: Int) {
let count = nums.count
// 把索引 index 之后的所有元素向前移动一位
for i in sequence(first: index, next: { $0 < count - 1 - 1 ? $0 + 1 : nil }) {
nums[i] = nums[i + 1]
}
}
```
## 数组常用操作
**数组遍历。** 以下介绍两种常用的遍历方法。
**数组遍历**。以下介绍两种常用的遍历方法。
=== "Java"
@@ -611,7 +671,24 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
}
```
**数组查找。** 通过遍历数组，查找数组内的指定元素，并输出对应索引。
=== "Swift"
```swift title="array.swift"
/* 遍历数组 */
func traverse(nums: [Int]) {
var count = 0
// 通过索引遍历数组
for _ in nums.indices {
count += 1
}
// 直接遍历数组
for _ in nums {
count += 1
}
}
```
**数组查找**。通过遍历数组，查找数组内的指定元素，并输出对应索引。
=== "Java"
@@ -713,10 +790,24 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
}
```
=== "Swift"
```swift title="array.swift"
/* 在数组中查找指定元素 */
func find(nums: [Int], target: Int) -> Int {
for i in nums.indices {
if nums[i] == target {
return i
}
}
return -1
}
```
## 数组典型应用
**随机访问。** 如果我们想要随机抽取一些样本，那么可以用数组存储，并生成一个随机序列，根据索引实现样本的随机抽取。
**随机访问**。如果我们想要随机抽取一些样本，那么可以用数组存储，并生成一个随机序列，根据索引实现样本的随机抽取。
**二分查找。** 例如前文查字典的例子，我们可以将字典中的所有字按照拼音顺序存储在数组中，然后使用与日常查纸质字典相同的“翻开中间，排除一半”的方式，来实现一个查电子字典的算法。
**二分查找**。例如前文查字典的例子，我们可以将字典中的所有字按照拼音顺序存储在数组中，然后使用与日常查纸质字典相同的“翻开中间，排除一半”的方式，来实现一个查电子字典的算法。
**深度学习。** 神经网络中大量使用了向量、矩阵、张量之间的线性代数运算，这些数据都是以数组的形式构建的。数组是神经网络编程中最常使用的数据结构。
**深度学习**。神经网络中大量使用了向量、矩阵、张量之间的线性代数运算，这些数据都是以数组的形式构建的。数组是神经网络编程中最常使用的数据结构。
docs/chapter_array_and_linkedlist/linked_list.md
+143 -40
View File
@@ -112,9 +112,23 @@ comments: true
}
```
=== "Swift"
```swift title=""
/* 链表结点类 */
class ListNode {
var val: Int // 结点值
var next: ListNode? // 指向下一结点的指针（引用）
init(x: Int) { // 构造函数
val = x
}
}
```
**尾结点指向什么？** 我们一般将链表的最后一个结点称为「尾结点」，其指向的是「空」，在 Java / C++ / Python 中分别记为 `null` / `nullptr` / `None` 。在不引起歧义下，本书都使用 `null` 来表示空。
**链表初始化方法。** 建立链表分为两步，第一步是初始化各个结点对象，第二步是构建引用指向关系。完成后，即可以从链表的首个结点（即头结点）出发，访问其余所有的结点。
**链表初始化方法**。建立链表分为两步，第一步是初始化各个结点对象，第二步是构建引用指向关系。完成后，即可以从链表的首个结点（即头结点）出发，访问其余所有的结点。
!!! tip
@@ -122,7 +136,7 @@ comments: true
=== "Java"
```java title=""
```java title="linked_list.java"
/* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
// 初始化各个结点
ListNode n0 = new ListNode(1);
@@ -139,7 +153,7 @@ comments: true
=== "C++"
```cpp title=""
```cpp title="linked_list.cpp"
/* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
// 初始化各个结点
ListNode* n0 = new ListNode(1);
@@ -156,7 +170,7 @@ comments: true
=== "Python"
```python title=""
```python title="linked_list.py"
""" 初始化链表 1 -> 3 -> 2 -> 5 -> 4 """
# 初始化各个结点
n0 = ListNode(1)
@@ -173,7 +187,7 @@ comments: true
=== "Go"
```go title=""
```go title="linked_list.go"
/* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
// 初始化各个结点
n0 := NewListNode(1)
@@ -191,7 +205,7 @@ comments: true
=== "JavaScript"
```js title=""
```js title="linked_list.js"
/* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
// 初始化各个结点
const n0 = new ListNode(1);
@@ -208,7 +222,7 @@ comments: true
=== "TypeScript"
```typescript title=""
```typescript title="linked_list.ts"
/* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
// 初始化各个结点
const n0 = new ListNode(1);
@@ -225,13 +239,13 @@ comments: true
=== "C"
```c title=""
```c title="linked_list.c"
```
=== "C#"
```csharp title=""
```csharp title="linked_list.cs"
/* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
// 初始化各个结点
ListNode n0 = new ListNode(1);
@@ -246,9 +260,26 @@ comments: true
n3.next = n4;
```
=== "Swift"
```swift title="linked_list.swift"
/* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
// 初始化各个结点
let n0 = ListNode(x: 1)
let n1 = ListNode(x: 3)
let n2 = ListNode(x: 2)
let n3 = ListNode(x: 5)
let n4 = ListNode(x: 4)
// 构建引用指向
n0.next = n1
n1.next = n2
n2.next = n3
n3.next = n4
```
## 链表优点
**在链表中，插入与删除结点的操作效率高。** 例如，如果想在链表中间的两个结点 `A` , `B` 之间插入一个新结点 `P` ，我们只需要改变两个结点指针即可，时间复杂度为 $O(1)$ ，相比数组的插入操作高效很多。在链表中删除某个结点也很方便，只需要改变一个结点指针即可。
**在链表中，插入与删除结点的操作效率高**。例如，如果想在链表中间的两个结点 `A` , `B` 之间插入一个新结点 `P` ，我们只需要改变两个结点指针即可，时间复杂度为 $O(1)$ ，相比数组的插入操作高效很多。在链表中删除某个结点也很方便，只需要改变一个结点指针即可。
![linkedlist_insert_remove_node](linked_list.assets/linkedlist_insert_remove_node.png)
@@ -256,7 +287,7 @@ comments: true
=== "Java"
```java title=""
```java title="linked_list.java"
/* 在链表的结点 n0 之后插入结点 P */
void insert(ListNode n0, ListNode P) {
ListNode n1 = n0.next;
@@ -277,7 +308,7 @@ comments: true
=== "C++"
```cpp title=""
```cpp title="linked_list.cpp"
/* 在链表的结点 n0 之后插入结点 P */
void insert(ListNode* n0, ListNode* P) {
ListNode* n1 = n0->next;
@@ -300,7 +331,7 @@ comments: true
=== "Python"
```python title=""
```python title="linked_list.py"
""" 在链表的结点 n0 之后插入结点 P """
def insert(n0, P):
n1 = n0.next
@@ -319,7 +350,7 @@ comments: true
=== "Go"
```go title=""
```go title="linked_list.go"
/* 在链表的结点 n0 之后插入结点 P */
func insert(n0 *ListNode, P *ListNode) {
n1 := n0.Next
@@ -341,7 +372,7 @@ comments: true
=== "JavaScript"
```js title=""
```js title="linked_list.js"
/* 在链表的结点 n0 之后插入结点 P */
function insert(n0, P) {
let n1 = n0.next;
@@ -362,7 +393,7 @@ comments: true
=== "TypeScript"
```typescript title=""
```typescript title="linked_list.ts"
/* 在链表的结点 n0 之后插入结点 P */
function insert(n0: ListNode, P: ListNode): void {
const n1 = n0.next;
@@ -383,13 +414,13 @@ comments: true
=== "C"
```c title=""
```c title="linked_list.c"
```
=== "C#"
```csharp title=""
```csharp title="linked_list.cs"
// 在链表的结点 n0 之后插入结点 P
void Insert(ListNode n0, ListNode P)
{
@@ -410,13 +441,36 @@ comments: true
}
```
=== "Swift"
```swift title="linked_list.swift"
/* 在链表的结点 n0 之后插入结点 P */
func insert(n0: ListNode, P: ListNode) {
let n1 = n0.next
n0.next = P
P.next = n1
}
/* 删除链表的结点 n0 之后的首个结点 */
func remove(n0: ListNode) {
if n0.next == nil {
return
}
// n0 -> P -> n1
let P = n0.next
let n1 = P?.next
n0.next = n1
P?.next = nil
}
```
## 链表缺点
**链表访问结点效率低。** 上节提到，数组可以在 $O(1)$ 时间下访问任意元素，但链表无法直接访问任意结点。这是因为计算机需要从头结点出发，一个一个地向后遍历到目标结点。例如，倘若想要访问链表索引为 `index` （即第 `index + 1` 个）的结点，那么需要 `index` 次访问操作。
**链表访问结点效率低**。上节提到，数组可以在 $O(1)$ 时间下访问任意元素，但链表无法直接访问任意结点。这是因为计算机需要从头结点出发，一个一个地向后遍历到目标结点。例如，倘若想要访问链表索引为 `index` （即第 `index + 1` 个）的结点，那么需要 `index` 次访问操作。
=== "Java"
```java title=""
```java title="linked_list.java"
/* 访问链表中索引为 index 的结点 */
ListNode access(ListNode head, int index) {
for (int i = 0; i < index; i++) {
@@ -430,7 +484,7 @@ comments: true
=== "C++"
```cpp title=""
```cpp title="linked_list.cpp"
/* 访问链表中索引为 index 的结点 */
ListNode* access(ListNode* head, int index) {
for (int i = 0; i < index; i++) {
@@ -444,7 +498,7 @@ comments: true
=== "Python"
```python title=""
```python title="linked_list.py"
""" 访问链表中索引为 index 的结点 """
def access(head, index):
for _ in range(index):
@@ -456,7 +510,7 @@ comments: true
=== "Go"
```go title=""
```go title="linked_list.go"
/* 访问链表中索引为 index 的结点 */
func access(head *ListNode, index int) *ListNode {
for i := 0; i < index; i++ {
@@ -471,7 +525,7 @@ comments: true
=== "JavaScript"
```js title=""
```js title="linked_list.js"
/* 访问链表中索引为 index 的结点 */
function access(head, index) {
for (let i = 0; i < index; i++) {
@@ -485,7 +539,7 @@ comments: true
=== "TypeScript"
```typescript title=""
```typescript title="linked_list.ts"
/* 访问链表中索引为 index 的结点 */
function access(head: ListNode | null, index: number): ListNode | null {
for (let i = 0; i < index; i++) {
@@ -500,13 +554,13 @@ comments: true
=== "C"
```c title=""
```c title="linked_list.c"
```
=== "C#"
```csharp title=""
```csharp title="linked_list.cs"
// 访问链表中索引为 index 的结点
ListNode Access(ListNode head, int index)
{
@@ -520,15 +574,31 @@ comments: true
}
```
**链表的内存占用多。** 链表以结点为单位，每个结点除了保存值外，还需额外保存指针（引用）。这意味着同样数据量下，链表比数组需要占用更多内存空间。
=== "Swift"
```swift title="linked_list.swift"
/* 访问链表中索引为 index 的结点 */
func access(head: ListNode, index: Int) -> ListNode? {
var head: ListNode? = head
for _ in 0 ..< index {
head = head?.next
if head == nil {
return nil
}
}
return head
}
```
**链表的内存占用多**。链表以结点为单位，每个结点除了保存值外，还需额外保存指针（引用）。这意味着同样数据量下，链表比数组需要占用更多内存空间。
## 链表常用操作
**遍历链表查找。** 遍历链表，查找链表内值为 `target` 的结点，输出结点在链表中的索引。
**遍历链表查找**。遍历链表，查找链表内值为 `target` 的结点，输出结点在链表中的索引。
=== "Java"
```java title=""
```java title="linked_list.java"
/* 在链表中查找值为 target 的首个结点 */
int find(ListNode head, int target) {
int index = 0;
@@ -544,7 +614,7 @@ comments: true
=== "C++"
```cpp title=""
```cpp title="linked_list.cpp"
/* 在链表中查找值为 target 的首个结点 */
int find(ListNode* head, int target) {
int index = 0;
@@ -560,7 +630,7 @@ comments: true
=== "Python"
```python title=""
```python title="linked_list.py"
""" 在链表中查找值为 target 的首个结点 """
def find(head, target):
index = 0
@@ -574,7 +644,7 @@ comments: true
=== "Go"
```go title=""
```go title="linked_list.go"
/* 在链表中查找值为 target 的首个结点 */
func find(head *ListNode, target int) int {
index := 0
@@ -591,7 +661,7 @@ comments: true
=== "JavaScript"
```js title=""
```js title="linked_list.js"
/* 在链表中查找值为 target 的首个结点 */
function find(head, target) {
let index = 0;
@@ -608,7 +678,7 @@ comments: true
=== "TypeScript"
```typescript title=""
```typescript title="linked_list.ts"
/* 在链表中查找值为 target 的首个结点 */
function find(head: ListNode | null, target: number): number {
let index = 0;
@@ -625,13 +695,13 @@ comments: true
=== "C"
```c title=""
```c title="linked_list.c"
```
=== "C#"
```csharp title=""
```csharp title="linked_list.cs"
// 在链表中查找值为 target 的首个结点
int Find(ListNode head, int target)
{
@@ -647,13 +717,31 @@ comments: true
}
```
=== "Swift"
```swift title="linked_list.swift"
/* 在链表中查找值为 target 的首个结点 */
func find(head: ListNode, target: Int) -> Int {
var head: ListNode? = head
var index = 0
while head != nil {
if head?.val == target {
return index
}
head = head?.next
index += 1
}
return -1
}
```
## 常见链表类型
**单向链表。** 即上述介绍的普通链表。单向链表的结点有「值」和指向下一结点的「指针（引用）」两项数据。我们将首个结点称为头结点，尾结点指向 `null` 。
**单向链表**。即上述介绍的普通链表。单向链表的结点有「值」和指向下一结点的「指针（引用）」两项数据。我们将首个结点称为头结点，尾结点指向 `null` 。
**环形链表。** 如果我们令单向链表的尾结点指向头结点（即首尾相接），则得到一个环形链表。在环形链表中，我们可以将任意结点看作是头结点。
**环形链表**。如果我们令单向链表的尾结点指向头结点（即首尾相接），则得到一个环形链表。在环形链表中，我们可以将任意结点看作是头结点。
**双向链表。** 单向链表仅记录了一个方向的指针（引用），在双向链表的结点定义中，同时有指向下一结点（后继结点）和上一结点（前驱结点）的「指针（引用）」。双向链表相对于单向链表更加灵活，即可以朝两个方向遍历链表，但也需要占用更多的内存空间。
**双向链表**。单向链表仅记录了一个方向的指针（引用），在双向链表的结点定义中，同时有指向下一结点（后继结点）和上一结点（前驱结点）的「指针（引用）」。双向链表相对于单向链表更加灵活，即可以朝两个方向遍历链表，但也需要占用更多的内存空间。
=== "Java"
@@ -760,6 +848,21 @@ comments: true
}
```
=== "Swift"
```swift title=""
/* 双向链表结点类 */
class ListNode {
var val: Int // 结点值
var next: ListNode? // 指向后继结点的指针（引用）
var prev: ListNode? // 指向前驱结点的指针（引用）
init(x: Int) { // 构造函数
val = x
}
}
```
![linkedlist_common_types](linked_list.assets/linkedlist_common_types.png)
<p align="center"> Fig. 常见链表类型 </p>
docs/chapter_array_and_linkedlist/list.md
+64 -18
View File
@@ -4,13 +4,13 @@ comments: true
# 列表
**由于长度不可变，数组的实用性大大降低。** 在很多情况下，我们事先并不知道会输入多少数据，这就为数组长度的选择带来了很大困难。长度选小了，需要在添加数据中频繁地扩容数组；长度选大了，又造成内存空间的浪费。
**由于长度不可变，数组的实用性大大降低**。在很多情况下，我们事先并不知道会输入多少数据，这就为数组长度的选择带来了很大困难。长度选小了，需要在添加数据中频繁地扩容数组；长度选大了，又造成内存空间的浪费。
为了解决此问题，诞生了一种被称为「列表 List」的数据结构。列表可以被理解为长度可变的数组，因此也常被称为「动态数组 Dynamic Array」。列表基于数组实现，继承了数组的优点，同时还可以在程序运行中实时扩容。在列表中，我们可以自由地添加元素，而不用担心超过容量限制。
## 列表常用操作
**初始化列表。** 我们通常会使用到“无初始值”和“有初始值”的两种初始化方法。
**初始化列表**。我们通常会使用到“无初始值”和“有初始值”的两种初始化方法。
=== "Java"
@@ -91,7 +91,13 @@ comments: true
List<int> list = numbers.ToList();
```
**访问与更新元素。** 列表的底层数据结构是数组，因此可以在 $O(1)$ 时间内访问与更新元素，效率很高。
=== "Swift"
```swift title="list.swift"
```
**访问与更新元素**。列表的底层数据结构是数组，因此可以在 $O(1)$ 时间内访问与更新元素，效率很高。
=== "Java"
@@ -169,7 +175,13 @@ comments: true
list[1] = 0; // 将索引 1 处的元素更新为 0
```
**在列表中添加、插入、删除元素。** 相对于数组，列表可以自由地添加与删除元素。在列表尾部添加元素的时间复杂度为 $O(1)$ ，但是插入与删除元素的效率仍与数组一样低，时间复杂度为 $O(N)$ 。
=== "Swift"
```swift title="list.swift"
```
**在列表中添加、插入、删除元素**。相对于数组，列表可以自由地添加与删除元素。在列表尾部添加元素的时间复杂度为 $O(1)$ ，但是插入与删除元素的效率仍与数组一样低，时间复杂度为 $O(N)$ 。
=== "Java"
@@ -317,7 +329,13 @@ comments: true
list.RemoveAt(3);
```
**遍历列表。** 与数组一样，列表可以使用索引遍历，也可以使用 `for-each` 直接遍历。
=== "Swift"
```swift title="list.swift"
```
**遍历列表**。与数组一样，列表可以使用索引遍历，也可以使用 `for-each` 直接遍历。
=== "Java"
@@ -437,7 +455,13 @@ comments: true
}
```
**拼接两个列表。** 再创建一个新列表 `list1` ，我们可以将其中一个列表拼接到另一个的尾部。
=== "Swift"
```swift title="list.swift"
```
**拼接两个列表**。再创建一个新列表 `list1` ，我们可以将其中一个列表拼接到另一个的尾部。
=== "Java"
@@ -502,7 +526,13 @@ comments: true
list.AddRange(list1); // 将列表 list1 拼接到 list 之后
```
**排序列表。** 排序也是常用的方法之一，完成列表排序后，我们就可以使用在数组类算法题中经常考察的「二分查找」和「双指针」算法了。
=== "Swift"
```swift title="list.swift"
```
**排序列表**。排序也是常用的方法之一，完成列表排序后，我们就可以使用在数组类算法题中经常考察的「二分查找」和「双指针」算法了。
=== "Java"
@@ -559,6 +589,12 @@ comments: true
list.Sort(); // 排序后，列表元素从小到大排列
```
=== "Swift"
```swift title="list.swift"
```
## 列表简易实现 *
为了帮助加深对列表的理解，我们在此提供一个列表的简易版本的实现。需要关注三个核心点：
@@ -828,7 +864,7 @@ comments: true
```go title="my_list.go"
/* 列表类简易实现 */
type MyList struct {
type myList struct {
numsCapacity int
nums []int
numsSize int
@@ -836,8 +872,8 @@ comments: true
}
/* 构造函数 */
func newMyList() *MyList {
return &MyList{
func newMyList() *myList {
return &myList{
numsCapacity: 10, // 列表容量
nums: make([]int, 10), // 数组（存储列表元素）
numsSize: 0, // 列表长度（即当前元素数量）
@@ -846,17 +882,17 @@ comments: true
}
/* 获取列表长度（即当前元素数量） */
func (l *MyList) size() int {
func (l *myList) size() int {
return l.numsSize
}
/* 获取列表容量 */
func (l *MyList) capacity() int {
func (l *myList) capacity() int {
return l.numsCapacity
}
/* 访问元素 */
func (l *MyList) get(index int) int {
func (l *myList) get(index int) int {
// 索引如果越界则抛出异常，下同
if index >= l.numsSize {
panic("索引越界")
@@ -865,7 +901,7 @@ comments: true
}
/* 更新元素 */
func (l *MyList) set(num, index int) {
func (l *myList) set(num, index int) {
if index >= l.numsSize {
panic("索引越界")
}
@@ -873,7 +909,7 @@ comments: true
}
/* 尾部添加元素 */
func (l *MyList) add(num int) {
func (l *myList) add(num int) {
// 元素数量超出容量时，触发扩容机制
if l.numsSize == l.numsCapacity {
l.extendCapacity()
@@ -884,7 +920,7 @@ comments: true
}
/* 中间插入元素 */
func (l *MyList) insert(num, index int) {
func (l *myList) insert(num, index int) {
if index >= l.numsSize {
panic("索引越界")
}
@@ -902,20 +938,23 @@ comments: true
}
/* 删除元素 */
func (l *MyList) Remove(index int) {
func (l *myList) remove(index int) int {
if index >= l.numsSize {
panic("索引越界")
}
num := l.nums[index]
// 索引 i 之后的元素都向前移动一位
for j := index; j < l.numsSize-1; j++ {
l.nums[j] = l.nums[j+1]
}
// 更新元素数量
l.numsSize--
// 返回被删除元素
return num
}
/* 列表扩容 */
func (l *MyList) extendCapacity() {
func (l *myList) extendCapacity() {
// 新建一个长度为 self.__size 的数组，并将原数组拷贝到新数组
l.nums = append(l.nums, make([]int, l.numsCapacity*(l.extendRatio-1))...)
// 更新列表容量
@@ -1220,3 +1259,10 @@ comments: true
}
}
```
=== "Swift"
```swift title="my_list.swift"
```
docs/chapter_computational_complexity/performance_evaluation.md
+6 -6
View File
@@ -8,15 +8,15 @@ comments: true
在开始学习算法之前，我们首先要想清楚算法的设计目标是什么，或者说，如何来评判算法的好与坏。整体上看，我们设计算法时追求两个层面的目标。
1. **找到问题解法。** 算法需要能够在规定的输入范围下，可靠地求得问题的正确解。
2. **寻求最优解法。** 同一个问题可能存在多种解法，而我们希望算法效率尽可能的高。
1. **找到问题解法**。算法需要能够在规定的输入范围下，可靠地求得问题的正确解。
2. **寻求最优解法**。同一个问题可能存在多种解法，而我们希望算法效率尽可能的高。
换言之，在可以解决问题的前提下，算法效率则是主要评价维度，包括：
- **时间效率** ，即算法的运行速度的快慢。
- **空间效率** ，即算法占用的内存空间大小。
数据结构与算法追求“运行得快、内存占用少”，而如何去评价算法效率则是非常重要的问题，因为只有知道如何评价算法，才能去做算法之间的对比分析，以及优化算法设计。
数据结构与算法追求“运行速度快、占用内存少”，而如何去评价算法效率则是非常重要的问题，因为只有知道如何评价算法，才能去做算法之间的对比分析，以及优化算法设计。
## 效率评估方法
@@ -24,9 +24,9 @@ comments: true
假设我们现在有算法 A 和 算法 B ，都能够解决同一问题，现在需要对比两个算法之间的效率。我们能够想到的最直接的方式，就是找一台计算机，把两个算法都完整跑一遍，并监控记录运行时间和内存占用情况。这种评估方式能够反映真实情况，但是也存在很大的硬伤。
**难以排除测试环境的干扰因素。** 硬件配置会影响到算法的性能表现。例如，在某台计算机中，算法 A 比算法 B 运行时间更短；但换到另一台配置不同的计算机中，可能会得到相反的测试结果。这意味着我们需要在各种机器上展开测试，而这是不现实的。
**难以排除测试环境的干扰因素**。硬件配置会影响到算法的性能表现。例如，在某台计算机中，算法 A 比算法 B 运行时间更短；但换到另一台配置不同的计算机中，可能会得到相反的测试结果。这意味着我们需要在各种机器上展开测试，而这是不现实的。
**展开完整测试非常耗费资源。** 随着输入数据量的大小变化，算法会呈现出不同的效率表现。比如，有可能输入数据量较小时，算法 A 运行时间短于算法 B ，而在输入数据量较大时，测试结果截然相反。因此，若想要达到具有说服力的对比结果，那么需要输入各种体量数据，这样的测试需要占用大量计算资源。
**展开完整测试非常耗费资源**。随着输入数据量的大小变化，算法会呈现出不同的效率表现。比如，有可能输入数据量较小时，算法 A 运行时间短于算法 B ，而在输入数据量较大时，测试结果截然相反。因此，若想要达到具有说服力的对比结果，那么需要输入各种体量数据，这样的测试需要占用大量计算资源。
### 理论估算
@@ -34,7 +34,7 @@ comments: true
**复杂度分析评估随着输入数据量的增长，算法的运行时间和占用空间的增长趋势** 。根据时间和空间两方面，复杂度可分为「时间复杂度 Time Complexity」和「空间复杂度 Space Complexity」。
**复杂度分析克服了实际测试方法的弊端。** 一是独立于测试环境，分析结果适用于所有运行平台。二是可以体现不同数据量下的算法效率，尤其是可以反映大数据量下的算法性能。
**复杂度分析克服了实际测试方法的弊端**。一是独立于测试环境，分析结果适用于所有运行平台。二是可以体现不同数据量下的算法效率，尤其是可以反映大数据量下的算法性能。
## 复杂度分析的重要性
docs/chapter_computational_complexity/space_complexity.md
+21 -21
View File
@@ -103,14 +103,14 @@ comments: true
```go title=""
/* 结构体 */
type Node struct {
type node struct {
val int
next *Node
next *node
}
/* 创建 Node 结构体 */
func newNode(val int) *Node {
return &Node{val: val}
/* 创建 node 结构体 */
func newNode(val int) *node {
return &node{val: val}
}
/* 函数 */
@@ -177,7 +177,7 @@ comments: true
=== "Swift"
```swift title=""
// 类
/* 类 */
class Node {
var val: Int
var next: Node?
@@ -187,7 +187,7 @@ comments: true
}
}
// 函数
/* 函数 */
func function() -> Int {
// do something...
return 0
@@ -208,8 +208,8 @@ comments: true
**最差空间复杂度中的“最差”有两层含义**，分别为输入数据的最差分布、算法运行中的最差时间点。
- **以最差输入数据为准。** 当 $n < 10$ 时，空间复杂度为 $O(1)$ ；但是当 $n > 10$ 时，初始化的数组 `nums` 使用 $O(n)$ 空间；因此最差空间复杂度为 $O(n)$ ；
- **以算法运行过程中的峰值内存为准。** 程序在执行最后一行之前，使用 $O(1)$ 空间；当初始化数组 `nums` 时，程序使用 $O(n)$ 空间；因此最差空间复杂度为 $O(n)$ ；
- **以最差输入数据为准**。当 $n < 10$ 时，空间复杂度为 $O(1)$ ；但是当 $n > 10$ 时，初始化的数组 `nums` 使用 $O(n)$ 空间；因此最差空间复杂度为 $O(n)$ ；
- **以算法运行过程中的峰值内存为准**。程序在执行最后一行之前，使用 $O(1)$ 空间；当初始化数组 `nums` 时，程序使用 $O(n)$ 空间；因此最差空间复杂度为 $O(n)$ ；
=== "Java"
@@ -301,7 +301,7 @@ comments: true
}
```
**在递归函数中，需要注意统计栈帧空间。** 例如函数 `loop()`，在循环中调用了 $n$ 次 `function()` ，每轮中的 `function()` 都返回并释放了栈帧空间，因此空间复杂度仍为 $O(1)$ 。而递归函数 `recur()` 在运行中会同时存在 $n$ 个未返回的 `recur()` ，从而使用 $O(n)$ 的栈帧空间。
**在递归函数中，需要注意统计栈帧空间**。例如函数 `loop()`，在循环中调用了 $n$ 次 `function()` ，每轮中的 `function()` 都返回并释放了栈帧空间，因此空间复杂度仍为 $O(1)$ 。而递归函数 `recur()` 在运行中会同时存在 $n$ 个未返回的 `recur()` ，从而使用 $O(n)$ 的栈帧空间。
=== "Java"
@@ -436,14 +436,14 @@ comments: true
return 0
}
// 循环 O(1)
/* 循环 O(1) */
func loop(n: Int) {
for _ in 0 ..< n {
function()
}
}
// 递归 O(n)
/* 递归 O(n) */
func recur(n: Int) {
if n == 1 {
return
@@ -604,7 +604,7 @@ $$
=== "Swift"
```swift title="space_complexity.swift"
// 常数阶
/* 常数阶 */
func constant(n: Int) {
// 常量、变量、对象占用 O(1) 空间
let a = 0
@@ -687,7 +687,7 @@ $$
// 长度为 n 的数组占用 O(n) 空间
_ = make([]int, n)
// 长度为 n 的列表占用 O(n) 空间
var nodes []*Node
var nodes []*node
for i := 0; i < n; i++ {
nodes = append(nodes, newNode(i))
}
@@ -743,7 +743,7 @@ $$
=== "Swift"
```swift title="space_complexity.swift"
// 线性阶
/* 线性阶 */
func linear(n: Int) {
// 长度为 n 的数组占用 O(n) 空间
let nums = Array(repeating: 0, count: n)
@@ -834,7 +834,7 @@ $$
=== "Swift"
```swift title="space_complexity.swift"
// 线性阶（递归实现）
/* 线性阶（递归实现） */
func linearRecur(n: Int) {
print("递归 n = \(n)")
if n == 1 {
@@ -954,7 +954,7 @@ $$
=== "Swift"
```swift title="space_complexity.swift"
// 平方阶
/* 平方阶 */
func quadratic(n: Int) {
// 二维列表占用 O(n^2) 空间
let numList = Array(repeating: Array(repeating: 0, count: n), count: n)
@@ -1047,7 +1047,7 @@ $$
=== "Swift"
```swift title="space_complexity.swift"
// 平方阶（递归实现）
/* 平方阶（递归实现） */
func quadraticRecur(n: Int) -> Int {
if n <= 0 {
return 0
@@ -1108,7 +1108,7 @@ $$
```go title="space_complexity.go"
/* 指数阶（建立满二叉树） */
func buildTree(n int) *TreeNode {
func buildTree(n int) *treeNode {
if n == 0 {
return nil
}
@@ -1154,7 +1154,7 @@ $$
=== "Swift"
```swift title="space_complexity.swift"
// 指数阶（建立满二叉树）
/* 指数阶（建立满二叉树） */
func buildTree(n: Int) -> TreeNode? {
if n == 0 {
return nil
docs/chapter_computational_complexity/space_time_tradeoff.md
+1 -1
View File
@@ -6,7 +6,7 @@ comments: true
理想情况下，我们希望算法的时间复杂度和空间复杂度都能够达到最优，而实际上，同时优化时间复杂度和空间复杂度是非常困难的。
**降低时间复杂度，往往是以提升空间复杂度为代价的，反之亦然。** 我们把牺牲内存空间来提升算法运行速度的思路称为「以空间换时间」；反之，称之为「以时间换空间」。选择哪种思路取决于我们更看重哪个方面。
**降低时间复杂度，往往是以提升空间复杂度为代价的，反之亦然**。我们把牺牲内存空间来提升算法运行速度的思路称为「以空间换时间」；反之，称之为「以时间换空间」。选择哪种思路取决于我们更看重哪个方面。
大多数情况下，时间都是比空间更宝贵的，只要空间复杂度不要太离谱、能接受就行，**因此以空间换时间最为常用**。
docs/chapter_computational_complexity/time_complexity.md
+31 -31
View File
@@ -153,7 +153,7 @@ $$
}
```
但实际上， **统计算法的运行时间既不合理也不现实。** 首先，我们不希望预估时间和运行平台绑定，毕竟算法需要跑在各式各样的平台之上。其次，我们很难获知每一种操作的运行时间，这为预估过程带来了极大的难度。
但实际上， **统计算法的运行时间既不合理也不现实**。首先，我们不希望预估时间和运行平台绑定，毕竟算法需要跑在各式各样的平台之上。其次，我们很难获知每一种操作的运行时间，这为预估过程带来了极大的难度。
## 统计时间增长趋势
@@ -363,11 +363,11 @@ $$
相比直接统计算法运行时间，时间复杂度分析的做法有什么好处呢？以及有什么不足？
**时间复杂度可以有效评估算法效率。** 算法 `B` 运行时间的增长是线性的，在 $n > 1$ 时慢于算法 `A` ，在 $n > 1000000$ 时慢于算法 `C` 。实质上，只要输入数据大小 $n$ 足够大，复杂度为「常数阶」的算法一定优于「线性阶」的算法，这也正是时间增长趋势的含义。
**时间复杂度可以有效评估算法效率**。算法 `B` 运行时间的增长是线性的，在 $n > 1$ 时慢于算法 `A` ，在 $n > 1000000$ 时慢于算法 `C` 。实质上，只要输入数据大小 $n$ 足够大，复杂度为「常数阶」的算法一定优于「线性阶」的算法，这也正是时间增长趋势的含义。
**时间复杂度分析将统计「计算操作的运行时间」简化为统计「计算操作的数量」。** 这是因为，无论是运行平台、还是计算操作类型，都与算法运行时间的增长趋势无关。因此，我们可以简单地将所有计算操作的执行时间统一看作是相同的“单位时间”。
**时间复杂度的推算方法更加简便**。在时间复杂度分析中，我们可以将统计「计算操作的运行时间」简化为统计「计算操作的数量」，这是因为，无论是运行平台还是计算操作类型，都与算法运行时间的增长趋势无关。因而，我们可以简单地将所有计算操作的执行时间统一看作是相同的“单位时间”，这样的简化做法大大降低了估算难度。
**时间复杂度也存在一定的局限性。** 比如，虽然算法 `A` 和 `C` 的时间复杂度相同，但是实际的运行时间有非常大的差别。再比如，虽然算法 `B` 比 `C` 的时间复杂度要更高，但在输入数据大小 $n$ 比较小时，算法 `B` 是要明显优于算法 `C` 的。即使存在这些问题，计算复杂度仍然是评判算法效率的最有效、最常用方法。
**时间复杂度也存在一定的局限性**。比如，虽然算法 `A` 和 `C` 的时间复杂度相同，但是实际的运行时间有非常大的差别。再比如，虽然算法 `B` 比 `C` 的时间复杂度要更高，但在输入数据大小 $n$ 比较小时，算法 `B` 是要明显优于算法 `C` 的。对于以上情况，我们很难仅凭时间复杂度来判定算法效率高低。然而，即使存在这些问题，计算复杂度仍然是评判算法效率的最有效且常用的方法。
## 函数渐近上界
@@ -421,12 +421,12 @@ $$
```go title=""
func algorithm(n int) {
a := 1 // +1
a = a + 1 // +1
a = a * 2 // +1
a := 1 // +1
a = a + 1 // +1
a = a * 2 // +1
// 循环 n 次
for i := 0; i < n; i++ { // +1
fmt.Println(a) // +1
for i := 0; i < n; i++ { // +1
fmt.Println(a) // +1
}
}
```
@@ -538,9 +538,9 @@ $T(n)$ 是个一次函数，说明时间增长趋势是线性的，因此易得
对着代码，从上到下一行一行地计数即可。然而，**由于上述 $c \cdot f(n)$ 中的常数项 $c$ 可以取任意大小，因此操作数量 $T(n)$ 中的各种系数、常数项都可以被忽略**。根据此原则，可以总结出以下计数偷懒技巧：
1. **跳过数量与 $n$ 无关的操作。** 因为他们都是 $T(n)$ 中的常数项，对时间复杂度不产生影响。
2. **省略所有系数。** 例如，循环 $2n$ 次、$5n + 1$ 次、……，都可以化简记为 $n$ 次，因为 $n$ 前面的系数对时间复杂度也不产生影响。
3. **循环嵌套时使用乘法。** 总操作数量等于外层循环和内层循环操作数量之积，每一层循环依然可以分别套用上述 `1.` 和 `2.` 技巧。
1. **跳过数量与 $n$ 无关的操作**。因为他们都是 $T(n)$ 中的常数项，对时间复杂度不产生影响。
2. **省略所有系数**。例如，循环 $2n$ 次、$5n + 1$ 次、……，都可以化简记为 $n$ 次，因为 $n$ 前面的系数对时间复杂度也不产生影响。
3. **循环嵌套时使用乘法**。总操作数量等于外层循环和内层循环操作数量之积，每一层循环依然可以分别套用上述 `1.` 和 `2.` 技巧。
根据以下示例，使用上述技巧前、后的统计结果分别为
@@ -876,7 +876,7 @@ $$
=== "Swift"
```swift title="time_complexity.swift"
// 常数阶
/* 常数阶 */
func constant(n: Int) -> Int {
var count = 0
let size = 100000
@@ -990,7 +990,7 @@ $$
=== "Swift"
```swift title="time_complexity.swift"
// 线性阶
/* 线性阶 */
func linear(n: Int) -> Int {
var count = 0
for _ in 0 ..< n {
@@ -1004,7 +1004,7 @@ $$
!!! tip
**数据大小 $n$ 是根据输入数据的类型来确定的。** 比如，在上述示例中，我们直接将 $n$ 看作输入数据大小；以下遍历数组示例中，数据大小 $n$ 为数组的长度。
**数据大小 $n$ 是根据输入数据的类型来确定的**。比如，在上述示例中，我们直接将 $n$ 看作输入数据大小；以下遍历数组示例中，数据大小 $n$ 为数组的长度。
=== "Java"
@@ -1121,7 +1121,7 @@ $$
=== "Swift"
```swift title="time_complexity.swift"
// 线性阶（遍历数组）
/* 线性阶（遍历数组） */
func arrayTraversal(nums: [Int]) -> Int {
var count = 0
// 循环次数与数组长度成正比
@@ -1267,7 +1267,7 @@ $$
=== "Swift"
```swift title="time_complexity.swift"
// 平方阶
/* 平方阶 */
func quadratic(n: Int) -> Int {
var count = 0
// 循环次数与数组长度成平方关系
@@ -1477,7 +1477,7 @@ $$
=== "Swift"
```swift title="time_complexity.swift"
// 平方阶（冒泡排序）
/* 平方阶（冒泡排序） */
func bubbleSort(nums: inout [Int]) -> Int {
var count = 0 // 计数器
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
@@ -1656,7 +1656,7 @@ $$
=== "Swift"
```swift title="time_complexity.swift"
// 指数阶（循环实现）
/* 指数阶（循环实现） */
func exponential(n: Int) -> Int {
var count = 0
var base = 1
@@ -1764,7 +1764,7 @@ $$
=== "Swift"
```swift title="time_complexity.swift"
// 指数阶（递归实现）
/* 指数阶（递归实现） */
func expRecur(n: Int) -> Int {
if n == 1 {
return 1
@@ -1896,7 +1896,7 @@ $$
=== "Swift"
```swift title="time_complexity.swift"
// 对数阶（循环实现）
/* 对数阶（循环实现） */
func logarithmic(n: Int) -> Int {
var count = 0
var n = n
@@ -1999,7 +1999,7 @@ $$
=== "Swift"
```swift title="time_complexity.swift"
// 对数阶（递归实现）
/* 对数阶（递归实现） */
func logRecur(n: Int) -> Int {
if n <= 1 {
return 0
@@ -2137,7 +2137,7 @@ $$
=== "Swift"
```swift title="time_complexity.swift"
// 线性对数阶
/* 线性对数阶 */
func linearLogRecur(n: Double) -> Int {
if n <= 1 {
return 1
@@ -2288,7 +2288,7 @@ $$
=== "Swift"
```swift title="time_complexity.swift"
// 阶乘阶（递归实现）
/* 阶乘阶（递归实现） */
func factorialRecur(n: Int) -> Int {
if n == 0 {
return 1
@@ -2308,7 +2308,7 @@ $$
## 最差、最佳、平均时间复杂度
**某些算法的时间复杂度不是恒定的，而是与输入数据的分布有关。** 举一个例子，输入一个长度为 $n$ 数组 `nums` ，其中 `nums` 由从 $1$ 至 $n$ 的数字组成，但元素顺序是随机打乱的；算法的任务是返回元素 $1$ 的索引。我们可以得出以下结论：
**某些算法的时间复杂度不是恒定的，而是与输入数据的分布有关**。举一个例子，输入一个长度为 $n$ 数组 `nums` ，其中 `nums` 由从 $1$ 至 $n$ 的数字组成，但元素顺序是随机打乱的；算法的任务是返回元素 $1$ 的索引。我们可以得出以下结论：
- 当 `nums = [?, ?, ..., 1]`，即当末尾元素是 $1$ 时，则需完整遍历数组，此时达到 **最差时间复杂度 $O(n)$** ；
- 当 `nums = [1, ?, ?, ...]` ，即当首个数字为 $1$ 时，无论数组多长都不需要继续遍历，此时达到 **最佳时间复杂度 $\Omega(1)$** ；
@@ -2657,8 +2657,8 @@ $$
=== "Swift"
```swift title=""
// 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱
```swift title="worst_best_time_complexity.swift"
/* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */
func randomNumbers(n: Int) -> [Int] {
// 生成数组 nums = { 1, 2, 3, ..., n }
var nums = Array(1 ... n)
@@ -2667,7 +2667,7 @@ $$
return nums
}
// 查找数组 nums 中数字 1 所在索引
/* 查找数组 nums 中数字 1 所在索引 */
func findOne(nums: [Int]) -> Int {
for i in nums.indices {
if nums[i] == 1 {
@@ -2677,14 +2677,14 @@ $$
return -1
}
// Driver Code
/* Driver Code */
func main() {
for _ in 0 ..< 10 {
let n = 100
let nums = randomNumbers(n: n)
let index = findOne(nums: nums)
print("数组 [ 1, 2, ..., n ] 被打乱后 =", nums)
print("数字 1 的索引为", index)
print("数组 [ 1, 2, ..., n ] 被打乱后 = \(nums)")
print("数字 1 的索引为 \(index)")
}
}
```
docs/chapter_data_structure/classification_of_data_structure.md
+3 -3
View File
@@ -8,7 +8,7 @@ comments: true
## 逻辑结构：线性与非线性
**「逻辑结构」反映了数据之间的逻辑关系。** 数组和链表的数据按照顺序依次排列，反映了数据间的线性关系；树从顶至底按层级排列，反映了祖先与后代之间的派生关系；图由结点和边组成，反映了复杂网络关系。
**「逻辑结构」反映了数据之间的逻辑关系**。数组和链表的数据按照顺序依次排列，反映了数据间的线性关系；树从顶至底按层级排列，反映了祖先与后代之间的派生关系；图由结点和边组成，反映了复杂网络关系。
我们一般将逻辑结构分为「线性」和「非线性」两种。“线性”这个概念很直观，即表明数据在逻辑关系上是排成一条线的；而如果数据之间的逻辑关系是非线形的（例如是网状或树状的），那么就是非线性数据结构。
@@ -25,13 +25,13 @@ comments: true
若感到阅读困难，建议先看完下个章节「数组与链表」，再回过头来理解物理结构的含义。
**「物理结构」反映了数据在计算机内存中的存储方式。** 从本质上看，分别是 **数组的连续空间存储** 和 **链表的离散空间存储** 。物理结构从底层上决定了数据的访问、更新、增删等操作方法，在时间效率和空间效率方面呈现出此消彼长的特性。
**「物理结构」反映了数据在计算机内存中的存储方式**。从本质上看，分别是 **数组的连续空间存储** 和 **链表的离散空间存储** 。物理结构从底层上决定了数据的访问、更新、增删等操作方法，在时间效率和空间效率方面呈现出此消彼长的特性。
![classification_phisical_structure](classification_of_data_structure.assets/classification_phisical_structure.png)
<p align="center"> Fig. 连续空间存储与离散空间存储 </p>
**所有数据结构都是基于数组、或链表、或两者组合实现的。** 例如栈和队列，既可以使用数组实现、也可以使用链表实现，而例如哈希表，其实现同时包含了数组和链表。
**所有数据结构都是基于数组、或链表、或两者组合实现的**。例如栈和队列，既可以使用数组实现、也可以使用链表实现，而例如哈希表，其实现同时包含了数组和链表。
- **基于数组可实现：** 栈、队列、堆、哈希表、矩阵、张量（维度 $\geq 3$ 的数组）等；
- **基于链表可实现：** 栈、队列、堆、哈希表、树、图等；
docs/chapter_data_structure/data_and_memory.md
+4 -4
View File
@@ -117,7 +117,7 @@ comments: true
=== "Swift"
```swift title=""
// 使用多种「基本数据类型」来初始化「数组」
/* 使用多种「基本数据类型」来初始化「数组」 */
let numbers = Array(repeating: Int(), count: 5)
let decimals = Array(repeating: Double(), count: 5)
let characters = Array(repeating: Character("a"), count: 5)
@@ -128,12 +128,12 @@ comments: true
在计算机中，内存和硬盘是两种主要的存储硬件设备。「硬盘」主要用于长期存储数据，容量较大（通常可达到 TB 级别）、速度较慢。「内存」用于运行程序时暂存数据，速度更快，但容量较小（通常为 GB 级别）。
**算法运行中，相关数据都被存储在内存中。** 下图展示了一个计算机内存条，其中每个黑色方块都包含一块内存空间。我们可以将内存想象成一个巨大的 Excel 表格，其中每个单元格都可以存储 1 byte 的数据，在算法运行时，所有数据都被存储在这些单元格中。
**算法运行中，相关数据都被存储在内存中**。下图展示了一个计算机内存条，其中每个黑色方块都包含一块内存空间。我们可以将内存想象成一个巨大的 Excel 表格，其中每个单元格都可以存储 1 byte 的数据，在算法运行时，所有数据都被存储在这些单元格中。
**系统通过「内存地址 Memory Location」来访问目标内存位置的数据。** 计算机根据特定规则给表格中每个单元格编号，保证每块内存空间都有独立的内存地址。自此，程序便通过这些地址，访问内存中的数据。
**系统通过「内存地址 Memory Location」来访问目标内存位置的数据**。计算机根据特定规则给表格中每个单元格编号，保证每块内存空间都有独立的内存地址。自此，程序便通过这些地址，访问内存中的数据。
![computer_memory_location](data_and_memory.assets/computer_memory_location.png)
<p align="center"> Fig. 内存条、内存空间、内存地址 </p>
**内存资源是设计数据结构与算法的重要考虑因素。** 内存是所有程序的公共资源，当内存被某程序占用时，不能被其它程序同时使用。我们需要根据剩余内存资源的情况来设计算法。例如，若剩余内存空间有限，则要求算法占用的峰值内存不能超过系统剩余内存；若运行的程序很多、缺少大块连续的内存空间，则要求选取的数据结构必须能够存储在离散的内存空间内。
**内存资源是设计数据结构与算法的重要考虑因素**。内存是所有程序的公共资源，当内存被某程序占用时，不能被其它程序同时使用。我们需要根据剩余内存资源的情况来设计算法。例如，若剩余内存空间有限，则要求算法占用的峰值内存不能超过系统剩余内存；若运行的程序很多、缺少大块连续的内存空间，则要求选取的数据结构必须能够存储在离散的内存空间内。
docs/chapter_hashing/hash_map.md
+46 -28
View File
@@ -108,25 +108,25 @@ comments: true
=== "Go"
```go title="hash_map_test.go"
/* 初始化哈希表 */
mapp := make(map[int]string)
```go title="hash_map.go"
/* 初始化哈希表 */
mapp := make(map[int]string)
/* 添加操作 */
// 在哈希表中添加键值对 (key, value)
mapp[12836] = "小哈"
mapp[15937] = "小啰"
mapp[16750] = "小算"
mapp[13276] = "小法"
mapp[10583] = "小鸭"
/* 添加操作 */
// 在哈希表中添加键值对 (key, value)
mapp[12836] = "小哈"
mapp[15937] = "小啰"
mapp[16750] = "小算"
mapp[13276] = "小法"
mapp[10583] = "小鸭"
/* 查询操作 */
// 向哈希表输入键 key ，得到值 value
name := mapp[15937]
/* 查询操作 */
// 向哈希表输入键 key ，得到值 value
name := mapp[15937]
/* 删除操作 */
// 在哈希表中删除键值对 (key, value)
delete(mapp, 10583)
/* 删除操作 */
// 在哈希表中删除键值对 (key, value)
delete(mapp, 10583)
```
=== "JavaScript"
@@ -207,6 +207,12 @@ comments: true
map.Remove(10583);
```
=== "Swift"
```swift title="hash_map.swift"
```
遍历哈希表有三种方式，即 **遍历键值对、遍历键、遍历值**。
=== "Java"
@@ -339,6 +345,12 @@ comments: true
}
```
=== "Swift"
```swift title="hash_map.swift"
```
## 哈希函数
哈希表中存储元素的数据结构被称为「桶 Bucket」，底层实现可能是数组、链表、二叉树（红黑树），或是它们的组合。
@@ -512,30 +524,30 @@ $$
```go title="array_hash_map.go"
/* 键值对 int->String */
type Entry struct {
type entry struct {
key int
val string
}
/* 基于数组简易实现的哈希表 */
type ArrayHashMap struct {
bucket []*Entry
type arrayHashMap struct {
bucket []*entry
}
func newArrayHashMap() *ArrayHashMap {
func newArrayHashMap() *arrayHashMap {
// 初始化一个长度为 100 的桶（数组）
bucket := make([]*Entry, 100)
return &ArrayHashMap{bucket: bucket}
bucket := make([]*entry, 100)
return &arrayHashMap{bucket: bucket}
}
/* 哈希函数 */
func (a *ArrayHashMap) hashFunc(key int) int {
func (a *arrayHashMap) hashFunc(key int) int {
index := key % 100
return index
}
/* 查询操作 */
func (a *ArrayHashMap) get(key int) string {
func (a *arrayHashMap) get(key int) string {
index := a.hashFunc(key)
pair := a.bucket[index]
if pair == nil {
@@ -545,16 +557,16 @@ $$
}
/* 添加操作 */
func (a *ArrayHashMap) put(key int, val string) {
pair := &Entry{key: key, val: val}
func (a *arrayHashMap) put(key int, val string) {
pair := &entry{key: key, val: val}
index := a.hashFunc(key)
a.bucket[index] = pair
}
/* 删除操作 */
func (a *ArrayHashMap) remove(key int) {
func (a *arrayHashMap) remove(key int) {
index := a.hashFunc(key)
// 置为空字符，代表删除
// 置为 nil ，代表删除
a.bucket[index] = nil
}
```
@@ -756,6 +768,12 @@ $$
}
```
=== "Swift"
```swift title="array_hash_map.swift"
```
## 哈希冲突
细心的同学可能会发现，**哈希函数 $f(x) = x \% 100$ 会在某些情况下失效**。具体地，当输入的 key 后两位相同时，哈希函数的计算结果也相同，指向同一个 value 。例如，分别查询两个学号 12836 和 20336 ，则有
docs/chapter_introduction/algorithms_are_everywhere.md
+3 -3
View File
@@ -6,13 +6,13 @@ comments: true
听到“算法”这个词，我们一般会联想到数学。但实际上，大多数算法并不包含复杂的数学，而更像是在考察基本逻辑，而这些逻辑在我们日常生活中处处可见。
在正式介绍算法之前，我想告诉你一件有趣的事：**其实，你在过去已经学会了很多算法，并且已经习惯将它们应用到日常生活中。** 接下来，我将介绍两个具体例子来佐证。
在正式介绍算法之前，我想告诉你一件有趣的事：**其实，你在过去已经学会了很多算法，并且已经习惯将它们应用到日常生活中**。接下来，我将介绍两个具体例子来佐证。
**例一：拼积木。** 一套积木，除了有许多部件之外，还会附送详细的拼装说明书。我们按照说明书上一步步操作，即可拼出复杂的积木模型。
**例一：拼积木**。一套积木，除了有许多部件之外，还会附送详细的拼装说明书。我们按照说明书上一步步操作，即可拼出复杂的积木模型。
如果从数据结构与算法的角度看，大大小小的「积木」就是数据结构，而「拼装说明书」上的一系列步骤就是算法。
**例二：查字典。** 在字典中，每个汉字都有一个对应的拼音，而字典是按照拼音的英文字母表顺序排列的。假设需要在字典中查询任意一个拼音首字母为 $r$ 的字，一般我们会这样做：
**例二：查字典**。在字典中，每个汉字都有一个对应的拼音，而字典是按照拼音的英文字母表顺序排列的。假设需要在字典中查询任意一个拼音首字母为 $r$ 的字，一般我们会这样做：
1. 打开字典大致一半页数的位置，查看此页的首字母是什么（假设为 $m$ ）；
2. 由于在英文字母表中 $r$ 在 $m$ 的后面，因此应排除字典前半部分，查找范围仅剩后半部分；
docs/chapter_preface/about_the_book.md
+16 -3
View File
@@ -192,6 +192,19 @@ comments: true
*/
```
=== "Swift"
```swift title=""
/* 标题注释，用于标注函数、类、测试样例等 */
// 内容注释，用于详解代码
/**
* 多行
* 注释
*/
```
"""
在 Java, C, C++, C#, Go, JS, TS 的代码注释中，`/* ... */` 用于注释函数、类、测试样例等标题， `// ...` 用于解释代码内容；类似地，在 Python 中，`""" ... """` 用于注释标题， `# ...` 用于解释代码。
@@ -199,19 +212,19 @@ comments: true
??? abstract "默认折叠，可以跳过"
**以实践为主。** 我们知道，学习英语期间光啃书本是远远不够的，需要多听、多说、多写，在实践中培养语感、积累经验。编程语言也是一门语言，因此学习方法也应是类似的，需要多看优秀代码、多敲键盘、多思考代码逻辑。
**以实践为主**。我们知道，学习英语期间光啃书本是远远不够的，需要多听、多说、多写，在实践中培养语感、积累经验。编程语言也是一门语言，因此学习方法也应是类似的，需要多看优秀代码、多敲键盘、多思考代码逻辑。
本书的理论部分占少量篇幅，主要分为两类：一是基础且必要的概念知识，以培养读者对于算法的感性认识；二是重要的分类、对比或总结，这是为了帮助你站在更高视角俯瞰各个知识点，形成连点成面的效果。
实践部分主要由示例和代码组成。代码配有简要注释，复杂示例会尽可能地使用视觉化的形式呈现。我强烈建议读者对照着代码自己敲一遍，如果时间有限，也至少逐行读、复制并运行一遍，配合着讲解将代码吃透。
**视觉化学习。** 信息时代以来，视觉化的脚步从未停止。媒体形式经历了文字短信、图文 Email 、动图、短（长）视频、交互式 Web 、3D 游戏等演变过程，信息的视觉化程度越来越高、愈加符合人类感官、信息传播效率大大提升。科技界也在向视觉化迈进，iPhone 就是一个典型例子，其相对于传统手机是高度视觉化的，包含精心设计的字体、主题配色、交互动画等。
**视觉化学习**。信息时代以来，视觉化的脚步从未停止。媒体形式经历了文字短信、图文 Email 、动图、短（长）视频、交互式 Web 、3D 游戏等演变过程，信息的视觉化程度越来越高、愈加符合人类感官、信息传播效率大大提升。科技界也在向视觉化迈进，iPhone 就是一个典型例子，其相对于传统手机是高度视觉化的，包含精心设计的字体、主题配色、交互动画等。
近两年，短视频成为最受欢迎的信息媒介，可以在短时间内将高密度的信息“灌”给我们，有着极其舒适的观看体验。阅读则不然，读者与书本之间天然存在一种“疏离感”，我们看书会累、会走神、会停下来想其他事、会划下喜欢的句子、会思考某一片段的含义，这种疏离感给了读者与书本之间对话的可能，拓宽了想象空间。
本书作为一本入门教材，希望可以保有书本的“慢节奏”，但也会避免与读者产生过多“疏离感”，而是努力将知识完整清晰地推送到你聪明的小脑袋瓜中。我将采用视觉化的方式（例如配图、动画），尽我可能清晰易懂地讲解复杂概念和抽象示例。
**内容精简化。** 大多数的经典教科书，会把每个主题都讲的很透彻。虽然透彻性正是其获得读者青睐的原因，但对于想要快速入门的初学者来说，这些教材的实用性不足。本书会避免引入非必要的概念、名词、定义等，也避免展开不必要的理论分析，毕竟这不是一本真正意义上的教材，主要任务是尽快地带领读者入门。
**内容精简化**。大多数的经典教科书，会把每个主题都讲的很透彻。虽然透彻性正是其获得读者青睐的原因，但对于想要快速入门的初学者来说，这些教材的实用性不足。本书会避免引入非必要的概念、名词、定义等，也避免展开不必要的理论分析，毕竟这不是一本真正意义上的教材，主要任务是尽快地带领读者入门。
引入一些生活案例或趣味内容，非常适合作为知识点的引子或者解释的补充，但当融入过多额外元素时，内容会稍显冗长，也许反而使读者容易迷失、抓不住重点，这也是本书需要避免的。
docs/chapter_preface/suggestions.md
+3 -3
View File
@@ -54,10 +54,10 @@ git clone https://github.com/krahets/hello-algo.git
## 算法学习“三步走”
**第一阶段，算法入门，也正是本书的定位。** 熟悉各种数据结构的特点、用法，学习各种算法的工作原理、用途、效率等。
**第一阶段，算法入门，也正是本书的定位**。熟悉各种数据结构的特点、用法，学习各种算法的工作原理、用途、效率等。
**第二阶段，刷算法题。** 可以先从热门题单开刷，推荐 [剑指 Offer](https://leetcode.cn/problem-list/xb9nqhhg/)、[LeetCode 热题 HOT 100](https://leetcode.cn/problem-list/2cktkvj/) ，先积累至少 100 道题量，熟悉大多数的算法问题。刚开始刷题时，“遗忘”是最大的困扰点，但这是很正常的，请不要担心。学习中有一种概念叫“周期性回顾”，同一道题隔段时间做一次，当做了三遍以上，往往就能牢记于心了。
**第二阶段，刷算法题**。可以先从热门题单开刷，推荐 [剑指 Offer](https://leetcode.cn/problem-list/xb9nqhhg/)、[LeetCode 热题 HOT 100](https://leetcode.cn/problem-list/2cktkvj/) ，先积累至少 100 道题量，熟悉大多数的算法问题。刚开始刷题时，“遗忘”是最大的困扰点，但这是很正常的，请不要担心。学习中有一种概念叫“周期性回顾”，同一道题隔段时间做一次，当做了三遍以上，往往就能牢记于心了。
**第三阶段，搭建知识体系。** 在学习方面，可以阅读算法专栏文章、解题框架、算法教材，不断地丰富知识体系。在刷题方面，可以开始采用进阶刷题方案，例如按专题分类、一题多解、一解多题等，刷题方案在社区中可以找到一些讲解，在此不做赘述。
**第三阶段，搭建知识体系**。在学习方面，可以阅读算法专栏文章、解题框架、算法教材，不断地丰富知识体系。在刷题方面，可以开始采用进阶刷题方案，例如按专题分类、一题多解、一解多题等，刷题方案在社区中可以找到一些讲解，在此不做赘述。
![learning_route](suggestions.assets/learning_route.png)
docs/chapter_searching/binary_search.md
+23 -5
View File
@@ -210,6 +210,12 @@ $$
}
```
=== "Swift"
```swift title="binary_search.swift"
```
### “左闭右开”实现
当然，我们也可以使用“左闭右开”的表示方法，写出相同功能的二分查找代码。
@@ -374,6 +380,12 @@ $$
}
```
=== "Swift"
```swift title="binary_search.swift"
```
### 两种表示对比
对比下来，两种表示的代码写法有以下不同点：
@@ -460,6 +472,12 @@ $$
int m = i + (j - i) / 2;
```
=== "Swift"
```swift title=""
```
## 复杂度分析
**时间复杂度 $O(\log n)$ ：** 其中 $n$ 为数组或链表长度；每轮排除一半的区间，因此循环轮数为 $\log_2 n$ ，使用 $O(\log n)$ 时间。
@@ -470,11 +488,11 @@ $$
二分查找效率很高，体现在：
- **二分查找时间复杂度低。** 对数阶在数据量很大时具有巨大优势，例如，当数据大小 $n = 2^{20}$ 时，线性查找需要 $2^{20} = 1048576$ 轮循环，而二分查找仅需要 $\log_2 2^{20} = 20$ 轮循环。
- **二分查找不需要额外空间。** 相对于借助额外数据结构来实现查找的算法来说，其更加节约空间使用。
- **二分查找时间复杂度低**。对数阶在数据量很大时具有巨大优势，例如，当数据大小 $n = 2^{20}$ 时，线性查找需要 $2^{20} = 1048576$ 轮循环，而二分查找仅需要 $\log_2 2^{20} = 20$ 轮循环。
- **二分查找不需要额外空间**。相对于借助额外数据结构来实现查找的算法来说，其更加节约空间使用。
但并不意味着所有情况下都应使用二分查找，这是因为：
- **二分查找仅适用于有序数据。** 如果输入数据是无序的，为了使用二分查找而专门执行数据排序，那么是得不偿失的，因为排序算法的时间复杂度一般为 $O(n \log n)$ ，比线性查找和二分查找都更差。再例如，对于频繁插入元素的场景，为了保持数组的有序性，需要将元素插入到特定位置，时间复杂度为 $O(n)$ ，也是非常昂贵的。
- **二分查找仅适用于数组。** 由于在二分查找中，访问索引是 ”非连续“ 的，因此链表或者基于链表实现的数据结构都无法使用。
- **在小数据量下，线性查找的性能更好。** 在线性查找中，每轮只需要 1 次判断操作；而在二分查找中，需要 1 次加法、1 次除法、1 ~ 3 次判断操作、1 次加法（减法），共 4 ~ 6 个单元操作；因此，在数据量 $n$ 较小时，线性查找反而比二分查找更快。
- **二分查找仅适用于有序数据**。如果输入数据是无序的，为了使用二分查找而专门执行数据排序，那么是得不偿失的，因为排序算法的时间复杂度一般为 $O(n \log n)$ ，比线性查找和二分查找都更差。再例如，对于频繁插入元素的场景，为了保持数组的有序性，需要将元素插入到特定位置，时间复杂度为 $O(n)$ ，也是非常昂贵的。
- **二分查找仅适用于数组**。由于在二分查找中，访问索引是 ”非连续“ 的，因此链表或者基于链表实现的数据结构都无法使用。
- **在小数据量下，线性查找的性能更好**。在线性查找中，每轮只需要 1 次判断操作；而在二分查找中，需要 1 次加法、1 次除法、1 ~ 3 次判断操作、1 次加法（减法），共 4 ~ 6 个单元操作；因此，在数据量 $n$ 较小时，线性查找反而比二分查找更快。
docs/chapter_searching/hashing_search.md
+12
View File
@@ -95,6 +95,12 @@ comments: true
}
```
=== "Swift"
```swift title="hashing_search.swift"
```
再比如，如果我们想要给定一个目标结点值 `target` ，获取对应的链表结点对象，那么也可以使用哈希查找实现。
![hash_search_listnode](hashing_search.assets/hash_search_listnode.png)
@@ -179,6 +185,12 @@ comments: true
}
```
=== "Swift"
```swift title="hashing_search.swift"
```
## 复杂度分析
**时间复杂度：** $O(1)$ ，哈希表的查找操作使用 $O(1)$ 时间。
docs/chapter_searching/linear_search.md
+14 -2
View File
@@ -133,6 +133,12 @@ comments: true
```
=== "Swift"
```swift title="linear_search.swift"
```
再比如，我们想要在给定一个目标结点值 `target` ，返回此结点对象，也可以在链表中进行线性查找。
=== "Java"
@@ -261,6 +267,12 @@ comments: true
}
```
=== "Swift"
```swift title="linear_search.swift"
```
## 复杂度分析
**时间复杂度 $O(n)$ ：** 其中 $n$ 为数组或链表长度。
@@ -269,6 +281,6 @@ comments: true
## 优点与缺点
**线性查找的通用性极佳。** 由于线性查找是依次访问元素的，即没有跳跃访问元素，因此数组或链表皆适用。
**线性查找的通用性极佳**。由于线性查找是依次访问元素的，即没有跳跃访问元素，因此数组或链表皆适用。
**线性查找的时间复杂度太高。** 在数据量 $n$ 很大时，查找效率很低。
**线性查找的时间复杂度太高**。在数据量 $n$ 很大时，查找效率很低。
docs/chapter_sorting/bubble_sort.md
+12
View File
@@ -212,6 +212,12 @@ comments: true
}
```
=== "Swift"
```swift title="bubble_sort.swift"
```
## 算法特性
**时间复杂度 $O(n^2)$ ：** 各轮「冒泡」遍历的数组长度为 $n - 1$ , $n - 2$ , $\cdots$ , $2$ , $1$ 次，求和为 $\frac{(n - 1) n}{2}$ ，因此使用 $O(n^2)$ 时间。
@@ -414,3 +420,9 @@ comments: true
}
}
```
=== "Swift"
```swift title="bubble_sort.swift"
```
docs/chapter_sorting/insertion_sort.md
+6
View File
@@ -175,6 +175,12 @@ comments: true
}
```
=== "Swift"
```swift title="insertion_sort.swift"
```
## 算法特性
**时间复杂度 $O(n^2)$ ：** 最差情况下，各轮插入操作循环 $n - 1$ , $n-2$ , $\cdots$ , $2$ , $1$ 次，求和为 $\frac{(n - 1) n}{2}$ ，使用 $O(n^2)$ 时间。
docs/chapter_sorting/merge_sort.md
+15 -10
View File
@@ -201,36 +201,35 @@ comments: true
右子数组区间 [mid + 1, right]
*/
func merge(nums []int, left, mid, right int) {
// 初始化辅助数组 借助 copy模块
// 初始化辅助数组 借助 copy 模块
tmp := make([]int, right-left+1)
for i := left; i <= right; i++ {
tmp[i-left] = nums[i]
}
// 左子数组的起始索引和结束索引
left_start, left_end := left-left, mid-left
leftStart, leftEnd := left-left, mid-left
// 右子数组的起始索引和结束索引
right_start, right_end := mid+1-left, right-left
rightStart, rightEnd := mid+1-left, right-left
// i, j 分别指向左子数组、右子数组的首元素
i, j := left_start, right_start
i, j := leftStart, rightStart
// 通过覆盖原数组 nums 来合并左子数组和右子数组
for k := left; k <= right; k++ {
// 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
if i > left_end {
if i > leftEnd {
nums[k] = tmp[j]
j++
// 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
} else if j > right_end || tmp[i] <= tmp[j] {
// 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
} else if j > rightEnd || tmp[i] <= tmp[j] {
nums[k] = tmp[i]
i++
// 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
// 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
} else {
nums[k] = tmp[j]
j++
}
}
}
/* 归并排序 */
func mergeSort(nums []int, left, right int) {
// 终止条件
if left >= right {
@@ -388,6 +387,12 @@ comments: true
}
```
=== "Swift"
```swift title="merge_sort.swift"
```
下面重点解释一下合并方法 `merge()` 的流程：
1. 初始化一个辅助数组 `tmp` 暂存待合并区间 `[left, right]` 内的元素，后续通过覆盖原数组 `nums` 的元素来实现合并；
docs/chapter_sorting/quick_sort.md
+33 -9
View File
@@ -111,21 +111,21 @@ comments: true
```go title="quick_sort.go"
/* 哨兵划分 */
func partition(nums []int, left, right int) int {
//以 nums[left] 作为基准数
// 以 nums[left] 作为基准数
i, j := left, right
for i < j {
for i < j && nums[j] >= nums[left] {
j-- //从右向左找首个小于基准数的元素
j-- // 从右向左找首个小于基准数的元素
}
for i < j && nums[i] <= nums[left] {
i++ //从左向右找首个大于基准数的元素
i++ // 从左向右找首个大于基准数的元素
}
//元素交换
nums[i], nums[j] = nums[j], nums[i]
}
//将基准数交换至两子数组的分界线
// 将基准数交换至两子数组的分界线
nums[i], nums[left] = nums[left], nums[i]
return i //返回基准数的索引
return i // 返回基准数的索引
}
```
@@ -223,6 +223,12 @@ comments: true
```
=== "Swift"
```swift title="quick_sort.swift"
```
!!! note "快速排序的分治思想"
哨兵划分的实质是将 **一个长数组的排序问题** 简化为 **两个短数组的排序问题**。
@@ -359,6 +365,12 @@ comments: true
```
=== "Swift"
```swift title="quick_sort.swift"
```
## 算法特性
**平均时间复杂度 $O(n \log n)$ ：** 平均情况下，哨兵划分的递归层数为 $\log n$ ，每层中的总循环数为 $n$ ，总体使用 $O(n \log n)$ 时间。
@@ -383,7 +395,7 @@ comments: true
## 基准数优化
**普通快速排序在某些输入下的时间效率变差。** 举个极端例子，假设输入数组是完全倒序的，由于我们选取最左端元素为基准数，那么在哨兵划分完成后，基准数被交换至数组最右端，从而 **左子数组长度为 $n - 1$ 、右子数组长度为 $0$** 。这样进一步递归下去，**每轮哨兵划分后的右子数组长度都为 $0$** ，分治策略失效，快速排序退化为「冒泡排序」了。
**普通快速排序在某些输入下的时间效率变差**。举个极端例子，假设输入数组是完全倒序的，由于我们选取最左端元素为基准数，那么在哨兵划分完成后，基准数被交换至数组最右端，从而 **左子数组长度为 $n - 1$ 、右子数组长度为 $0$** 。这样进一步递归下去，**每轮哨兵划分后的右子数组长度都为 $0$** ，分治策略失效，快速排序退化为「冒泡排序」了。
为了尽量避免这种情况发生，我们可以优化一下基准数的选取策略。首先，在哨兵划分中，我们可以 **随机选取一个元素作为基准数** 。但如果运气很差，每次都选择到比较差的基准数，那么效率依然不好。
@@ -574,9 +586,15 @@ comments: true
}
```
=== "Swift"
```swift title="quick_sort.swift"
```
## 尾递归优化
**普通快速排序在某些输入下的空间效率变差。** 仍然以完全倒序的输入数组为例，由于每轮哨兵划分后右子数组长度为 0 ，那么将形成一个高度为 $n - 1$ 的递归树，此时使用的栈帧空间大小劣化至 $O(n)$ 。
**普通快速排序在某些输入下的空间效率变差**。仍然以完全倒序的输入数组为例，由于每轮哨兵划分后右子数组长度为 0 ，那么将形成一个高度为 $n - 1$ 的递归树，此时使用的栈帧空间大小劣化至 $O(n)$ 。
为了避免栈帧空间的累积，我们可以在每轮哨兵排序完成后，判断两个子数组的长度大小，仅递归排序较短的子数组。由于较短的子数组长度不会超过 $\frac{n}{2}$ ，因此这样做能保证递归深度不超过 $\log n$ ，即最差空间复杂度被优化至 $O(\log n)$ 。
@@ -652,10 +670,10 @@ comments: true
// 对两个子数组中较短的那个执行快排
if pivot-left < right-pivot {
quickSort(nums, left, pivot-1) // 递归排序左子数组
left = pivot + 1 // 剩余待排序区间为 [pivot + 1, right]
left = pivot + 1 // 剩余待排序区间为 [pivot + 1, right]
} else {
quickSort(nums, pivot+1, right) // 递归排序右子数组
right = pivot - 1 // 剩余待排序区间为 [left, pivot - 1]
right = pivot - 1 // 剩余待排序区间为 [left, pivot - 1]
}
}
}
@@ -734,3 +752,9 @@ comments: true
}
}
```
=== "Swift"
```swift title="quick_sort.swift"
```
docs/chapter_stack_and_queue/deque.md
+35 -29
View File
@@ -12,7 +12,7 @@ comments: true
## 双向队列常用操作
双向队列的常用操作见下表，方法名需根据编程语言设定来具体确定。
双向队列的常用操作见下表（方法命名以 Java 为例）。
<p align="center"> Table. 双向队列的常用操作 </p>
@@ -38,25 +38,25 @@ comments: true
```java title="deque.java"
/* 初始化双向队列 */
Deque<Integer> deque = new LinkedList<>();
/* 元素入队 */
deque.offerLast(2); // 添加至队尾
deque.offerLast(5);
deque.offerLast(4);
deque.offerFirst(3); // 添加至队首
deque.offerFirst(1);
/* 访问元素 */
int peekFirst = deque.peekFirst(); // 队首元素
int peekLast = deque.peekLast(); // 队尾元素
/* 元素出队 */
int pollFirst = deque.pollFirst(); // 队首元素出队
int pollLast = deque.pollLast(); // 队尾元素出队
/* 获取双向队列的长度 */
int size = deque.size();
/* 判断双向队列是否为空 */
boolean isEmpty = deque.isEmpty();
```
@@ -66,25 +66,25 @@ comments: true
```cpp title="deque.cpp"
/* 初始化双向队列 */
deque<int> deque;
/* 元素入队 */
deque.push_back(2); // 添加至队尾
deque.push_back(5);
deque.push_back(4);
deque.push_front(3); // 添加至队首
deque.push_front(1);
/* 访问元素 */
int front = deque.front(); // 队首元素
int back = deque.back(); // 队尾元素
/* 元素出队 */
deque.pop_front(); // 队首元素出队
deque.pop_back(); // 队尾元素出队
/* 获取双向队列的长度 */
int size = deque.size();
/* 判断双向队列是否为空 */
bool empty = deque.empty();
```
@@ -94,25 +94,25 @@ comments: true
```python title="deque.py"
""" 初始化双向队列 """
duque = deque()
""" 元素入队 """
duque.append(2) # 添加至队尾
duque.append(5)
duque.append(4)
duque.appendleft(3) # 添加至队首
duque.appendleft(1)
""" 访问元素 """
front = duque[0] # 队首元素
rear = duque[-1] # 队尾元素
""" 元素出队 """
pop_front = duque.popleft() # 队首元素出队
pop_rear = duque.pop() # 队尾元素出队
""" 获取双向队列的长度 """
size = len(duque)
""" 判断双向队列是否为空 """
is_empty = len(duque) == 0
```
@@ -123,25 +123,25 @@ comments: true
/* 初始化双向队列 */
// 在 Go 中，将 list 作为双向队列使用
deque := list.New()
/* 元素入队 */
deque.PushBack(2) // 添加至队尾
deque.PushBack(5)
deque.PushBack(4)
deque.PushFront(3) // 添加至队首
deque.PushFront(1)
/* 访问元素 */
front := deque.Front() // 队首元素
rear := deque.Back() // 队尾元素
/* 元素出队 */
deque.Remove(front) // 队首元素出队
deque.Remove(rear) // 队尾元素出队
/* 获取双向队列的长度 */
size := deque.Len()
/* 判断双向队列是否为空 */
isEmpty := deque.Len() == 0
```
@@ -149,19 +149,19 @@ comments: true
=== "JavaScript"
```js title="deque.js"
```
=== "TypeScript"
```typescript title="deque.ts"
```
=== "C"
```c title="deque.c"
```
=== "C#"
@@ -170,25 +170,31 @@ comments: true
/* 初始化双向队列 */
// 在 C# 中，将链表 LinkedList 看作双向队列来使用
LinkedList<int> deque = new LinkedList<int>();
/* 元素入队 */
deque.AddLast(2); // 添加至队尾
deque.AddLast(5);
deque.AddLast(4);
deque.AddFirst(3); // 添加至队首
deque.AddFirst(1);
/* 访问元素 */
int peekFirst = deque.First.Value; // 队首元素
int peekLast = deque.Last.Value; // 队尾元素
/* 元素出队 */
deque.RemoveFirst(); // 队首元素出队
deque.RemoveLast(); // 队尾元素出队
/* 获取双向队列的长度 */
int size = deque.Count;
/* 判断双向队列是否为空 */
bool isEmpty = deque.Count == 0;
```
=== "Swift"
```swift title="deque.swift"
```
docs/chapter_stack_and_queue/queue.md
+115 -85
View File
@@ -14,7 +14,7 @@ comments: true
## 队列常用操作
队列的常用操作见下表，方法命名需根据编程语言的设定来具体确定。
队列的常用操作见下表（方法命名以 Java 为例）。
<p align="center"> Table. 队列的常用操作 </p>
@@ -37,23 +37,23 @@ comments: true
```java title="queue.java"
/* 初始化队列 */
Queue<Integer> queue = new LinkedList<>();
/* 元素入队 */
queue.offer(1);
queue.offer(3);
queue.offer(2);
queue.offer(5);
queue.offer(4);
/* 访问队首元素 */
int peek = queue.peek();
/* 元素出队 */
int poll = queue.poll();
/* 获取队列的长度 */
int size = queue.size();
/* 判断队列是否为空 */
boolean isEmpty = queue.isEmpty();
```
@@ -91,23 +91,23 @@ comments: true
# 在 Python 中，我们一般将双向队列类 deque 看作队列使用
# 虽然 queue.Queue() 是纯正的队列类，但不太好用，因此不建议
que = collections.deque()
""" 元素入队 """
que.append(1)
que.append(3)
que.append(2)
que.append(5)
que.append(4)
""" 访问队首元素 """
front = que[0];
""" 元素出队 """
pop = que.popleft()
""" 获取队列的长度 """
size = len(que)
""" 判断队列是否为空 """
is_empty = len(que) == 0
```
@@ -118,24 +118,24 @@ comments: true
/* 初始化队列 */
// 在 Go 中，将 list 作为队列来使用
queue := list.New()
/* 元素入队 */
queue.PushBack(1)
queue.PushBack(3)
queue.PushBack(2)
queue.PushBack(5)
queue.PushBack(4)
/* 访问队首元素 */
peek := queue.Front()
/* 元素出队 */
poll := queue.Front()
queue.Remove(poll)
/* 获取队列的长度 */
size := queue.Len()
/* 判断队列是否为空 */
isEmpty := queue.Len() == 0
```
@@ -146,24 +146,24 @@ comments: true
/* 初始化队列 */
// JavaScript 没有内置的队列，可以把 Array 当作队列来使用
const queue = [];
/* 元素入队 */
queue.push(1);
queue.push(3);
queue.push(2);
queue.push(5);
queue.push(4);
/* 访问队首元素 */
const peek = queue[0];
/* 元素出队 */
// 底层是数组，因此 shift() 方法的时间复杂度为 O(n)
const poll = queue.shift();
/* 获取队列的长度 */
const size = queue.length;
/* 判断队列是否为空 */
const empty = queue.length === 0;
```
@@ -174,24 +174,24 @@ comments: true
/* 初始化队列 */
// TypeScript 没有内置的队列，可以把 Array 当作队列来使用
const queue: number[] = [];
/* 元素入队 */
queue.push(1);
queue.push(3);
queue.push(2);
queue.push(5);
queue.push(4);
/* 访问队首元素 */
const peek = queue[0];
/* 元素出队 */
// 底层是数组，因此 shift() 方法的时间复杂度为 O(n)
const poll = queue.shift();
/* 获取队列的长度 */
const size = queue.length;
/* 判断队列是否为空 */
const empty = queue.length === 0;
```
@@ -199,7 +199,7 @@ comments: true
=== "C"
```c title="queue.c"
```
=== "C#"
@@ -207,27 +207,33 @@ comments: true
```csharp title="queue.cs"
/* 初始化队列 */
Queue<int> queue = new();
/* 元素入队 */
queue.Enqueue(1);
queue.Enqueue(3);
queue.Enqueue(2);
queue.Enqueue(5);
queue.Enqueue(4);
/* 访问队首元素 */
int peek = queue.Peek();
/* 元素出队 */
int poll = queue.Dequeue();
/* 获取队列的长度 */
int size = queue.Count();
/* 判断队列是否为空 */
bool isEmpty = queue.Count() == 0;
```
=== "Swift"
```swift title="queue.swift"
```
## 队列实现
队列需要一种可以在一端添加，并在另一端删除的数据结构，也可以使用链表或数组来实现。
@@ -243,7 +249,7 @@ comments: true
class LinkedListQueue {
private ListNode front, rear; // 头结点 front ，尾结点 rear
private int queSize = 0;
public LinkedListQueue() {
front = null;
rear = null;
@@ -296,7 +302,7 @@ comments: true
private:
ListNode *front, *rear; // 头结点 front ，尾结点 rear
int queSize;
public:
LinkedListQueue() {
front = nullptr;
@@ -355,15 +361,15 @@ comments: true
self.__front = None # 头结点 front
self.__rear = None # 尾结点 rear
self.__size = 0
""" 获取队列的长度 """
def size(self):
return self.__size
""" 判断队列是否为空 """
def is_empty(self):
return not self.__front
""" 入队 """
def push(self, num):
# 尾结点后添加 num
@@ -377,7 +383,7 @@ comments: true
self.__rear.next = node
self.__rear = node
self.__size += 1
""" 出队 """
def poll(self):
num = self.peek()
@@ -385,7 +391,7 @@ comments: true
self.__front = self.__front.next
self.__size -= 1
return num
""" 访问队首元素 """
def peek(self):
if self.size() == 0:
@@ -398,43 +404,49 @@ comments: true
```go title="linkedlist_queue.go"
/* 基于链表实现的队列 */
type LinkedListQueue struct {
type linkedListQueue struct {
// 使用内置包 list 来实现队列
data *list.List
}
// NewLinkedListQueue 初始化链表
func NewLinkedListQueue() *LinkedListQueue {
return &LinkedListQueue{
// newLinkedListQueue 初始化链表
func newLinkedListQueue() *linkedListQueue {
return &linkedListQueue{
data: list.New(),
}
}
// Offer 入队
func (s *LinkedListQueue) Offer(value any) {
// offer 入队
func (s *linkedListQueue) offer(value any) {
s.data.PushBack(value)
}
// Poll 出队
func (s *LinkedListQueue) Poll() any {
if s.IsEmpty() {
// poll 出队
func (s *linkedListQueue) poll() any {
if s.isEmpty() {
return nil
}
e := s.data.Front()
s.data.Remove(e)
return e.Value
}
// Peek 访问队首元素
func (s *LinkedListQueue) Peek() any {
if s.IsEmpty() {
// peek 访问队首元素
func (s *linkedListQueue) peek() any {
if s.isEmpty() {
return nil
}
e := s.data.Front()
return e.Value
}
// Size 获取队列的长度
func (s *LinkedListQueue) Size() int {
// size 获取队列的长度
func (s *linkedListQueue) size() int {
return s.data.Len()
}
// IsEmpty 判断队列是否为空
func (s *LinkedListQueue) IsEmpty() bool {
// isEmpty 判断队列是否为空
func (s *linkedListQueue) isEmpty() bool {
return s.data.Len() == 0
}
```
@@ -548,7 +560,7 @@ comments: true
=== "C"
```c title="linkedlist_queue.c"
```
=== "C#"
@@ -612,6 +624,12 @@ comments: true
}
```
=== "Swift"
```swift title="linkedlist_queue.swift"
```
### 基于数组的实现
数组的删除首元素的时间复杂度为 $O(n)$ ，因此不适合直接用来实现队列。然而，我们可以借助两个指针 `front` , `rear` 来分别记录队首和队尾的索引位置，在入队 / 出队时分别将 `front` / `rear` 向后移动一位即可，这样每次仅需操作一个元素，时间复杂度降至 $O(1)$ 。
@@ -630,7 +648,7 @@ comments: true
private int[] nums; // 用于存储队列元素的数组
private int front = 0; // 头指针，指向队首
private int rear = 0; // 尾指针，指向队尾 + 1
public ArrayQueue(int capacity) {
// 初始化数组
nums = new int[capacity];
@@ -686,7 +704,7 @@ comments: true
int cap; // 队列容量
int front = 0; // 头指针，指向队首
int rear = 0; // 尾指针，指向队尾 + 1
public:
ArrayQueue(int capacity) {
// 初始化数组
@@ -741,20 +759,20 @@ comments: true
self.__nums = [0] * size # 用于存储队列元素的数组
self.__front = 0 # 头指针，指向队首
self.__rear = 0 # 尾指针，指向队尾 + 1
""" 获取队列的容量 """
def capacity(self):
return len(self.__nums)
""" 获取队列的长度 """
def size(self):
# 由于将数组看作为环形，可能 rear < front ，因此需要取余数
return (self.capacity() + self.__rear - self.__front) % self.capacity()
""" 判断队列是否为空 """
def is_empty(self):
return (self.__rear - self.__front) == 0
""" 入队 """
def push(self, val):
if self.size() == self.capacity():
@@ -764,21 +782,21 @@ comments: true
self.__nums[self.__rear] = val
# 尾指针向后移动一位，越过尾部后返回到数组头部
self.__rear = (self.__rear + 1) % self.capacity()
""" 出队 """
def poll(self):
num = self.peek()
# 队头指针向后移动一位，若越过尾部则返回到数组头部
self.__front = (self.__front + 1) % self.capacity()
return num
""" 访问队首元素 """
def peek(self):
if self.is_empty():
print("队列为空")
return False
return self.__nums[self.__front]
""" 返回列表用于打印 """
def to_list(self):
res = [0] * self.size()
@@ -793,34 +811,38 @@ comments: true
```go title="array_queue.go"
/* 基于环形数组实现的队列 */
type ArrayQueue struct {
type arrayQueue struct {
data []int // 用于存储队列元素的数组
capacity int // 队列容量（即最多容量的元素个数）
front int // 头指针，指向队首
rear int // 尾指针，指向队尾 + 1
}
// NewArrayQueue 基于环形数组实现的队列
func NewArrayQueue(capacity int) *ArrayQueue {
return &ArrayQueue{
// newArrayQueue 基于环形数组实现的队列
func newArrayQueue(capacity int) *arrayQueue {
return &arrayQueue{
data: make([]int, capacity),
capacity: capacity,
front: 0,
rear: 0,
}
}
// Size 获取队列的长度
func (q *ArrayQueue) Size() int {
// size 获取队列的长度
func (q *arrayQueue) size() int {
size := (q.capacity + q.rear - q.front) % q.capacity
return size
}
// IsEmpty 判断队列是否为空
func (q *ArrayQueue) IsEmpty() bool {
// isEmpty 判断队列是否为空
func (q *arrayQueue) isEmpty() bool {
return q.rear-q.front == 0
}
// Offer 入队
func (q *ArrayQueue) Offer(v int) {
// offer 入队
func (q *arrayQueue) offer(v int) {
// 当 rear == capacity 表示队列已满
if q.Size() == q.capacity {
if q.size() == q.capacity {
return
}
// 尾结点后添加
@@ -828,9 +850,10 @@ comments: true
// 尾指针向后移动一位，越过尾部后返回到数组头部
q.rear = (q.rear + 1) % q.capacity
}
// Poll 出队
func (q *ArrayQueue) Poll() any {
if q.IsEmpty() {
// poll 出队
func (q *arrayQueue) poll() any {
if q.isEmpty() {
return nil
}
v := q.data[q.front]
@@ -838,9 +861,10 @@ comments: true
q.front = (q.front + 1) % q.capacity
return v
}
// Peek 访问队首元素
func (q *ArrayQueue) Peek() any {
if q.IsEmpty() {
// peek 访问队首元素
func (q *arrayQueue) peek() any {
if q.isEmpty() {
return nil
}
v := q.data[q.front]
@@ -950,7 +974,7 @@ comments: true
=== "C"
```c title="array_queue.c"
```
=== "C#"
@@ -1015,7 +1039,13 @@ comments: true
}
```
=== "Swift"
```swift title="array_queue.swift"
```
## 队列典型应用
- **淘宝订单。** 购物者下单后，订单就被加入到队列之中，随后系统再根据顺序依次处理队列中的订单。在双十一时，在短时间内会产生海量的订单，如何处理「高并发」则是工程师们需要重点思考的问题。
- **各种待办事项。** 例如打印机的任务队列、餐厅的出餐队列等等。
- **淘宝订单**。购物者下单后，订单就被加入到队列之中，随后系统再根据顺序依次处理队列中的订单。在双十一时，在短时间内会产生海量的订单，如何处理「高并发」则是工程师们需要重点思考的问题。
- **各种待办事项**。例如打印机的任务队列、餐厅的出餐队列等等。
docs/chapter_stack_and_queue/stack.md
+129 -99
View File
@@ -16,7 +16,7 @@ comments: true
## 栈常用操作
栈的常用操作见下表，方法名需根据编程语言设定来具体确定。
栈的常用操作见下表（方法命名以 Java 为例）。
<p align="center"> Table. 栈的常用操作 </p>
@@ -40,23 +40,23 @@ comments: true
/* 初始化栈 */
// 在 Java 中，推荐将 LinkedList 当作栈来使用
LinkedList<Integer> stack = new LinkedList<>();
/* 元素入栈 */
stack.addLast(1);
stack.addLast(3);
stack.addLast(2);
stack.addLast(5);
stack.addLast(4);
/* 访问栈顶元素 */
int peek = stack.peekLast();
/* 元素出栈 */
int pop = stack.removeLast();
/* 获取栈的长度 */
int size = stack.size();
/* 判断是否为空 */
boolean isEmpty = stack.isEmpty();
```
@@ -66,23 +66,23 @@ comments: true
```cpp title="stack.cpp"
/* 初始化栈 */
stack<int> stack;
/* 元素入栈 */
stack.push(1);
stack.push(3);
stack.push(2);
stack.push(5);
stack.push(4);
/* 访问栈顶元素 */
int top = stack.top();
/* 元素出栈 */
stack.pop();
/* 获取栈的长度 */
int size = stack.size();
/* 判断是否为空 */
bool empty = stack.empty();
```
@@ -93,23 +93,23 @@ comments: true
""" 初始化栈 """
# Python 没有内置的栈类，可以把 List 当作栈来使用
stack = []
""" 元素入栈 """
stack.append(1)
stack.append(3)
stack.append(2)
stack.append(5)
stack.append(4)
""" 访问栈顶元素 """
peek = stack[-1]
""" 元素出栈 """
pop = stack.pop()
""" 获取栈的长度 """
size = len(stack)
""" 判断是否为空 """
is_empty = len(stack) == 0
```
@@ -120,24 +120,24 @@ comments: true
/* 初始化栈 */
// 在 Go 中，推荐将 Slice 当作栈来使用
var stack []int
/* 元素入栈 */
stack = append(stack, 1)
stack = append(stack, 3)
stack = append(stack, 2)
stack = append(stack, 5)
stack = append(stack, 4)
/* 访问栈顶元素 */
peek := stack[len(stack)-1]
/* 元素出栈 */
pop := stack[len(stack)-1]
stack = stack[:len(stack)-1]
/* 获取栈的长度 */
size := len(stack)
/* 判断是否为空 */
isEmpty := len(stack) == 0
```
@@ -148,23 +148,23 @@ comments: true
/* 初始化栈 */
// Javascript 没有内置的栈类，可以把 Array 当作栈来使用
const stack = [];
/* 元素入栈 */
stack.push(1);
stack.push(3);
stack.push(2);
stack.push(5);
stack.push(4);
/* 访问栈顶元素 */
const peek = stack[stack.length-1];
/* 元素出栈 */
const pop = stack.pop();
/* 获取栈的长度 */
const size = stack.length;
/* 判断是否为空 */
const is_empty = stack.length === 0;
```
@@ -175,23 +175,23 @@ comments: true
/* 初始化栈 */
// Typescript 没有内置的栈类，可以把 Array 当作栈来使用
const stack: number[] = [];
/* 元素入栈 */
stack.push(1);
stack.push(3);
stack.push(2);
stack.push(5);
stack.push(4);
/* 访问栈顶元素 */
const peek = stack[stack.length - 1];
/* 元素出栈 */
const pop = stack.pop();
/* 获取栈的长度 */
const size = stack.length;
/* 判断是否为空 */
const is_empty = stack.length === 0;
```
@@ -199,7 +199,7 @@ comments: true
=== "C"
```c title="stack.c"
```
=== "C#"
@@ -207,27 +207,33 @@ comments: true
```csharp title="stack.cs"
/* 初始化栈 */
Stack<int> stack = new ();
/* 元素入栈 */
stack.Push(1);
stack.Push(3);
stack.Push(2);
stack.Push(5);
stack.Push(4);
/* 访问栈顶元素 */
int peek = stack.Peek();
/* 元素出栈 */
int pop = stack.Pop();
/* 获取栈的长度 */
int size = stack.Count();
/* 判断是否为空 */
bool isEmpty = stack.Count()==0;
```
=== "Swift"
```swift title="stack.swift"
```
## 栈的实现
为了更加清晰地了解栈的运行机制，接下来我们来自己动手实现一个栈类。
@@ -291,7 +297,7 @@ comments: true
private:
ListNode* stackTop; // 将头结点作为栈顶
int stkSize; // 栈的长度
public:
LinkedListStack() {
stackTop = nullptr;
@@ -338,29 +344,29 @@ comments: true
def __init__(self):
self.__peek = None
self.__size = 0
""" 获取栈的长度 """
def size(self):
return self.__size
""" 判断栈是否为空 """
def is_empty(self):
return not self.__peek
""" 入栈 """
def push(self, val):
node = ListNode(val)
node.next = self.__peek
self.__peek = node
self.__size += 1
""" 出栈 """
def pop(self):
num = self.peek()
self.__peek = self.__peek.next
self.__size -= 1
return num
""" 访问栈顶元素 """
def peek(self):
# 判空处理
@@ -372,43 +378,49 @@ comments: true
```go title="linkedlist_stack.go"
/* 基于链表实现的栈 */
type LinkedListStack struct {
type linkedListStack struct {
// 使用内置包 list 来实现栈
data *list.List
}
// NewLinkedListStack 初始化链表
func NewLinkedListStack() *LinkedListStack {
return &LinkedListStack{
// newLinkedListStack 初始化链表
func newLinkedListStack() *linkedListStack {
return &linkedListStack{
data: list.New(),
}
}
// Push 入栈
func (s *LinkedListStack) Push(value int) {
// push 入栈
func (s *linkedListStack) push(value int) {
s.data.PushBack(value)
}
// Pop 出栈
func (s *LinkedListStack) Pop() any {
if s.IsEmpty() {
// pop 出栈
func (s *linkedListStack) pop() any {
if s.isEmpty() {
return nil
}
e := s.data.Back()
s.data.Remove(e)
return e.Value
}
// Peek 访问栈顶元素
func (s *LinkedListStack) Peek() any {
if s.IsEmpty() {
// peek 访问栈顶元素
func (s *linkedListStack) peek() any {
if s.isEmpty() {
return nil
}
e := s.data.Back()
return e.Value
}
// Size 获取栈的长度
func (s *LinkedListStack) Size() int {
// size 获取栈的长度
func (s *linkedListStack) size() int {
return s.data.Len()
}
// IsEmpty 判断栈是否为空
func (s *LinkedListStack) IsEmpty() bool {
// isEmpty 判断栈是否为空
func (s *linkedListStack) isEmpty() bool {
return s.data.Len() == 0
}
```
@@ -420,21 +432,21 @@ comments: true
class LinkedListStack {
#stackPeek; // 将头结点作为栈顶
#stkSize = 0; // 栈的长度
constructor() {
this.#stackPeek = null;
}
/* 获取栈的长度 */
get size() {
return this.#stkSize;
}
/* 判断栈是否为空 */
isEmpty() {
return this.size == 0;
}
/* 入栈 */
push(num) {
const node = new ListNode(num);
@@ -442,7 +454,7 @@ comments: true
this.#stackPeek = node;
this.#stkSize++;
}
/* 出栈 */
pop() {
const num = this.peek();
@@ -453,7 +465,7 @@ comments: true
this.#stkSize--;
return num;
}
/* 访问栈顶元素 */
peek() {
if (!this.#stackPeek) {
@@ -461,7 +473,7 @@ comments: true
}
return this.#stackPeek.val;
}
/* 将链表转化为 Array 并返回 */
toArray() {
let node = this.#stackPeek;
@@ -482,21 +494,21 @@ comments: true
class LinkedListStack {
private stackPeek: ListNode | null; // 将头结点作为栈顶
private stkSize: number = 0; // 栈的长度
constructor() {
this.stackPeek = null;
}
/* 获取栈的长度 */
get size(): number {
return this.stkSize;
}
/* 判断栈是否为空 */
isEmpty(): boolean {
return this.size == 0;
}
/* 入栈 */
push(num: number): void {
const node = new ListNode(num);
@@ -504,7 +516,7 @@ comments: true
this.stackPeek = node;
this.stkSize++;
}
/* 出栈 */
pop(): number {
const num = this.peek();
@@ -515,7 +527,7 @@ comments: true
this.stkSize--;
return num;
}
/* 访问栈顶元素 */
peek(): number {
if (!this.stackPeek) {
@@ -523,7 +535,7 @@ comments: true
}
return this.stackPeek.val;
}
/* 将链表转化为 Array 并返回 */
toArray(): number[] {
let node = this.stackPeek;
@@ -540,7 +552,7 @@ comments: true
=== "C"
```c title="linkedlist_stack.c"
```
=== "C#"
@@ -591,6 +603,12 @@ comments: true
}
```
=== "Swift"
```swift title="linkedlist_stack.swift"
```
### 基于数组的实现
使用「数组」实现栈时，将数组的尾部当作栈顶，这样可以保证入栈与出栈操作的时间复杂度都为 $O(1)$ 。准确地说，由于入栈的元素可能是源源不断的，我们需要使用可以动态扩容的「列表」。
@@ -676,24 +694,24 @@ comments: true
class ArrayStack:
def __init__(self):
self.__stack = []
""" 获取栈的长度 """
def size(self):
return len(self.__stack)
""" 判断栈是否为空 """
def is_empty(self):
return self.__stack == []
""" 入栈 """
def push(self, item):
self.__stack.append(item)
""" 出栈 """
def pop(self):
assert not self.is_empty(), "栈为空"
return self.__stack.pop()
""" 访问栈顶元素 """
def peek(self):
assert not self.is_empty(), "栈为空"
@@ -704,41 +722,47 @@ comments: true
```go title="array_stack.go"
/* 基于数组实现的栈 */
type ArrayStack struct {
type arrayStack struct {
data []int // 数据
}
func NewArrayStack() *ArrayStack {
return &ArrayStack{
func newArrayStack() *arrayStack {
return &arrayStack{
// 设置栈的长度为 0，容量为 16
data: make([]int, 0, 16),
}
}
// Size 栈的长度
func (s *ArrayStack) Size() int {
// size 栈的长度
func (s *arrayStack) size() int {
return len(s.data)
}
// IsEmpty 栈是否为空
func (s *ArrayStack) IsEmpty() bool {
return s.Size() == 0
// isEmpty 栈是否为空
func (s *arrayStack) isEmpty() bool {
return s.size() == 0
}
// Push 入栈
func (s *ArrayStack) Push(v int) {
// push 入栈
func (s *arrayStack) push(v int) {
// 切片会自动扩容
s.data = append(s.data, v)
}
// Pop 出栈
func (s *ArrayStack) Pop() any {
// pop 出栈
func (s *arrayStack) pop() any {
// 弹出栈前，先判断是否为空
if s.IsEmpty() {
if s.isEmpty() {
return nil
}
val := s.Peek()
val := s.peek()
s.data = s.data[:len(s.data)-1]
return val
}
// Peek 获取栈顶元素
func (s *ArrayStack) Peek() any {
if s.IsEmpty() {
// peek 获取栈顶元素
func (s *arrayStack) peek() any {
if s.isEmpty() {
return nil
}
val := s.data[len(s.data)-1]
@@ -821,7 +845,7 @@ comments: true
=== "C"
```c title="array_stack.c"
```
=== "C#"
@@ -870,11 +894,17 @@ comments: true
}
```
=== "Swift"
```swift title="array_stack.swift"
```
!!! tip
某些语言并未专门提供栈类，但我们可以直接把该语言的「数组」或「链表」看作栈来使用，并通过“脑补”来屏蔽无关操作，而无需像上述代码去特意包装一层。
## 栈典型应用
- **浏览器中的后退与前进、软件中的撤销与反撤销。** 每当我们打开新的网页，浏览器就讲上一个网页执行入栈，这样我们就可以通过「后退」操作来回到上一页面，后退操作实际上是在执行出栈。如果要同时支持后退和前进，那么则需要两个栈来配合实现。
- **程序内存管理。** 每当调用函数时，系统就会在栈顶添加一个栈帧，用来记录函数的上下文信息。在递归函数中，向下递推会不断执行入栈，向上回溯阶段时出栈。
- **浏览器中的后退与前进、软件中的撤销与反撤销**。每当我们打开新的网页，浏览器就讲上一个网页执行入栈，这样我们就可以通过「后退」操作来回到上一页面，后退操作实际上是在执行出栈。如果要同时支持后退和前进，那么则需要两个栈来配合实现。
- **程序内存管理**。每当调用函数时，系统就会在栈顶添加一个栈帧，用来记录函数的上下文信息。在递归函数中，向下递推会不断执行入栈，向上回溯阶段时出栈。
docs/chapter_tree/avl_tree.md
+217 -16
View File
@@ -60,7 +60,13 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
=== "Go"
```go title="avl_tree.go"
/* AVL 树结点类 */
type TreeNode struct {
Val int // 结点值
Height int // 结点高度
Left *TreeNode // 左子结点引用
Right *TreeNode // 右子结点引用
}
```
=== "JavaScript"
@@ -94,6 +100,12 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
}
```
=== "Swift"
```swift title="avl_tree.swift"
```
「结点高度」是最远叶结点到该结点的距离，即走过的「边」的数量。需要特别注意，**叶结点的高度为 0 ，空结点的高度为 -1** 。我们封装两个工具函数，分别用于获取与更新结点的高度。
=== "Java"
@@ -122,14 +134,14 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
```python title="avl_tree.py"
""" 获取结点高度 """
def height(self, node: typing.Optional[TreeNode]) -> int:
def height(self, node: Optional[TreeNode]) -> int:
# 空结点高度为 -1 ，叶结点高度为 0
if node is not None:
return node.height
return -1
""" 更新结点高度 """
def __update_height(self, node: TreeNode):
def __update_height(self, node: Optional[TreeNode]):
# 结点高度等于最高子树高度 + 1
node.height = max([self.height(node.left), self.height(node.right)]) + 1
```
@@ -137,7 +149,26 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
=== "Go"
```go title="avl_tree.go"
/* 获取结点高度 */
func height(node *TreeNode) int {
// 空结点高度为 -1 ，叶结点高度为 0
if node != nil {
return node.Height
}
return -1
}
/* 更新结点高度 */
func updateHeight(node *TreeNode) {
lh := height(node.Left)
rh := height(node.Right)
// 结点高度等于最高子树高度 + 1
if lh > rh {
node.Height = lh + 1
} else {
node.Height = rh + 1
}
}
```
=== "JavaScript"
@@ -176,6 +207,12 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
}
```
=== "Swift"
```swift title="avl_tree.swift"
```
### 结点平衡因子
结点的「平衡因子 Balance Factor」是 **结点的左子树高度减去右子树高度**，并定义空结点的平衡因子为 0 。同样地，我们将获取结点平衡因子封装成函数，以便后续使用。
@@ -202,7 +239,7 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
```python title="avl_tree.py"
""" 获取平衡因子 """
def balance_factor(self, node: TreeNode) -> int:
def balance_factor(self, node: Optional[TreeNode]) -> int:
# 空结点平衡因子为 0
if node is None:
return 0
@@ -213,7 +250,15 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
=== "Go"
```go title="avl_tree.go"
/* 获取平衡因子 */
func balanceFactor(node *TreeNode) int {
// 空结点平衡因子为 0
if node == nil {
return 0
}
// 结点平衡因子 = 左子树高度 - 右子树高度
return height(node.Left) - height(node.Right)
}
```
=== "JavaScript"
@@ -247,13 +292,19 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
}
```
=== "Swift"
```swift title="avl_tree.swift"
```
!!! note
设平衡因子为 $f$ ，则一棵 AVL 树的任意结点的平衡因子皆满足 $-1 \le f \le 1$ 。
## AVL 树旋转
AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影响二叉树中序遍历序列的前提下，使失衡结点重新恢复平衡。** 换言之，旋转操作既可以使树保持为「二叉搜索树」，也可以使树重新恢复为「平衡二叉树」。
AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影响二叉树中序遍历序列的前提下，使失衡结点重新恢复平衡**。换言之，旋转操作既可以使树保持为「二叉搜索树」，也可以使树重新恢复为「平衡二叉树」。
我们将平衡因子的绝对值 $> 1$ 的结点称为「失衡结点」。根据结点的失衡情况，旋转操作分为 **右旋、左旋、先右旋后左旋、先左旋后右旋**，接下来我们来一起来看看它们是如何操作的。
@@ -304,7 +355,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
```python title="avl_tree.py"
""" 右旋操作 """
def __right_rotate(self, node: TreeNode) -> TreeNode:
def __right_rotate(self, node: Optional[TreeNode]) -> TreeNode:
child = node.left
grand_child = child.right
# 以 child 为原点，将 node 向右旋转
@@ -320,7 +371,19 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
=== "Go"
```go title="avl_tree.go"
/* 右旋操作 */
func rightRotate(node *TreeNode) *TreeNode {
child := node.Left
grandChild := child.Right
// 以 child 为原点，将 node 向右旋转
child.Right = node
node.Left = grandChild
// 更新结点高度
updateHeight(node)
updateHeight(child)
// 返回旋转后子树的根节点
return child
}
```
=== "JavaScript"
@@ -361,6 +424,12 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
```
=== "Swift"
```swift title="avl_tree.swift"
```
### Case 2 - 左旋
类似地，如果将取上述失衡二叉树的“镜像”，那么则需要「左旋」操作。
@@ -401,7 +470,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
```python title="avl_tree.py"
""" 左旋操作 """
def __left_rotate(self, node: TreeNode) -> TreeNode:
def __left_rotate(self, node: Optional[TreeNode]) -> TreeNode:
child = node.right
grand_child = child.left
# 以 child 为原点，将 node 向左旋转
@@ -417,7 +486,19 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
=== "Go"
```go title="avl_tree.go"
/* 左旋操作 */
func leftRotate(node *TreeNode) *TreeNode {
child := node.Right
grandChild := child.Left
// 以 child 为原点，将 node 向左旋转
child.Left = node
node.Right = grandChild
// 更新结点高度
updateHeight(node)
updateHeight(child)
// 返回旋转后子树的根节点
return child
}
```
=== "JavaScript"
@@ -457,6 +538,12 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
}
```
=== "Swift"
```swift title="avl_tree.swift"
```
### Case 3 - 先左后右
对于下图的失衡结点 3 ，**单一使用左旋或右旋都无法使子树恢复平衡**，此时需要「先左旋后右旋」，即先对 `child` 执行「左旋」，再对 `node` 执行「右旋」。
@@ -534,7 +621,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
```python title="avl_tree.py"
""" 执行旋转操作，使该子树重新恢复平衡 """
def __rotate(self, node: TreeNode) -> TreeNode:
def __rotate(self, node: Optional[TreeNode]) -> TreeNode:
# 获取结点 node 的平衡因子
balance_factor = self.balance_factor(node)
# 左偏树
@@ -562,7 +649,36 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
=== "Go"
```go title="avl_tree.go"
/* 执行旋转操作，使该子树重新恢复平衡 */
func rotate(node *TreeNode) *TreeNode {
// 获取结点 node 的平衡因子
// Go 推荐短变量，这里 bf 指代 balanceFactor
bf := balanceFactor(node)
// 左偏树
if bf > 1 {
if balanceFactor(node.Left) >= 0 {
// 右旋
return rightRotate(node)
} else {
// 先左旋后右旋
node.Left = leftRotate(node.Left)
return rightRotate(node)
}
}
// 右偏树
if bf < -1 {
if balanceFactor(node.Right) <= 0 {
// 左旋
return leftRotate(node)
} else {
// 先右旋后左旋
node.Right = rightRotate(node.Right)
return leftRotate(node)
}
}
// 平衡树，无需旋转，直接返回
return node
}
```
=== "JavaScript"
@@ -626,6 +742,12 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
}
```
=== "Swift"
```swift title="avl_tree.swift"
```
## AVL 树常用操作
### 插入结点
@@ -674,7 +796,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
return self.root
""" 递归插入结点（辅助函数）"""
def __insert_helper(self, node: typing.Optional[TreeNode], val: int) -> TreeNode:
def __insert_helper(self, node: Optional[TreeNode], val: int) -> TreeNode:
if node is None:
return TreeNode(val)
# 1. 查找插入位置，并插入结点
@@ -694,7 +816,32 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
=== "Go"
```go title="avl_tree.go"
/* 插入结点 */
func (t *avlTree) insert(val int) *TreeNode {
t.root = insertHelper(t.root, val)
return t.root
}
/* 递归插入结点（辅助函数） */
func insertHelper(node *TreeNode, val int) *TreeNode {
if node == nil {
return NewTreeNode(val)
}
/* 1. 查找插入位置，并插入结点 */
if val < node.Val {
node.Left = insertHelper(node.Left, val)
} else if val > node.Val {
node.Right = insertHelper(node.Right, val)
} else {
// 重复结点不插入，直接返回
return node
}
// 更新结点高度
updateHeight(node)
/* 2. 执行旋转操作，使该子树重新恢复平衡 */
node = rotate(node)
// 返回子树的根节点
return node
}
```
=== "JavaScript"
@@ -744,6 +891,12 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
}
```
=== "Swift"
```swift title="avl_tree.swift"
```
### 删除结点
「AVL 树」删除结点操作与「二叉搜索树」删除结点操作总体相同。类似地，**在删除结点后，也需要从底至顶地执行旋转操作，使所有失衡结点恢复平衡**。
@@ -804,7 +957,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
return root
""" 递归删除结点（辅助函数） """
def __remove_helper(self, node: typing.Optional[TreeNode], val: int) -> typing.Optional[TreeNode]:
def __remove_helper(self, node: Optional[TreeNode], val: int) -> Optional[TreeNode]:
if node is None:
return None
# 1. 查找结点，并删除之
@@ -834,7 +987,49 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
=== "Go"
```go title="avl_tree.go"
/* 删除结点 */
func (t *avlTree) remove(val int) *TreeNode {
root := removeHelper(t.root, val)
return root
}
/* 递归删除结点（辅助函数） */
func removeHelper(node *TreeNode, val int) *TreeNode {
if node == nil {
return nil
}
/* 1. 查找结点，并删除之 */
if val < node.Val {
node.Left = removeHelper(node.Left, val)
} else if val > node.Val {
node.Right = removeHelper(node.Right, val)
} else {
if node.Left == nil || node.Right == nil {
child := node.Left
if node.Right != nil {
child = node.Right
}
// 子结点数量 = 0 ，直接删除 node 并返回
if child == nil {
return nil
} else {
// 子结点数量 = 1 ，直接删除 node
node = child
}
} else {
// 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
temp := getInOrderNext(node.Right)
node.Right = removeHelper(node.Right, temp.Val)
node.Val = temp.Val
}
}
// 更新结点高度
updateHeight(node)
/* 2. 执行旋转操作，使该子树重新恢复平衡 */
node = rotate(node)
// 返回子树的根节点
return node
}
```
=== "JavaScript"
@@ -902,6 +1097,12 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
}
```
=== "Swift"
```swift title="avl_tree.swift"
```
### 查找结点
「AVL 树」的结点查找操作与「二叉搜索树」一致，在此不再赘述。
docs/chapter_tree/binary_search_tree.md
+29 -11
View File
@@ -83,7 +83,7 @@ comments: true
```python title="binary_search_tree.py"
""" 查找结点 """
def search(self, num: int) -> typing.Optional[TreeNode]:
def search(self, num: int) -> Optional[TreeNode]:
cur = self.root
# 循环查找，越过叶结点后跳出
while cur is not None:
@@ -103,7 +103,7 @@ comments: true
```go title="binary_search_tree.go"
/* 查找结点 */
func (bst *BinarySearchTree) Search(num int) *TreeNode {
func (bst *binarySearchTree) search(num int) *TreeNode {
node := bst.root
// 循环查找，越过叶结点后跳出
for node != nil {
@@ -192,6 +192,12 @@ comments: true
}
```
=== "Swift"
```swift title="binary_search_tree.swift"
```
### 插入结点
给定一个待插入元素 `num` ，为了保持二叉搜索树“左子树 < 根结点 < 右子树”的性质，插入操作分为两步：
@@ -259,7 +265,7 @@ comments: true
```python title="binary_search_tree.py"
""" 插入结点 """
def insert(self, num: int) -> typing.Optional[TreeNode]:
def insert(self, num: int) -> Optional[TreeNode]:
root = self.root
# 若树为空，直接提前返回
if root is None:
@@ -293,7 +299,7 @@ comments: true
```go title="binary_search_tree.go"
/* 插入结点 */
func (bst *BinarySearchTree) Insert(num int) *TreeNode {
func (bst *binarySearchTree) insert(num int) *TreeNode {
cur := bst.root
// 若树为空，直接提前返回
if cur == nil {
@@ -422,6 +428,12 @@ comments: true
}
```
=== "Swift"
```swift title="binary_search_tree.swift"
```
为了插入结点，需要借助 **辅助结点 `prev`** 保存上一轮循环的结点，这样在遍历到 $\text{null}$ 时，我们也可以获取到其父结点，从而完成结点插入操作。
与查找结点相同，插入结点使用 $O(\log n)$ 时间。
@@ -430,15 +442,15 @@ comments: true
与插入结点一样，我们需要在删除操作后维持二叉搜索树的“左子树 < 根结点 < 右子树”的性质。首先，我们需要在二叉树中执行查找操作，获取待删除结点。接下来，根据待删除结点的子结点数量，删除操作需要分为三种情况：
**待删除结点的子结点数量 $= 0$ 。** 表明待删除结点是叶结点，直接删除即可。
**待删除结点的子结点数量 $= 0$ **。表明待删除结点是叶结点，直接删除即可。
![bst_remove_case1](binary_search_tree.assets/bst_remove_case1.png)
**待删除结点的子结点数量 $= 1$ 。** 将待删除结点替换为其子结点。
**待删除结点的子结点数量 $= 1$ **。将待删除结点替换为其子结点。
![bst_remove_case2](binary_search_tree.assets/bst_remove_case2.png)
**待删除结点的子结点数量 $= 2$ 。** 删除操作分为三步：
**待删除结点的子结点数量 $= 2$ **。删除操作分为三步：
1. 找到待删除结点在 **中序遍历序列** 中的下一个结点，记为 `nex` ；
2. 在树中递归删除结点 `nex` ；
@@ -548,7 +560,7 @@ comments: true
```python title="binary_search_tree.py"
""" 删除结点 """
def remove(self, num: int) -> typing.Optional[TreeNode]:
def remove(self, num: int) -> Optional[TreeNode]:
root = self.root
# 若树为空，直接提前返回
if root is None:
@@ -597,7 +609,7 @@ comments: true
```go title="binary_search_tree.go"
/* 删除结点 */
func (bst *BinarySearchTree) Remove(num int) *TreeNode {
func (bst *binarySearchTree) remove(num int) *TreeNode {
cur := bst.root
// 若树为空，直接提前返回
if cur == nil {
@@ -641,10 +653,10 @@ comments: true
// 子结点数为 2
} else {
// 获取中序遍历中待删除结点 cur 的下一个结点
next := bst.GetInOrderNext(cur)
next := bst.getInOrderNext(cur)
temp := next.Val
// 递归删除结点 next
bst.Remove(next.Val)
bst.remove(next.Val)
// 将 next 的值复制给 cur
cur.Val = temp
}
@@ -808,6 +820,12 @@ comments: true
}
```
=== "Swift"
```swift title="binary_search_tree.swift"
```
## 二叉搜索树的优势
假设给定 $n$ 个数字，最常用的存储方式是「数组」，那么对于这串乱序的数字，常见操作的效率为：
docs/chapter_tree/binary_tree.assets/binary_tree_add_remove.png
BIN
View File
Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 76 KiB

After

Width:  |  Height:  |  Size: 78 KiB

docs/chapter_tree/binary_tree.md
+27 -3
View File
@@ -106,6 +106,12 @@ comments: true
}
```
=== "Swift"
```swift title=""
```
结点的两个指针分别指向「左子结点 Left Child Node」和「右子结点 Right Child Node」，并且称该结点为两个子结点的「父结点 Parent Node」。给定二叉树某结点，将左子结点以下的树称为该结点的「左子树 Left Subtree」，右子树同理。
除了叶结点外，每个结点都有子结点和子树。例如，若将上图的「结点 2」看作父结点，那么其左子结点和右子结点分别为「结点 4」和「结点 5」，左子树和右子树分别为「结点 4 以下的树」和「结点 5 以下的树」。
@@ -137,7 +143,7 @@ comments: true
## 二叉树基本操作
**初始化二叉树。** 与链表类似，先初始化结点，再构建引用指向（即指针）。
**初始化二叉树**。与链表类似，先初始化结点，再构建引用指向（即指针）。
=== "Java"
@@ -263,7 +269,13 @@ comments: true
n2.right = n5;
```
**插入与删除结点。** 与链表类似，插入与删除结点都可以通过修改指针实现。
=== "Swift"
```swift title="binary_tree.swift"
```
**插入与删除结点**。与链表类似，插入与删除结点都可以通过修改指针实现。
![binary_tree_add_remove](binary_tree.assets/binary_tree_add_remove.png)
@@ -358,6 +370,12 @@ comments: true
n1.left = n2;
```
=== "Swift"
```swift title="binary_tree.swift"
```
!!! note
插入结点会改变二叉树的原有逻辑结构，删除结点往往意味着删除了该结点的所有子树。因此，二叉树中的插入与删除一般都是由一套操作配合完成的，这样才能实现有意义的操作。
@@ -495,9 +513,15 @@ comments: true
int?[] tree = { 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 };
```
=== "Swift"
```swift title=""
```
![array_representation_with_empty](binary_tree.assets/array_representation_with_empty.png)
回顾「完全二叉树」的满足条件，其只有最底层有空结点，并且最底层的结点尽量靠左，因而所有空结点都一定出现在层序遍历序列的末尾。**因为我们先验地确定了空位的位置，所以在使用数组表示完全二叉树时，可以省略存储“空位”**。“便于使用数组表示”也是完全二叉树受欢迎的原因之一。
回顾「完全二叉树」的定义，其只有最底层有空结点，并且最底层的结点尽量靠左，因而所有空结点都一定出现在层序遍历序列的末尾。**因为我们先验地确定了空位的位置，所以在使用数组表示完全二叉树时，可以省略存储“空位”**。因此，完全二叉树非常适合使用数组来表示。
![array_representation_complete_binary_tree](binary_tree.assets/array_representation_complete_binary_tree.png)
docs/chapter_tree/binary_tree_traversal.md
+16 -4
View File
@@ -66,7 +66,7 @@ comments: true
```python title="binary_tree_bfs.py"
""" 层序遍历 """
def hier_order(root: TreeNode):
def hier_order(root: Optional[TreeNode]):
# 初始化队列，加入根结点
queue = collections.deque()
queue.append(root)
@@ -185,6 +185,12 @@ comments: true
```
=== "Swift"
```swift title="binary_tree_bfs.swift"
```
## 前序、中序、后序遍历
相对地，前、中、后序遍历皆属于「深度优先遍历 Depth-First Traversal」，其体现着一种“先走到尽头，再回头继续”的回溯遍历方式。
@@ -271,7 +277,7 @@ comments: true
```python title="binary_tree_dfs.py"
""" 前序遍历 """
def pre_order(root: typing.Optional[TreeNode]):
def pre_order(root: Optional[TreeNode]):
if root is None:
return
# 访问优先级：根结点 -> 左子树 -> 右子树
@@ -280,7 +286,7 @@ comments: true
pre_order(root=root.right)
""" 中序遍历 """
def in_order(root: typing.Optional[TreeNode]):
def in_order(root: Optional[TreeNode]):
if root is None:
return
# 访问优先级：左子树 -> 根结点 -> 右子树
@@ -289,7 +295,7 @@ comments: true
in_order(root=root.right)
""" 后序遍历 """
def post_order(root: typing.Optional[TreeNode]):
def post_order(root: Optional[TreeNode]):
if root is None:
return
# 访问优先级：左子树 -> 右子树 -> 根结点
@@ -443,6 +449,12 @@ comments: true
}
```
=== "Swift"
```swift title="binary_tree_dfs.swift"
```
!!! note
使用循环一样可以实现前、中、后序遍历，但代码相对繁琐，有兴趣的同学可以自行实现。