mirror of
https://github.com/krahets/hello-algo.git
synced 2026-08-13 20:20:58 +00:00
Merge branch 'master' into master
This commit is contained in:
Yudong Jin
@@ -14,7 +14,7 @@ comments: true
|
||||
|
||||
观察上图，我们发现 **数组首元素的索引为 $0$** 。你可能会想，这并不符合日常习惯，首个元素的索引为什么不是 $1$ 呢，这不是更加自然吗？我认同你的想法，但请先记住这个设定，后面讲内存地址计算时，我会尝试解答这个问题。
|
||||
|
||||
**数组有多种初始化写法。** 根据实际需要，选代码最短的那一种就好。
|
||||
**数组有多种初始化写法**。根据实际需要，选代码最短的那一种就好。
|
||||
|
||||
=== "Java"
|
||||
|
||||
@@ -43,7 +43,12 @@ comments: true
|
||||
=== "Go"
|
||||
|
||||
```go title="array.go"
|
||||
|
||||
/* 初始化数组 */
|
||||
var arr [5]int
|
||||
// 在 Go 中，指定长度时（[5]int）为数组，不指定长度时（[]int）为切片
|
||||
// 由于 Go 的数组被设计为在编译期确定长度，因此只能使用常量来指定长度
|
||||
// 为了方便实现扩容 extend() 方法，以下将切片（Slice）看作数组（Array）
|
||||
nums := []int{1, 3, 2, 5, 4}
|
||||
```
|
||||
|
||||
=== "JavaScript"
|
||||
@@ -76,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]
|
||||
```
|
||||
|
||||
## 数组优点
|
||||
|
||||
**在数组中访问元素非常高效。** 这是因为在数组中，计算元素的内存地址非常容易。给定数组首个元素的地址、和一个元素的索引，利用以下公式可以直接计算得到该元素的内存地址，从而直接访问此元素。
|
||||
**在数组中访问元素非常高效**。这是因为在数组中，计算元素的内存地址非常容易。给定数组首个元素的地址、和一个元素的索引，利用以下公式可以直接计算得到该元素的内存地址，从而直接访问此元素。
|
||||
|
||||
|
||||
|
||||
@@ -133,7 +146,14 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
|
||||
=== "Go"
|
||||
|
||||
```go title="array.go"
|
||||
|
||||
/* 随机返回一个数组元素 */
|
||||
func randomAccess(nums []int) (randomNum int) {
|
||||
// 在区间 [0, nums.length) 中随机抽取一个数字
|
||||
randomIndex := rand.Intn(len(nums))
|
||||
// 获取并返回随机元素
|
||||
randomNum = nums[randomIndex]
|
||||
return
|
||||
}
|
||||
```
|
||||
|
||||
=== "JavaScript"
|
||||
@@ -181,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"
|
||||
|
||||
@@ -236,7 +269,17 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
|
||||
=== "Go"
|
||||
|
||||
```go title="array.go"
|
||||
|
||||
/* 扩展数组长度 */
|
||||
func extend(nums []int, enlarge int) []int {
|
||||
// 初始化一个扩展长度后的数组
|
||||
res := make([]int, len(nums)+enlarge)
|
||||
// 将原数组中的所有元素复制到新数组
|
||||
for i, num := range nums {
|
||||
res[i] = num
|
||||
}
|
||||
// 返回扩展后的新数组
|
||||
return res
|
||||
}
|
||||
```
|
||||
|
||||
=== "JavaScript"
|
||||
@@ -295,11 +338,27 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
|
||||
}
|
||||
```
|
||||
|
||||
**数组中插入或删除元素效率低下。** 假设我们想要在数组中间某位置插入一个元素，由于数组元素在内存中是“紧挨着的”，它们之间没有空间再放任何数据。因此，我们不得不将此索引之后的所有元素都向后移动一位，然后再把元素赋值给该索引。删除元素也是类似，需要把此索引之后的元素都向前移动一位。总体看有以下缺点：
|
||||
=== "Swift"
|
||||
|
||||
- **时间复杂度高：** 数组的插入和删除的平均时间复杂度均为 $O(N)$ ，其中 $N$ 为数组长度。
|
||||
- **丢失元素：** 由于数组的长度不可变，因此在插入元素后，超出数组长度范围的元素会被丢失。
|
||||
- **内存浪费：** 我们一般会初始化一个比较长的数组，只用前面一部分，这样在插入数据时，丢失的末尾元素都是我们不关心的，但这样做同时也会造成内存空间的浪费。
|
||||
```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$ 为数组长度。
|
||||
- **丢失元素**：由于数组的长度不可变，因此在插入元素后，超出数组长度范围的元素会被丢失。
|
||||
- **内存浪费**：我们一般会初始化一个比较长的数组，只用前面一部分，这样在插入数据时，丢失的末尾元素都是我们不关心的，但这样做同时也会造成内存空间的浪费。
|
||||
|
||||
|
||||
|
||||
@@ -370,7 +429,23 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
|
||||
=== "Go"
|
||||
|
||||
```go title="array.go"
|
||||
|
||||
/* 在数组的索引 index 处插入元素 num */
|
||||
func insert(nums []int, num int, index int) {
|
||||
// 把索引 index 以及之后的所有元素向后移动一位
|
||||
for i := len(nums) - 1; i > index; i-- {
|
||||
nums[i] = nums[i-1]
|
||||
}
|
||||
// 将 num 赋给 index 处元素
|
||||
nums[index] = num
|
||||
}
|
||||
|
||||
/* 删除索引 index 处元素 */
|
||||
func remove(nums []int, index int) {
|
||||
// 把索引 index 之后的所有元素向前移动一位
|
||||
for i := index; i < len(nums)-1; i++ {
|
||||
nums[i] = nums[i+1]
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
=== "JavaScript"
|
||||
@@ -448,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"
|
||||
|
||||
@@ -499,7 +597,18 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
|
||||
=== "Go"
|
||||
|
||||
```go title="array.go"
|
||||
|
||||
/* 遍历数组 */
|
||||
func traverse(nums []int) {
|
||||
count := 0
|
||||
// 通过索引遍历数组
|
||||
for i := 0; i < len(nums); i++ {
|
||||
count++
|
||||
}
|
||||
// 直接遍历数组
|
||||
for range nums {
|
||||
count++
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
=== "JavaScript"
|
||||
@@ -562,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"
|
||||
|
||||
@@ -604,7 +730,17 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
|
||||
=== "Go"
|
||||
|
||||
```go title="array.go"
|
||||
|
||||
/* 在数组中查找指定元素 */
|
||||
func find(nums []int, target int) (index int) {
|
||||
index = -1
|
||||
for i := 0; i < len(nums); i++ {
|
||||
if nums[i] == target {
|
||||
index = i
|
||||
break
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
```
|
||||
|
||||
=== "JavaScript"
|
||||
@@ -654,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
|
||||
}
|
||||
```
|
||||
|
||||
## 数组典型应用
|
||||
|
||||
**随机访问。** 如果我们想要随机抽取一些样本，那么可以用数组存储，并生成一个随机序列，根据索引实现样本的随机抽取。
|
||||
**随机访问**。如果我们想要随机抽取一些样本，那么可以用数组存储，并生成一个随机序列，根据索引实现样本的随机抽取。
|
||||
|
||||
**二分查找。** 例如前文查字典的例子，我们可以将字典中的所有字按照拼音顺序存储在数组中，然后使用与日常查纸质字典相同的“翻开中间，排除一半”的方式，来实现一个查电子字典的算法。
|
||||
**二分查找**。例如前文查字典的例子，我们可以将字典中的所有字按照拼音顺序存储在数组中，然后使用与日常查纸质字典相同的“翻开中间，排除一半”的方式，来实现一个查电子字典的算法。
|
||||
|
||||
**深度学习。** 神经网络中大量使用了向量、矩阵、张量之间的线性代数运算，这些数据都是以数组的形式构建的。数组是神经网络编程中最常使用的数据结构。
|
||||
**深度学习**。神经网络中大量使用了向量、矩阵、张量之间的线性代数运算，这些数据都是以数组的形式构建的。数组是神经网络编程中最常使用的数据结构。
|
||||
|
||||
@@ -51,7 +51,19 @@ comments: true
|
||||
=== "Go"
|
||||
|
||||
```go title=""
|
||||
|
||||
/* 链表结点结构体 */
|
||||
type ListNode struct {
|
||||
Val int // 结点值
|
||||
Next *ListNode // 指向下一结点的指针（引用）
|
||||
}
|
||||
|
||||
// NewListNode 构造函数，创建一个新的链表
|
||||
func NewListNode(val int) *ListNode {
|
||||
return &ListNode{
|
||||
Val: val,
|
||||
Next: nil,
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
=== "JavaScript"
|
||||
@@ -100,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
|
||||
|
||||
@@ -110,7 +136,7 @@ comments: true
|
||||
|
||||
=== "Java"
|
||||
|
||||
```java title=""
|
||||
```java title="linked_list.java"
|
||||
/* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
|
||||
// 初始化各个结点
|
||||
ListNode n0 = new ListNode(1);
|
||||
@@ -127,7 +153,7 @@ comments: true
|
||||
|
||||
=== "C++"
|
||||
|
||||
```cpp title=""
|
||||
```cpp title="linked_list.cpp"
|
||||
/* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
|
||||
// 初始化各个结点
|
||||
ListNode* n0 = new ListNode(1);
|
||||
@@ -144,7 +170,7 @@ comments: true
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python title=""
|
||||
```python title="linked_list.py"
|
||||
""" 初始化链表 1 -> 3 -> 2 -> 5 -> 4 """
|
||||
# 初始化各个结点
|
||||
n0 = ListNode(1)
|
||||
@@ -161,13 +187,25 @@ comments: true
|
||||
|
||||
=== "Go"
|
||||
|
||||
```go title=""
|
||||
|
||||
```go title="linked_list.go"
|
||||
/* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
|
||||
// 初始化各个结点
|
||||
n0 := NewListNode(1)
|
||||
n1 := NewListNode(3)
|
||||
n2 := NewListNode(2)
|
||||
n3 := NewListNode(5)
|
||||
n4 := NewListNode(4)
|
||||
|
||||
// 构建引用指向
|
||||
n0.Next = n1
|
||||
n1.Next = n2
|
||||
n2.Next = n3
|
||||
n3.Next = n4
|
||||
```
|
||||
|
||||
=== "JavaScript"
|
||||
|
||||
```js title=""
|
||||
```js title="linked_list.js"
|
||||
/* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
|
||||
// 初始化各个结点
|
||||
const n0 = new ListNode(1);
|
||||
@@ -184,7 +222,7 @@ comments: true
|
||||
|
||||
=== "TypeScript"
|
||||
|
||||
```typescript title=""
|
||||
```typescript title="linked_list.ts"
|
||||
/* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
|
||||
// 初始化各个结点
|
||||
const n0 = new ListNode(1);
|
||||
@@ -201,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);
|
||||
@@ -222,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)$ ，相比数组的插入操作高效很多。在链表中删除某个结点也很方便，只需要改变一个结点指针即可。
|
||||
|
||||
|
||||
|
||||
@@ -232,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;
|
||||
@@ -253,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;
|
||||
@@ -269,12 +324,14 @@ comments: true
|
||||
ListNode* P = n0->next;
|
||||
ListNode* n1 = P->next;
|
||||
n0->next = n1;
|
||||
// 释放内存
|
||||
delete P;
|
||||
}
|
||||
```
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python title=""
|
||||
```python title="linked_list.py"
|
||||
""" 在链表的结点 n0 之后插入结点 P """
|
||||
def insert(n0, P):
|
||||
n1 = n0.next
|
||||
@@ -293,13 +350,29 @@ comments: true
|
||||
|
||||
=== "Go"
|
||||
|
||||
```go title=""
|
||||
```go title="linked_list.go"
|
||||
/* 在链表的结点 n0 之后插入结点 P */
|
||||
func insert(n0 *ListNode, P *ListNode) {
|
||||
n1 := n0.Next
|
||||
n0.Next = P
|
||||
P.Next = n1
|
||||
}
|
||||
|
||||
/* 删除链表的结点 n0 之后的首个结点 */
|
||||
func removeNode(n0 *ListNode) {
|
||||
if n0.Next == nil {
|
||||
return
|
||||
}
|
||||
// n0 -> P -> n1
|
||||
P := n0.Next
|
||||
n1 := P.Next
|
||||
n0.Next = n1
|
||||
}
|
||||
```
|
||||
|
||||
=== "JavaScript"
|
||||
|
||||
```js title=""
|
||||
```js title="linked_list.js"
|
||||
/* 在链表的结点 n0 之后插入结点 P */
|
||||
function insert(n0, P) {
|
||||
let n1 = n0.next;
|
||||
@@ -320,13 +393,14 @@ comments: true
|
||||
|
||||
=== "TypeScript"
|
||||
|
||||
```typescript title=""
|
||||
```typescript title="linked_list.ts"
|
||||
/* 在链表的结点 n0 之后插入结点 P */
|
||||
function insert(n0: ListNode, P: ListNode): void {
|
||||
const n1 = n0.next;
|
||||
n0.next = P;
|
||||
P.next = n1;
|
||||
}
|
||||
|
||||
/* 删除链表的结点 n0 之后的首个结点 */
|
||||
function remove(n0: ListNode): void {
|
||||
if (!n0.next) {
|
||||
@@ -341,13 +415,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)
|
||||
{
|
||||
@@ -368,19 +442,42 @@ 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++) {
|
||||
head = head.next;
|
||||
if (head == null)
|
||||
return null;
|
||||
head = head.next;
|
||||
}
|
||||
return head;
|
||||
}
|
||||
@@ -388,13 +485,13 @@ comments: true
|
||||
|
||||
=== "C++"
|
||||
|
||||
```cpp title=""
|
||||
```cpp title="linked_list.cpp"
|
||||
/* 访问链表中索引为 index 的结点 */
|
||||
ListNode* access(ListNode* head, int index) {
|
||||
for (int i = 0; i < index; i++) {
|
||||
head = head->next;
|
||||
if (head == nullptr)
|
||||
return nullptr;
|
||||
head = head->next;
|
||||
}
|
||||
return head;
|
||||
}
|
||||
@@ -402,25 +499,34 @@ comments: true
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python title=""
|
||||
```python title="linked_list.py"
|
||||
""" 访问链表中索引为 index 的结点 """
|
||||
def access(head, index):
|
||||
for _ in range(index):
|
||||
head = head.next
|
||||
if not head:
|
||||
return None
|
||||
head = head.next
|
||||
return head
|
||||
```
|
||||
|
||||
=== "Go"
|
||||
|
||||
```go title=""
|
||||
|
||||
```go title="linked_list.go"
|
||||
/* 访问链表中索引为 index 的结点 */
|
||||
func access(head *ListNode, index int) *ListNode {
|
||||
for i := 0; i < index; i++ {
|
||||
if head == nil {
|
||||
return nil
|
||||
}
|
||||
head = head.Next
|
||||
}
|
||||
return head
|
||||
}
|
||||
```
|
||||
|
||||
=== "JavaScript"
|
||||
|
||||
```js title=""
|
||||
```js title="linked_list.js"
|
||||
/* 访问链表中索引为 index 的结点 */
|
||||
function access(head, index) {
|
||||
for (let i = 0; i < index; i++) {
|
||||
@@ -434,7 +540,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++) {
|
||||
@@ -449,35 +555,51 @@ 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)
|
||||
{
|
||||
for (int i = 0; i < index; i++)
|
||||
{
|
||||
head = head.next;
|
||||
if (head == null)
|
||||
return null;
|
||||
head = head.next;
|
||||
}
|
||||
return head;
|
||||
}
|
||||
```
|
||||
|
||||
**链表的内存占用多。** 链表以结点为单位，每个结点除了保存值外，还需额外保存指针（引用）。这意味着同样数据量下，链表比数组需要占用更多内存空间。
|
||||
=== "Swift"
|
||||
|
||||
```swift title="linked_list.swift"
|
||||
/* 访问链表中索引为 index 的结点 */
|
||||
func access(head: ListNode, index: Int) -> ListNode? {
|
||||
var head: ListNode? = head
|
||||
for _ in 0 ..< index {
|
||||
if head == nil {
|
||||
return nil
|
||||
}
|
||||
head = head?.next
|
||||
}
|
||||
return head
|
||||
}
|
||||
```
|
||||
|
||||
**链表的内存占用多**。链表以结点为单位，每个结点除了保存值外，还需额外保存指针（引用）。这意味着同样数据量下，链表比数组需要占用更多内存空间。
|
||||
|
||||
## 链表常用操作
|
||||
|
||||
**遍历链表查找。** 遍历链表，查找链表内值为 `target` 的结点，输出结点在链表中的索引。
|
||||
**遍历链表查找**。遍历链表，查找链表内值为 `target` 的结点，输出结点在链表中的索引。
|
||||
|
||||
=== "Java"
|
||||
|
||||
```java title=""
|
||||
```java title="linked_list.java"
|
||||
/* 在链表中查找值为 target 的首个结点 */
|
||||
int find(ListNode head, int target) {
|
||||
int index = 0;
|
||||
@@ -493,7 +615,7 @@ comments: true
|
||||
|
||||
=== "C++"
|
||||
|
||||
```cpp title=""
|
||||
```cpp title="linked_list.cpp"
|
||||
/* 在链表中查找值为 target 的首个结点 */
|
||||
int find(ListNode* head, int target) {
|
||||
int index = 0;
|
||||
@@ -509,7 +631,7 @@ comments: true
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python title=""
|
||||
```python title="linked_list.py"
|
||||
""" 在链表中查找值为 target 的首个结点 """
|
||||
def find(head, target):
|
||||
index = 0
|
||||
@@ -523,13 +645,24 @@ comments: true
|
||||
|
||||
=== "Go"
|
||||
|
||||
```go title=""
|
||||
|
||||
```go title="linked_list.go"
|
||||
/* 在链表中查找值为 target 的首个结点 */
|
||||
func find(head *ListNode, target int) int {
|
||||
index := 0
|
||||
for head != nil {
|
||||
if head.Val == target {
|
||||
return index
|
||||
}
|
||||
head = head.Next
|
||||
index++
|
||||
}
|
||||
return -1
|
||||
}
|
||||
```
|
||||
|
||||
=== "JavaScript"
|
||||
|
||||
```js title=""
|
||||
```js title="linked_list.js"
|
||||
/* 在链表中查找值为 target 的首个结点 */
|
||||
function find(head, target) {
|
||||
let index = 0;
|
||||
@@ -546,7 +679,7 @@ comments: true
|
||||
|
||||
=== "TypeScript"
|
||||
|
||||
```typescript title=""
|
||||
```typescript title="linked_list.ts"
|
||||
/* 在链表中查找值为 target 的首个结点 */
|
||||
function find(head: ListNode | null, target: number): number {
|
||||
let index = 0;
|
||||
@@ -563,13 +696,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)
|
||||
{
|
||||
@@ -585,13 +718,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"
|
||||
|
||||
@@ -631,7 +782,21 @@ comments: true
|
||||
=== "Go"
|
||||
|
||||
```go title=""
|
||||
|
||||
/* 双向链表结点结构体 */
|
||||
type DoublyListNode struct {
|
||||
Val int // 结点值
|
||||
Next *DoublyListNode // 指向后继结点的指针（引用）
|
||||
Prev *DoublyListNode // 指向前驱结点的指针（引用）
|
||||
}
|
||||
|
||||
// NewDoublyListNode 初始化
|
||||
func NewDoublyListNode(val int) *DoublyListNode {
|
||||
return &DoublyListNode{
|
||||
Val: val,
|
||||
Next: nil,
|
||||
Prev: nil,
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
=== "JavaScript"
|
||||
@@ -684,6 +849,21 @@ comments: true
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title=""
|
||||
/* 双向链表结点类 */
|
||||
class ListNode {
|
||||
var val: Int // 结点值
|
||||
var next: ListNode? // 指向后继结点的指针（引用）
|
||||
var prev: ListNode? // 指向前驱结点的指针（引用）
|
||||
|
||||
init(x: Int) { // 构造函数
|
||||
val = x
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
|
||||
<p align="center"> Fig. 常见链表类型 </p>
|
||||
|
||||
@@ -4,13 +4,13 @@ comments: true
|
||||
|
||||
# 列表
|
||||
|
||||
**由于长度不可变，数组的实用性大大降低。** 在很多情况下，我们事先并不知道会输入多少数据，这就为数组长度的选择带来了很大困难。长度选小了，需要在添加数据中频繁地扩容数组；长度选大了，又造成内存空间的浪费。
|
||||
**由于长度不可变，数组的实用性大大降低**。在很多情况下，我们事先并不知道会输入多少数据，这就为数组长度的选择带来了很大困难。长度选小了，需要在添加数据中频繁地扩容数组；长度选大了，又造成内存空间的浪费。
|
||||
|
||||
为了解决此问题，诞生了一种被称为「列表 List」的数据结构。列表可以被理解为长度可变的数组，因此也常被称为「动态数组 Dynamic Array」。列表基于数组实现，继承了数组的优点，同时还可以在程序运行中实时扩容。在列表中，我们可以自由地添加元素，而不用担心超过容量限制。
|
||||
|
||||
## 列表常用操作
|
||||
|
||||
**初始化列表。** 我们通常会使用到“无初始值”和“有初始值”的两种初始化方法。
|
||||
**初始化列表**。我们通常会使用到“无初始值”和“有初始值”的两种初始化方法。
|
||||
|
||||
=== "Java"
|
||||
|
||||
@@ -91,7 +91,17 @@ comments: true
|
||||
List<int> list = numbers.ToList();
|
||||
```
|
||||
|
||||
**访问与更新元素。** 列表的底层数据结构是数组，因此可以在 $O(1)$ 时间内访问与更新元素，效率很高。
|
||||
=== "Swift"
|
||||
|
||||
```swift title="list.swift"
|
||||
/* 初始化列表 */
|
||||
// 无初始值
|
||||
let list1: [Int] = []
|
||||
// 有初始值
|
||||
var list = [1, 3, 2, 5, 4]
|
||||
```
|
||||
|
||||
**访问与更新元素**。列表的底层数据结构是数组，因此可以在 $O(1)$ 时间内访问与更新元素，效率很高。
|
||||
|
||||
=== "Java"
|
||||
|
||||
@@ -169,7 +179,17 @@ comments: true
|
||||
list[1] = 0; // 将索引 1 处的元素更新为 0
|
||||
```
|
||||
|
||||
**在列表中添加、插入、删除元素。** 相对于数组，列表可以自由地添加与删除元素。在列表尾部添加元素的时间复杂度为 $O(1)$ ，但是插入与删除元素的效率仍与数组一样低，时间复杂度为 $O(N)$ 。
|
||||
=== "Swift"
|
||||
|
||||
```swift title="list.swift"
|
||||
/* 访问元素 */
|
||||
let num = list[1] // 访问索引 1 处的元素
|
||||
|
||||
/* 更新元素 */
|
||||
list[1] = 0 // 将索引 1 处的元素更新为 0
|
||||
```
|
||||
|
||||
**在列表中添加、插入、删除元素**。相对于数组，列表可以自由地添加与删除元素。在列表尾部添加元素的时间复杂度为 $O(1)$ ，但是插入与删除元素的效率仍与数组一样低，时间复杂度为 $O(N)$ 。
|
||||
|
||||
=== "Java"
|
||||
|
||||
@@ -317,7 +337,27 @@ comments: true
|
||||
list.RemoveAt(3);
|
||||
```
|
||||
|
||||
**遍历列表。** 与数组一样，列表可以使用索引遍历，也可以使用 `for-each` 直接遍历。
|
||||
=== "Swift"
|
||||
|
||||
```swift title="list.swift"
|
||||
/* 清空列表 */
|
||||
list.removeAll()
|
||||
|
||||
/* 尾部添加元素 */
|
||||
list.append(1)
|
||||
list.append(3)
|
||||
list.append(2)
|
||||
list.append(5)
|
||||
list.append(4)
|
||||
|
||||
/* 中间插入元素 */
|
||||
list.insert(6, at: 3) // 在索引 3 处插入数字 6
|
||||
|
||||
/* 删除元素 */
|
||||
list.remove(at: 3) // 删除索引 3 处的元素
|
||||
```
|
||||
|
||||
**遍历列表**。与数组一样，列表可以使用索引遍历，也可以使用 `for-each` 直接遍历。
|
||||
|
||||
=== "Java"
|
||||
|
||||
@@ -437,7 +477,23 @@ comments: true
|
||||
}
|
||||
```
|
||||
|
||||
**拼接两个列表。** 再创建一个新列表 `list1` ，我们可以将其中一个列表拼接到另一个的尾部。
|
||||
=== "Swift"
|
||||
|
||||
```swift title="list.swift"
|
||||
/* 通过索引遍历列表 */
|
||||
var count = 0
|
||||
for _ in list.indices {
|
||||
count += 1
|
||||
}
|
||||
|
||||
/* 直接遍历列表元素 */
|
||||
count = 0
|
||||
for _ in list {
|
||||
count += 1
|
||||
}
|
||||
```
|
||||
|
||||
**拼接两个列表**。再创建一个新列表 `list1` ，我们可以将其中一个列表拼接到另一个的尾部。
|
||||
|
||||
=== "Java"
|
||||
|
||||
@@ -502,7 +558,15 @@ comments: true
|
||||
list.AddRange(list1); // 将列表 list1 拼接到 list 之后
|
||||
```
|
||||
|
||||
**排序列表。** 排序也是常用的方法之一，完成列表排序后，我们就可以使用在数组类算法题中经常考察的「二分查找」和「双指针」算法了。
|
||||
=== "Swift"
|
||||
|
||||
```swift title="list.swift"
|
||||
/* 拼接两个列表 */
|
||||
let list1 = [6, 8, 7, 10, 9]
|
||||
list.append(contentsOf: list1) // 将列表 list1 拼接到 list 之后
|
||||
```
|
||||
|
||||
**排序列表**。排序也是常用的方法之一，完成列表排序后，我们就可以使用在数组类算法题中经常考察的「二分查找」和「双指针」算法了。
|
||||
|
||||
=== "Java"
|
||||
|
||||
@@ -559,13 +623,20 @@ comments: true
|
||||
list.Sort(); // 排序后，列表元素从小到大排列
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="list.swift"
|
||||
/* 排序列表 */
|
||||
list.sort() // 排序后，列表元素从小到大排列
|
||||
```
|
||||
|
||||
## 列表简易实现 *
|
||||
|
||||
为了帮助加深对列表的理解，我们在此提供一个列表的简易版本的实现。需要关注三个核心点：
|
||||
|
||||
- **初始容量：** 选取一个合理的数组的初始容量 `initialCapacity` 。在本示例中，我们选择 10 作为初始容量。
|
||||
- **数量记录：** 需要声明一个变量 `size` ，用来记录列表当前有多少个元素，并随着元素插入与删除实时更新。根据此变量，可以定位列表的尾部，以及判断是否需要扩容。
|
||||
- **扩容机制：** 插入元素有可能导致超出列表容量，此时需要扩容列表，方法是建立一个更大的数组来替换当前数组。需要给定一个扩容倍数 `extendRatio` ，在本示例中，我们规定每次将数组扩容至之前的 2 倍。
|
||||
- **初始容量**：选取一个合理的数组的初始容量 `initialCapacity` 。在本示例中，我们选择 10 作为初始容量。
|
||||
- **数量记录**：需要声明一个变量 `size` ，用来记录列表当前有多少个元素，并随着元素插入与删除实时更新。根据此变量，可以定位列表的尾部，以及判断是否需要扩容。
|
||||
- **扩容机制**：插入元素有可能导致超出列表容量，此时需要扩容列表，方法是建立一个更大的数组来替换当前数组。需要给定一个扩容倍数 `extendRatio` ，在本示例中，我们规定每次将数组扩容至之前的 2 倍。
|
||||
|
||||
本示例是为了帮助读者对如何实现列表产生直观的认识。实际编程语言中，列表的实现远比以下代码复杂且标准，感兴趣的读者可以查阅源码学习。
|
||||
|
||||
@@ -828,7 +899,7 @@ comments: true
|
||||
|
||||
```go title="my_list.go"
|
||||
/* 列表类简易实现 */
|
||||
type MyList struct {
|
||||
type myList struct {
|
||||
numsCapacity int
|
||||
nums []int
|
||||
numsSize int
|
||||
@@ -836,8 +907,8 @@ comments: true
|
||||
}
|
||||
|
||||
/* 构造函数 */
|
||||
func newMyList() *MyList {
|
||||
return &MyList{
|
||||
func newMyList() *myList {
|
||||
return &myList{
|
||||
numsCapacity: 10, // 列表容量
|
||||
nums: make([]int, 10), // 数组（存储列表元素）
|
||||
numsSize: 0, // 列表长度（即当前元素数量）
|
||||
@@ -846,17 +917,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 +936,7 @@ comments: true
|
||||
}
|
||||
|
||||
/* 更新元素 */
|
||||
func (l *MyList) set(num, index int) {
|
||||
func (l *myList) set(num, index int) {
|
||||
if index >= l.numsSize {
|
||||
panic("索引越界")
|
||||
}
|
||||
@@ -873,7 +944,7 @@ comments: true
|
||||
}
|
||||
|
||||
/* 尾部添加元素 */
|
||||
func (l *MyList) add(num int) {
|
||||
func (l *myList) add(num int) {
|
||||
// 元素数量超出容量时，触发扩容机制
|
||||
if l.numsSize == l.numsCapacity {
|
||||
l.extendCapacity()
|
||||
@@ -884,7 +955,7 @@ comments: true
|
||||
}
|
||||
|
||||
/* 中间插入元素 */
|
||||
func (l *MyList) insert(num, index int) {
|
||||
func (l *myList) insert(num, index int) {
|
||||
if index >= l.numsSize {
|
||||
panic("索引越界")
|
||||
}
|
||||
@@ -902,20 +973,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 +1294,110 @@ comments: true
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="my_list.swift"
|
||||
/* 列表类简易实现 */
|
||||
class MyList {
|
||||
private var nums: [Int] // 数组（存储列表元素）
|
||||
private var _capacity = 10 // 列表容量
|
||||
private var _size = 0 // 列表长度（即当前元素数量）
|
||||
private let extendRatio = 2 // 每次列表扩容的倍数
|
||||
|
||||
/* 构造函数 */
|
||||
init() {
|
||||
nums = Array(repeating: 0, count: _capacity)
|
||||
}
|
||||
|
||||
/* 获取列表长度（即当前元素数量）*/
|
||||
func size() -> Int {
|
||||
_size
|
||||
}
|
||||
|
||||
/* 获取列表容量 */
|
||||
func capacity() -> Int {
|
||||
_capacity
|
||||
}
|
||||
|
||||
/* 访问元素 */
|
||||
func get(index: Int) -> Int {
|
||||
// 索引如果越界则抛出错误，下同
|
||||
if index >= _size {
|
||||
fatalError("索引越界")
|
||||
}
|
||||
return nums[index]
|
||||
}
|
||||
|
||||
/* 更新元素 */
|
||||
func set(index: Int, num: Int) {
|
||||
if index >= _size {
|
||||
fatalError("索引越界")
|
||||
}
|
||||
nums[index] = num
|
||||
}
|
||||
|
||||
/* 尾部添加元素 */
|
||||
func add(num: Int) {
|
||||
// 元素数量超出容量时，触发扩容机制
|
||||
if _size == _capacity {
|
||||
extendCapacity()
|
||||
}
|
||||
nums[_size] = num
|
||||
// 更新元素数量
|
||||
_size += 1
|
||||
}
|
||||
|
||||
/* 中间插入元素 */
|
||||
func insert(index: Int, num: Int) {
|
||||
if index >= _size {
|
||||
fatalError("索引越界")
|
||||
}
|
||||
// 元素数量超出容量时，触发扩容机制
|
||||
if _size == _capacity {
|
||||
extendCapacity()
|
||||
}
|
||||
// 将索引 index 以及之后的元素都向后移动一位
|
||||
for j in sequence(first: _size - 1, next: { $0 >= index + 1 ? $0 - 1 : nil }) {
|
||||
nums[j + 1] = nums[j]
|
||||
}
|
||||
nums[index] = num
|
||||
// 更新元素数量
|
||||
_size += 1
|
||||
}
|
||||
|
||||
/* 删除元素 */
|
||||
@discardableResult
|
||||
func remove(index: Int) -> Int {
|
||||
if index >= _size {
|
||||
fatalError("索引越界")
|
||||
}
|
||||
let num = nums[index]
|
||||
// 将索引 index 之后的元素都向前移动一位
|
||||
for j in index ..< (_size - 1) {
|
||||
nums[j] = nums[j + 1]
|
||||
}
|
||||
// 更新元素数量
|
||||
_size -= 1
|
||||
// 返回被删除元素
|
||||
return num
|
||||
}
|
||||
|
||||
/* 列表扩容 */
|
||||
func extendCapacity() {
|
||||
// 新建一个长度为 size 的数组，并将原数组拷贝到新数组
|
||||
nums = nums + Array(repeating: 0, count: _capacity * (extendRatio - 1))
|
||||
// 更新列表容量
|
||||
_capacity = nums.count
|
||||
}
|
||||
|
||||
/* 将列表转换为数组 */
|
||||
func toArray() -> [Int] {
|
||||
var nums = Array(repeating: 0, count: _size)
|
||||
for i in 0 ..< _size {
|
||||
nums[i] = get(index: i)
|
||||
}
|
||||
return nums
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
@@ -4,7 +4,7 @@ comments: true
|
||||
|
||||
# 小结
|
||||
|
||||
- 数组和链表是两种基本数据结构，代表了数据在计算机内存中的两种存储方式，即连续空间存储和离散空间存储。两者的优缺点呈现出此消彼长的关系。
|
||||
- 数组和链表是两种基本数据结构，代表了数据在计算机内存中的两种存储方式，即连续空间存储和离散空间存储。两者的优点与缺点呈现出此消彼长的关系。
|
||||
- 数组支持随机访问、内存空间占用小；但插入与删除元素效率低，且初始化后长度不可变。
|
||||
- 链表可通过更改指针实现高效的结点插入与删除，并且可以灵活地修改长度；但结点访问效率低、占用内存多。常见的链表类型有单向链表、循环链表、双向链表。
|
||||
- 列表又称动态数组，是基于数组实现的一种数据结构，其保存了数组的优势，且可以灵活改变长度。列表的出现大大提升了数组的实用性，但副作用是会造成部分内存空间浪费。
|
||||
|
||||
@@ -8,15 +8,15 @@ comments: true
|
||||
|
||||
在开始学习算法之前，我们首先要想清楚算法的设计目标是什么，或者说，如何来评判算法的好与坏。整体上看，我们设计算法时追求两个层面的目标。
|
||||
|
||||
1. **找到问题解法。** 算法需要能够在规定的输入范围下，可靠地求得问题的正确解。
|
||||
2. **寻求最优解法。** 同一个问题可能存在多种解法，而我们希望算法效率尽可能的高。
|
||||
1. **找到问题解法**。算法需要能够在规定的输入范围下，可靠地求得问题的正确解。
|
||||
2. **寻求最优解法**。同一个问题可能存在多种解法，而我们希望算法效率尽可能的高。
|
||||
|
||||
换言之，在可以解决问题的前提下，算法效率则是主要评价维度，包括：
|
||||
|
||||
- **时间效率** ，即算法的运行速度的快慢。
|
||||
- **空间效率** ，即算法占用的内存空间大小。
|
||||
- **时间效率**，即算法的运行速度的快慢。
|
||||
- **空间效率**，即算法占用的内存空间大小。
|
||||
|
||||
数据结构与算法追求“运行得快、内存占用少”，而如何去评价算法效率则是非常重要的问题，因为只有知道如何评价算法，才能去做算法之间的对比分析，以及优化算法设计。
|
||||
数据结构与算法追求“运行速度快、占用内存少”，而如何去评价算法效率则是非常重要的问题，因为只有知道如何评价算法，才能去做算法之间的对比分析，以及优化算法设计。
|
||||
|
||||
## 效率评估方法
|
||||
|
||||
@@ -24,17 +24,17 @@ comments: true
|
||||
|
||||
假设我们现在有算法 A 和 算法 B ，都能够解决同一问题，现在需要对比两个算法之间的效率。我们能够想到的最直接的方式，就是找一台计算机，把两个算法都完整跑一遍，并监控记录运行时间和内存占用情况。这种评估方式能够反映真实情况，但是也存在很大的硬伤。
|
||||
|
||||
**难以排除测试环境的干扰因素。** 硬件配置会影响到算法的性能表现。例如，在某台计算机中，算法 A 比算法 B 运行时间更短；但换到另一台配置不同的计算机中，可能会得到相反的测试结果。这意味着我们需要在各种机器上展开测试，而这是不现实的。
|
||||
**难以排除测试环境的干扰因素**。硬件配置会影响到算法的性能表现。例如，在某台计算机中，算法 A 比算法 B 运行时间更短；但换到另一台配置不同的计算机中，可能会得到相反的测试结果。这意味着我们需要在各种机器上展开测试，而这是不现实的。
|
||||
|
||||
**展开完整测试非常耗费资源。** 随着输入数据量的大小变化，算法会呈现出不同的效率表现。比如，有可能输入数据量较小时，算法 A 运行时间短于算法 B ，而在输入数据量较大时，测试结果截然相反。因此，若想要达到具有说服力的对比结果，那么需要输入各种体量数据，这样的测试需要占用大量计算资源。
|
||||
**展开完整测试非常耗费资源**。随着输入数据量的大小变化，算法会呈现出不同的效率表现。比如，有可能输入数据量较小时，算法 A 运行时间短于算法 B ，而在输入数据量较大时，测试结果截然相反。因此，若想要达到具有说服力的对比结果，那么需要输入各种体量数据，这样的测试需要占用大量计算资源。
|
||||
|
||||
### 理论估算
|
||||
|
||||
既然实际测试具有很大的局限性，那么我们是否可以仅通过一些计算，就获知算法的效率水平呢？答案是肯定的，我们将此估算方法称为「复杂度分析 Complexity Analysis」或「渐近复杂度分析 Asymptotic Complexity Analysis」。
|
||||
|
||||
**复杂度分析评估随着输入数据量的增长，算法的运行时间和占用空间的增长趋势** 。根据时间和空间两方面，复杂度可分为「时间复杂度 Time Complexity」和「空间复杂度 Space Complexity」。
|
||||
**复杂度分析评估随着输入数据量的增长，算法的运行时间和占用空间的增长趋势**。根据时间和空间两方面，复杂度可分为「时间复杂度 Time Complexity」和「空间复杂度 Space Complexity」。
|
||||
|
||||
**复杂度分析克服了实际测试方法的弊端。** 一是独立于测试环境，分析结果适用于所有运行平台。二是可以体现不同数据量下的算法效率，尤其是可以反映大数据量下的算法性能。
|
||||
**复杂度分析克服了实际测试方法的弊端**。一是独立于测试环境，分析结果适用于所有运行平台。二是可以体现不同数据量下的算法效率，尤其是可以反映大数据量下的算法性能。
|
||||
|
||||
## 复杂度分析的重要性
|
||||
|
||||
|
||||
@@ -4,7 +4,7 @@ comments: true
|
||||
|
||||
# 空间复杂度
|
||||
|
||||
「空间复杂度 Space Complexity」统计 **算法使用内存空间随着数据量变大时的增长趋势** 。这个概念与时间复杂度很类似。
|
||||
「空间复杂度 Space Complexity」统计 **算法使用内存空间随着数据量变大时的增长趋势**。这个概念与时间复杂度很类似。
|
||||
|
||||
## 算法相关空间
|
||||
|
||||
@@ -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}
|
||||
}
|
||||
|
||||
/* 函数 */
|
||||
@@ -174,14 +174,42 @@ comments: true
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title=""
|
||||
/* 类 */
|
||||
class Node {
|
||||
var val: Int
|
||||
var next: Node?
|
||||
|
||||
init(x: Int) {
|
||||
val = x
|
||||
}
|
||||
}
|
||||
|
||||
/* 函数 */
|
||||
func function() -> Int {
|
||||
// do something...
|
||||
return 0
|
||||
}
|
||||
|
||||
func algorithm(n: Int) -> Int { // 输入数据
|
||||
let a = 0 // 暂存数据（常量）
|
||||
var b = 0 // 暂存数据（变量）
|
||||
let node = Node(x: 0) // 暂存数据（对象）
|
||||
let c = function() // 栈帧空间（调用函数）
|
||||
return a + b + c // 输出数据
|
||||
}
|
||||
```
|
||||
|
||||
## 推算方法
|
||||
|
||||
空间复杂度的推算方法和时间复杂度总体类似，只是从统计“计算操作数量”变为统计“使用空间大小”。与时间复杂度不同的是，**我们一般只关注「最差空间复杂度」**。这是因为内存空间是一个硬性要求，我们必须保证在所有输入数据下都有足够的内存空间预留。
|
||||
|
||||
**最差空间复杂度中的“最差”有两层含义**，分别为输入数据的最差分布、算法运行中的最差时间点。
|
||||
|
||||
- **以最差输入数据为准。** 当 $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"
|
||||
|
||||
@@ -219,11 +247,11 @@ comments: true
|
||||
|
||||
```go title=""
|
||||
func algorithm(n int) {
|
||||
a := 0 // O(1)
|
||||
b := make([]int, 10000) // O(1)
|
||||
a := 0 // O(1)
|
||||
b := make([]int, 10000) // O(1)
|
||||
var nums []int
|
||||
if n > 10 {
|
||||
nums = make([]int, 10000) // O(n)
|
||||
nums := make([]int, n) // O(n)
|
||||
}
|
||||
fmt.Println(a, b, nums)
|
||||
}
|
||||
@@ -261,7 +289,19 @@ comments: true
|
||||
}
|
||||
```
|
||||
|
||||
**在递归函数中，需要注意统计栈帧空间。** 例如函数 `loop()`，在循环中调用了 $n$ 次 `function()` ，每轮中的 `function()` 都返回并释放了栈帧空间，因此空间复杂度仍为 $O(1)$ 。而递归函数 `recur()` 在运行中会同时存在 $n$ 个未返回的 `recur()` ，从而使用 $O(n)$ 的栈帧空间。
|
||||
=== "Swift"
|
||||
|
||||
```swift title=""
|
||||
func algorithm(n: Int) {
|
||||
let a = 0 // O(1)
|
||||
let b = Array(repeating: 0, count: 10000) // O(1)
|
||||
if n > 10 {
|
||||
let nums = Array(repeating: 0, count: n) // O(n)
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**在递归函数中，需要注意统计栈帧空间**。例如函数 `loop()`，在循环中调用了 $n$ 次 `function()` ，每轮中的 `function()` 都返回并释放了栈帧空间，因此空间复杂度仍为 $O(1)$ 。而递归函数 `recur()` 在运行中会同时存在 $n$ 个未返回的 `recur()` ，从而使用 $O(n)$ 的栈帧空间。
|
||||
|
||||
=== "Java"
|
||||
|
||||
@@ -387,6 +427,31 @@ comments: true
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title=""
|
||||
@discardableResult
|
||||
func function() -> Int {
|
||||
// do something
|
||||
return 0
|
||||
}
|
||||
|
||||
/* 循环 O(1) */
|
||||
func loop(n: Int) {
|
||||
for _ in 0 ..< n {
|
||||
function()
|
||||
}
|
||||
}
|
||||
|
||||
/* 递归 O(n) */
|
||||
func recur(n: Int) {
|
||||
if n == 1 {
|
||||
return
|
||||
}
|
||||
recur(n: n - 1)
|
||||
}
|
||||
```
|
||||
|
||||
## 常见类型
|
||||
|
||||
设输入数据大小为 $n$ ，常见的空间复杂度类型有（从低到高排列）
|
||||
@@ -536,6 +601,27 @@ $$
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="space_complexity.swift"
|
||||
/* 常数阶 */
|
||||
func constant(n: Int) {
|
||||
// 常量、变量、对象占用 O(1) 空间
|
||||
let a = 0
|
||||
var b = 0
|
||||
let nums = Array(repeating: 0, count: 10000)
|
||||
let node = ListNode(x: 0)
|
||||
// 循环中的变量占用 O(1) 空间
|
||||
for _ in 0 ..< n {
|
||||
let c = 0
|
||||
}
|
||||
// 循环中的函数占用 O(1) 空间
|
||||
for _ in 0 ..< n {
|
||||
function()
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### 线性阶 $O(n)$
|
||||
|
||||
线性阶常见于元素数量与 $n$ 成正比的数组、链表、栈、队列等。
|
||||
@@ -601,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))
|
||||
}
|
||||
@@ -654,6 +740,20 @@ $$
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="space_complexity.swift"
|
||||
/* 线性阶 */
|
||||
func linear(n: Int) {
|
||||
// 长度为 n 的数组占用 O(n) 空间
|
||||
let nums = Array(repeating: 0, count: n)
|
||||
// 长度为 n 的列表占用 O(n) 空间
|
||||
let nodes = (0 ..< n).map { ListNode(x: $0) }
|
||||
// 长度为 n 的哈希表占用 O(n) 空间
|
||||
let map = Dictionary(uniqueKeysWithValues: (0 ..< n).map { ($0, "\($0)") })
|
||||
}
|
||||
```
|
||||
|
||||
以下递归函数会同时存在 $n$ 个未返回的 `algorithm()` 函数，使用 $O(n)$ 大小的栈帧空间。
|
||||
|
||||
=== "Java"
|
||||
@@ -731,6 +831,19 @@ $$
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="space_complexity.swift"
|
||||
/* 线性阶（递归实现） */
|
||||
func linearRecur(n: Int) {
|
||||
print("递归 n = \(n)")
|
||||
if n == 1 {
|
||||
return
|
||||
}
|
||||
linearRecur(n: n - 1)
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
|
||||
<p align="center"> Fig. 递归函数产生的线性阶空间复杂度 </p>
|
||||
@@ -838,7 +951,17 @@ $$
|
||||
|
||||
```
|
||||
|
||||
在以下递归函数中，同时存在 $n$ 个未返回的 `algorihtm()` ，并且每个函数中都初始化了一个数组，长度分别为 $n, n-1, n-2, ..., 2, 1$ ，平均长度为 $\frac{n}{2}$ ，因此总体使用 $O(n^2)$ 空间。
|
||||
=== "Swift"
|
||||
|
||||
```swift title="space_complexity.swift"
|
||||
/* 平方阶 */
|
||||
func quadratic(n: Int) {
|
||||
// 二维列表占用 O(n^2) 空间
|
||||
let numList = Array(repeating: Array(repeating: 0, count: n), count: n)
|
||||
}
|
||||
```
|
||||
|
||||
在以下递归函数中，同时存在 $n$ 个未返回的 `algorithm()` ，并且每个函数中都初始化了一个数组，长度分别为 $n, n-1, n-2, ..., 2, 1$ ，平均长度为 $\frac{n}{2}$ ，因此总体使用 $O(n^2)$ 空间。
|
||||
|
||||
=== "Java"
|
||||
|
||||
@@ -921,6 +1044,20 @@ $$
|
||||
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="space_complexity.swift"
|
||||
/* 平方阶（递归实现） */
|
||||
func quadraticRecur(n: Int) -> Int {
|
||||
if n <= 0 {
|
||||
return 0
|
||||
}
|
||||
// 数组 nums 长度为 n, n-1, ..., 2, 1
|
||||
let nums = Array(repeating: 0, count: n)
|
||||
return quadraticRecur(n: n - 1)
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
|
||||
<p align="center"> Fig. 递归函数产生的平方阶空间复杂度 </p>
|
||||
@@ -971,7 +1108,7 @@ $$
|
||||
|
||||
```go title="space_complexity.go"
|
||||
/* 指数阶（建立满二叉树） */
|
||||
func buildTree(n int) *TreeNode {
|
||||
func buildTree(n int) *treeNode {
|
||||
if n == 0 {
|
||||
return nil
|
||||
}
|
||||
@@ -1014,6 +1151,21 @@ $$
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="space_complexity.swift"
|
||||
/* 指数阶（建立满二叉树） */
|
||||
func buildTree(n: Int) -> TreeNode? {
|
||||
if n == 0 {
|
||||
return nil
|
||||
}
|
||||
let root = TreeNode(x: 0)
|
||||
root.left = buildTree(n: n - 1)
|
||||
root.right = buildTree(n: n - 1)
|
||||
return root
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
|
||||
<p align="center"> Fig. 满二叉树下的指数阶空间复杂度 </p>
|
||||
|
||||
@@ -6,7 +6,7 @@ comments: true
|
||||
|
||||
理想情况下，我们希望算法的时间复杂度和空间复杂度都能够达到最优，而实际上，同时优化时间复杂度和空间复杂度是非常困难的。
|
||||
|
||||
**降低时间复杂度，往往是以提升空间复杂度为代价的，反之亦然。** 我们把牺牲内存空间来提升算法运行速度的思路称为「以空间换时间」；反之，称之为「以时间换空间」。选择哪种思路取决于我们更看重哪个方面。
|
||||
**降低时间复杂度，往往是以提升空间复杂度为代价的，反之亦然**。我们把牺牲内存空间来提升算法运行速度的思路称为「以空间换时间」；反之，称之为「以时间换空间」。选择哪种思路取决于我们更看重哪个方面。
|
||||
|
||||
大多数情况下，时间都是比空间更宝贵的，只要空间复杂度不要太离谱、能接受就行，**因此以空间换时间最为常用**。
|
||||
|
||||
@@ -149,6 +149,22 @@ comments: true
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="leetcode_two_sum.swift"
|
||||
func twoSumBruteForce(nums: [Int], target: Int) -> [Int] {
|
||||
// 两层循环，时间复杂度 O(n^2)
|
||||
for i in nums.indices.dropLast() {
|
||||
for j in nums.indices.dropFirst(i + 1) {
|
||||
if nums[i] + nums[j] == target {
|
||||
return [i, j]
|
||||
}
|
||||
}
|
||||
}
|
||||
return [0]
|
||||
}
|
||||
```
|
||||
|
||||
### 方法二：辅助哈希表
|
||||
|
||||
时间复杂度 $O(N)$ ，空间复杂度 $O(N)$ ，属于「空间换时间」。
|
||||
@@ -294,3 +310,20 @@ comments: true
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="leetcode_two_sum.swift"
|
||||
func twoSumHashTable(nums: [Int], target: Int) -> [Int] {
|
||||
// 辅助哈希表，空间复杂度 O(n)
|
||||
var dic: [Int: Int] = [:]
|
||||
// 单层循环，时间复杂度 O(n)
|
||||
for i in nums.indices {
|
||||
if let j = dic[target - nums[i]] {
|
||||
return [j, i]
|
||||
}
|
||||
dic[nums[i]] = i
|
||||
}
|
||||
return [0]
|
||||
}
|
||||
```
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
|
Before Width: | Height: | Size: 92 KiB After Width: | Height: | Size: 92 KiB |
|
Before Width: | Height: | Size: 74 KiB After Width: | Height: | Size: 74 KiB |
+9
-9
@@ -8,14 +8,14 @@ comments: true
|
||||
|
||||
## 逻辑结构：线性与非线性
|
||||
|
||||
**「逻辑结构」反映了数据之间的逻辑关系。** 数组和链表的数据按照顺序依次排列，反映了数据间的线性关系；树从顶至底按层级排列，反映了祖先与后代之间的派生关系；图由结点和边组成，反映了复杂网络关系。
|
||||
**「逻辑结构」反映了数据之间的逻辑关系**。数组和链表的数据按照顺序依次排列，反映了数据间的线性关系；树从顶至底按层级排列，反映了祖先与后代之间的派生关系；图由结点和边组成，反映了复杂网络关系。
|
||||
|
||||
我们一般将逻辑结构分为「线性」和「非线性」两种。“线性”这个概念很直观，即表明数据在逻辑关系上是排成一条线的；而如果数据之间的逻辑关系是非线形的（例如是网状或树状的），那么就是非线性数据结构。
|
||||
|
||||
- **线性数据结构：** 数组、链表、栈、队列、哈希表；
|
||||
- **非线性数据结构：** 树、图、堆、哈希表；
|
||||
- **线性数据结构**：数组、链表、栈、队列、哈希表；
|
||||
- **非线性数据结构**：树、图、堆、哈希表；
|
||||
|
||||
|
||||
|
||||
|
||||
<p align="center"> Fig. 线性与非线性数据结构 </p>
|
||||
|
||||
@@ -25,16 +25,16 @@ comments: true
|
||||
|
||||
若感到阅读困难，建议先看完下个章节「数组与链表」，再回过头来理解物理结构的含义。
|
||||
|
||||
**「物理结构」反映了数据在计算机内存中的存储方式。** 从本质上看，分别是 **数组的连续空间存储** 和 **链表的离散空间存储** 。物理结构从底层上决定了数据的访问、更新、增删等操作方法，在时间效率和空间效率方面呈现出此消彼长的特性。
|
||||
**「物理结构」反映了数据在计算机内存中的存储方式**。从本质上看，分别是 **数组的连续空间存储** 和 **链表的离散空间存储**。物理结构从底层上决定了数据的访问、更新、增删等操作方法，在时间效率和空间效率方面呈现出此消彼长的特性。
|
||||
|
||||
|
||||
|
||||
|
||||
<p align="center"> Fig. 连续空间存储与离散空间存储 </p>
|
||||
|
||||
**所有数据结构都是基于数组、或链表、或两者组合实现的。** 例如栈和队列，既可以使用数组实现、也可以使用链表实现，而例如哈希表，其实现同时包含了数组和链表。
|
||||
**所有数据结构都是基于数组、或链表、或两者组合实现的**。例如栈和队列，既可以使用数组实现、也可以使用链表实现，而例如哈希表，其实现同时包含了数组和链表。
|
||||
|
||||
- **基于数组可实现：** 栈、队列、堆、哈希表、矩阵、张量（维度 $\geq 3$ 的数组）等；
|
||||
- **基于链表可实现：** 栈、队列、堆、哈希表、树、图等；
|
||||
- **基于数组可实现**：栈、队列、堆、哈希表、矩阵、张量（维度 $\geq 3$ 的数组）等；
|
||||
- **基于链表可实现**：栈、队列、堆、哈希表、树、图等；
|
||||
|
||||
基于数组实现的数据结构也被称为「静态数据结构」，这意味着该数据结构在在被初始化后，长度不可变。相反地，基于链表实现的数据结构被称为「动态数据结构」，该数据结构在被初始化后，我们也可以在程序运行中修改其长度。
|
||||
|
||||
@@ -42,7 +42,7 @@ comments: true
|
||||
|
||||
**「基本数据类型」与「数据结构」之间的联系与区别**
|
||||
|
||||
我们知道，数据结构是在计算机中 **组织与存储数据的方式** ，它的主语是“结构”，而不是“数据”。比如，我们想要表示“一排数字”，自然应该使用「数组」这个数据结构。数组的存储方式使之可以表示数字的相邻关系、先后关系等一系列我们需要的信息，但至于其中存储的是整数 int ，还是小数 float ，或是字符 char ，**则与所谓的数据的结构无关了**。
|
||||
我们知道，数据结构是在计算机中 **组织与存储数据的方式**，它的主语是“结构”，而不是“数据”。比如，我们想要表示“一排数字”，自然应该使用「数组」这个数据结构。数组的存储方式使之可以表示数字的相邻关系、先后关系等一系列我们需要的信息，但至于其中存储的是整数 int ，还是小数 float ，或是字符 char ，**则与所谓的数据的结构无关了**。
|
||||
|
||||
=== "Java"
|
||||
|
||||
@@ -74,7 +74,11 @@ comments: true
|
||||
=== "Go"
|
||||
|
||||
```go title=""
|
||||
|
||||
// 使用多种「基本数据类型」来初始化「数组」
|
||||
var numbers = [5]int{}
|
||||
var decimals = [5]float64{}
|
||||
var characters = [5]byte{}
|
||||
var booleans = [5]bool{}
|
||||
```
|
||||
|
||||
=== "JavaScript"
|
||||
@@ -110,16 +114,26 @@ comments: true
|
||||
bool[] booleans = new bool[5];
|
||||
```
|
||||
|
||||
=== "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)
|
||||
let booleans = Array(repeating: Bool(), count: 5)
|
||||
```
|
||||
|
||||
## 计算机内存
|
||||
|
||||
在计算机中，内存和硬盘是两种主要的存储硬件设备。「硬盘」主要用于长期存储数据，容量较大（通常可达到 TB 级别）、速度较慢。「内存」用于运行程序时暂存数据，速度更快，但容量较小（通常为 GB 级别）。
|
||||
|
||||
**算法运行中，相关数据都被存储在内存中。** 下图展示了一个计算机内存条，其中每个黑色方块都包含一块内存空间。我们可以将内存想象成一个巨大的 Excel 表格，其中每个单元格都可以存储 1 byte 的数据，在算法运行时，所有数据都被存储在这些单元格中。
|
||||
**算法运行中，相关数据都被存储在内存中**。下图展示了一个计算机内存条，其中每个黑色方块都包含一块内存空间。我们可以将内存想象成一个巨大的 Excel 表格，其中每个单元格都可以存储 1 byte 的数据，在算法运行时，所有数据都被存储在这些单元格中。
|
||||
|
||||
**系统通过「内存地址 Memory Location」来访问目标内存位置的数据。** 计算机根据特定规则给表格中每个单元格编号，保证每块内存空间都有独立的内存地址。自此，程序便通过这些地址，访问内存中的数据。
|
||||
**系统通过「内存地址 Memory Location」来访问目标内存位置的数据**。计算机根据特定规则给表格中每个单元格编号，保证每块内存空间都有独立的内存地址。自此，程序便通过这些地址，访问内存中的数据。
|
||||
|
||||
|
||||
|
||||
<p align="center"> Fig. 内存条、内存空间、内存地址 </p>
|
||||
|
||||
**内存资源是设计数据结构与算法的重要考虑因素。** 内存是所有程序的公共资源，当内存被某程序占用时，不能被其它程序同时使用。我们需要根据剩余内存资源的情况来设计算法。例如，若剩余内存空间有限，则要求算法占用的峰值内存不能超过系统剩余内存；若运行的程序很多、缺少大块连续的内存空间，则要求选取的数据结构必须能够存储在离散的内存空间内。
|
||||
**内存资源是设计数据结构与算法的重要考虑因素**。内存是所有程序的公共资源，当内存被某程序占用时，不能被其它程序同时使用。我们需要根据剩余内存资源的情况来设计算法。例如，若剩余内存空间有限，则要求算法占用的峰值内存不能超过系统剩余内存；若运行的程序很多、缺少大块连续的内存空间，则要求选取的数据结构必须能够存储在离散的内存空间内。
|
||||
|
||||
@@ -24,9 +24,9 @@ comments: true
|
||||
|
||||
在原始哈希表中，一个桶地址只能存储一个元素（即键值对）。**考虑将桶地址内的单个元素转变成一个链表，将所有冲突元素都存储在一个链表中**，此时哈希表操作方法为：
|
||||
|
||||
- **查询元素：** 先将 key 输入到哈希函数得到桶地址（即访问链表头部），再遍历链表来确定对应的 value 。
|
||||
- **添加元素：** 先通过哈希函数访问链表头部，再将元素直接添加到链表头部即可。
|
||||
- **删除元素：** 同样先访问链表头部，再遍历链表查找对应元素，删除之即可。
|
||||
- **查询元素**：先将 key 输入到哈希函数得到桶地址（即访问链表头部），再遍历链表来确定对应的 value 。
|
||||
- **添加元素**：先通过哈希函数访问链表头部，再将元素直接添加到链表头部即可。
|
||||
- **删除元素**：同样先访问链表头部，再遍历链表查找对应元素，删除之即可。
|
||||
|
||||
（图）
|
||||
|
||||
@@ -46,9 +46,9 @@ comments: true
|
||||
|
||||
「线性探测」使用固定步长的线性查找来解决哈希冲突。
|
||||
|
||||
**插入元素：** 如果出现哈希冲突，则从冲突位置向后线性遍历（步长一般取 1 ），直到找到一个空位，则将元素插入到该空位中。
|
||||
**插入元素**：如果出现哈希冲突，则从冲突位置向后线性遍历（步长一般取 1 ），直到找到一个空位，则将元素插入到该空位中。
|
||||
|
||||
**查找元素：** 若出现哈希冲突，则使用相同步长执行线性查找，会遇到两种情况：
|
||||
**查找元素**：若出现哈希冲突，则使用相同步长执行线性查找，会遇到两种情况：
|
||||
|
||||
1. 找到对应元素，返回 value 即可；
|
||||
2. 若遇到空位，则说明查找键值对不在哈希表中；
|
||||
@@ -64,9 +64,9 @@ comments: true
|
||||
|
||||
顾名思义，「多次哈希」的思路是基于多个哈希函数 $f_1(x)$ , $f_2(x)$ , $f_3(x)$ , $\cdots$ 进行探测。
|
||||
|
||||
**插入元素：** 若哈希函数 $f_1(x)$ 出现冲突，则尝试 $f_2(x)$ ，以此类推……直到找到空位后插入元素。
|
||||
**插入元素**：若哈希函数 $f_1(x)$ 出现冲突，则尝试 $f_2(x)$ ，以此类推……直到找到空位后插入元素。
|
||||
|
||||
**查找元素：** 以相同的哈希函数顺序查找，存在两种情况：
|
||||
**查找元素**：以相同的哈希函数顺序查找，存在两种情况：
|
||||
|
||||
1. 找到目标元素，则返回之；
|
||||
2. 到空位或已尝试所有哈希函数，说明哈希表中无此元素；
|
||||
|
||||
@@ -16,10 +16,10 @@ comments: true
|
||||
|
||||
除了哈希表之外，还可以使用以下数据结构来实现上述查询功能：
|
||||
|
||||
1. **无序数组：** 每个元素为 `[学号, 姓名]` ；
|
||||
2. **有序数组：** 将 `1.` 中的数组按照学号从小到大排序；
|
||||
3. **链表：** 每个结点的值为 `[学号, 姓名]` ；
|
||||
4. **二叉搜索树：** 每个结点的值为 `[学号, 姓名]` ，根据学号大小来构建树；
|
||||
1. **无序数组**：每个元素为 `[学号, 姓名]` ；
|
||||
2. **有序数组**：将 `1.` 中的数组按照学号从小到大排序；
|
||||
3. **链表**：每个结点的值为 `[学号, 姓名]` ；
|
||||
4. **二叉搜索树**：每个结点的值为 `[学号, 姓名]` ，根据学号大小来构建树；
|
||||
|
||||
使用上述方法，各项操作的时间复杂度如下表所示（在此不做赘述，详解可见 [二叉搜索树章节](https://www.hello-algo.com/chapter_tree/binary_search_tree/#_6)）。无论是查找元素、还是增删元素，哈希表的时间复杂度都是 $O(1)$ ，全面胜出！
|
||||
|
||||
@@ -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
|
||||
}
|
||||
```
|
||||
@@ -646,7 +658,7 @@ $$
|
||||
/* 添加操作 */
|
||||
public set(key: number, val: string) {
|
||||
let index = this.hashFunc(key);
|
||||
this.bucket[index] = new Entry(index, val);
|
||||
this.bucket[index] = new Entry(key, val);
|
||||
}
|
||||
|
||||
/* 删除操作 */
|
||||
@@ -756,6 +768,12 @@ $$
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="array_hash_map.swift"
|
||||
|
||||
```
|
||||
|
||||
## 哈希冲突
|
||||
|
||||
细心的同学可能会发现，**哈希函数 $f(x) = x \% 100$ 会在某些情况下失效**。具体地，当输入的 key 后两位相同时，哈希函数的计算结果也相同，指向同一个 value 。例如，分别查询两个学号 12836 和 20336 ，则有
|
||||
|
||||
@@ -6,13 +6,13 @@ comments: true
|
||||
|
||||
听到“算法”这个词，我们一般会联想到数学。但实际上，大多数算法并不包含复杂的数学，而更像是在考察基本逻辑，而这些逻辑在我们日常生活中处处可见。
|
||||
|
||||
在正式介绍算法之前，我想告诉你一件有趣的事：**其实，你在过去已经学会了很多算法，并且已经习惯将它们应用到日常生活中。** 接下来，我将介绍两个具体例子来佐证。
|
||||
在正式介绍算法之前，我想告诉你一件有趣的事：**其实，你在过去已经学会了很多算法，并且已经习惯将它们应用到日常生活中**。接下来，我将介绍两个具体例子来佐证。
|
||||
|
||||
**例一：拼积木。** 一套积木，除了有许多部件之外，还会附送详细的拼装说明书。我们按照说明书上一步步操作，即可拼出复杂的积木模型。
|
||||
**例一：拼积木**。一套积木，除了有许多部件之外，还会附送详细的拼装说明书。我们按照说明书上一步步操作，即可拼出复杂的积木模型。
|
||||
|
||||
如果从数据结构与算法的角度看，大大小小的「积木」就是数据结构，而「拼装说明书」上的一系列步骤就是算法。
|
||||
|
||||
**例二：查字典。** 在字典中，每个汉字都有一个对应的拼音，而字典是按照拼音的英文字母表顺序排列的。假设需要在字典中查询任意一个拼音首字母为 $r$ 的字，一般我们会这样做：
|
||||
**例二：查字典**。在字典中，每个汉字都有一个对应的拼音，而字典是按照拼音的英文字母表顺序排列的。假设需要在字典中查询任意一个拼音首字母为 $r$ 的字，一般我们会这样做：
|
||||
|
||||
1. 打开字典大致一半页数的位置，查看此页的首字母是什么（假设为 $m$ ）；
|
||||
2. 由于在英文字母表中 $r$ 在 $m$ 的后面，因此应排除字典前半部分，查找范围仅剩后半部分；
|
||||
|
||||
@@ -44,13 +44,13 @@ comments: true
|
||||
|
||||
首先介绍数据结构与算法的评价维度、算法效率的评估方法，引出了计算复杂度概念。
|
||||
|
||||
接下来，从 **函数渐近上界** 入手，分别介绍了 **时间复杂度** 和 **空间复杂度** ，包括推算方法、常见类型、示例等。同时，剖析了 **最差、最佳、平均** 时间复杂度的联系与区别。
|
||||
接下来，从 **函数渐近上界** 入手，分别介绍了 **时间复杂度** 和 **空间复杂度**，包括推算方法、常见类型、示例等。同时，剖析了 **最差、最佳、平均** 时间复杂度的联系与区别。
|
||||
|
||||
### 数据结构
|
||||
|
||||
首先介绍了常用的 **基本数据类型** 、以及它们是如何在内存中存储的。
|
||||
|
||||
接下来，介绍了两种 **数据结构分类方法** ，包括逻辑结构与物理结构。
|
||||
接下来，介绍了两种 **数据结构分类方法**，包括逻辑结构与物理结构。
|
||||
|
||||
后续展开介绍了 **数组、链表、栈、队列、散列表、树、堆、图** 等数据结构，关心以下内容：
|
||||
|
||||
@@ -82,28 +82,146 @@ comments: true
|
||||
|
||||
## 风格约定
|
||||
|
||||
- 文章中的重要名词会用「」符号标注，例如「数组 Array」。名词混淆会导致不必要的歧义，因此最好可以记住这类名词（包括中文和英文），以便后续阅读文献时使用。
|
||||
- 重点内容、总起句、总结句会被 **加粗** ，此类文字值得更多关注。
|
||||
- 专有名词和有特指含义的词句会使用 “ ” 标注，以避免歧义。
|
||||
- 标题后标注 * 符号的是选读章节，如果你的时间有限，可以先跳过这些章节。
|
||||
- 文章中的重要名词会用「」符号标注，例如「数组 Array」。名词混淆会导致不必要的歧义，因此最好可以记住这类名词（包括中文和英文），以便后续阅读文献时使用。
|
||||
- 重点内容、总起句、总结句会被 **加粗**，此类文字值得特别关注。
|
||||
- 专有名词和有特指含义的词句会使用 “ ” 标注，以避免歧义。
|
||||
- 在工程应用中，每种语言都有注释规范；而本书放弃了一部分的注释规范性，以换取更加紧凑的内容排版。注释主要分为三种类型：标题注释、内容注释、多行注释。
|
||||
|
||||
=== "Java"
|
||||
|
||||
```java title=""
|
||||
/* 标题注释，用于标注函数、类、测试样例等 */
|
||||
|
||||
// 内容注释，用于详解代码
|
||||
|
||||
/**
|
||||
* 多行
|
||||
* 注释
|
||||
*/
|
||||
```
|
||||
|
||||
=== "C++"
|
||||
|
||||
```cpp title=""
|
||||
/* 标题注释，用于标注函数、类、测试样例等 */
|
||||
|
||||
// 内容注释，用于详解代码
|
||||
|
||||
/**
|
||||
* 多行
|
||||
* 注释
|
||||
*/
|
||||
```
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python title=""
|
||||
""" 标题注释，用于标注函数、类、测试样例等 """
|
||||
|
||||
# 内容注释，用于详解代码
|
||||
|
||||
"""
|
||||
多行
|
||||
注释
|
||||
"""
|
||||
```
|
||||
|
||||
=== "Go"
|
||||
|
||||
```go title=""
|
||||
/* 标题注释，用于标注函数、类、测试样例等 */
|
||||
|
||||
// 内容注释，用于详解代码
|
||||
|
||||
/**
|
||||
* 多行
|
||||
* 注释
|
||||
*/
|
||||
```
|
||||
|
||||
=== "JavaScript"
|
||||
|
||||
```js title=""
|
||||
/* 标题注释，用于标注函数、类、测试样例等 */
|
||||
|
||||
// 内容注释，用于详解代码
|
||||
|
||||
/**
|
||||
* 多行
|
||||
* 注释
|
||||
*/
|
||||
```
|
||||
|
||||
=== "TypeScript"
|
||||
|
||||
```typescript title=""
|
||||
/* 标题注释，用于标注函数、类、测试样例等 */
|
||||
|
||||
// 内容注释，用于详解代码
|
||||
|
||||
/**
|
||||
* 多行
|
||||
* 注释
|
||||
*/
|
||||
```
|
||||
|
||||
=== "C"
|
||||
|
||||
```c title=""
|
||||
/* 标题注释，用于标注函数、类、测试样例等 */
|
||||
|
||||
// 内容注释，用于详解代码
|
||||
|
||||
/**
|
||||
* 多行
|
||||
* 注释
|
||||
*/
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
|
||||
```csharp title=""
|
||||
/* 标题注释，用于标注函数、类、测试样例等 */
|
||||
|
||||
// 内容注释，用于详解代码
|
||||
|
||||
/**
|
||||
* 多行
|
||||
* 注释
|
||||
*/
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title=""
|
||||
/* 标题注释，用于标注函数、类、测试样例等 */
|
||||
|
||||
// 内容注释，用于详解代码
|
||||
|
||||
/**
|
||||
* 多行
|
||||
* 注释
|
||||
*/
|
||||
```
|
||||
|
||||
## 本书特点 *
|
||||
|
||||
??? abstract "默认折叠，可以跳过"
|
||||
|
||||
**以实践为主。** 我们知道，学习英语期间光啃书本是远远不够的，需要多听、多说、多写，在实践中培养语感、积累经验。编程语言也是一门语言，因此学习方法也应是类似的，需要多看优秀代码、多敲键盘、多思考代码逻辑。
|
||||
**以实践为主**。我们知道，学习英语期间光啃书本是远远不够的，需要多听、多说、多写，在实践中培养语感、积累经验。编程语言也是一门语言，因此学习方法也应是类似的，需要多看优秀代码、多敲键盘、多思考代码逻辑。
|
||||
|
||||
本书的理论部分占少量篇幅，主要分为两类：一是基础且必要的概念知识，以培养读者对于算法的感性认识；二是重要的分类、对比或总结，这是为了帮助你站在更高视角俯瞰各个知识点，形成连点成面的效果。
|
||||
|
||||
实践部分主要由示例和代码组成。代码配有简要注释，复杂示例会尽可能地使用视觉化的形式呈现。我强烈建议读者对照着代码自己敲一遍，如果时间有限，也至少逐行读、复制并运行一遍，配合着讲解将代码吃透。
|
||||
|
||||
**视觉化学习。** 信息时代以来，视觉化的脚步从未停止。媒体形式经历了文字短信、图文 Email 、动图、短（长）视频、交互式 Web 、3D 游戏等演变过程，信息的视觉化程度越来越高、愈加符合人类感官、信息传播效率大大提升。科技界也在向视觉化迈进，iPhone 就是一个典型例子，其相对于传统手机是高度视觉化的，包含精心设计的字体、主题配色、交互动画等。
|
||||
**视觉化学习**。信息时代以来，视觉化的脚步从未停止。媒体形式经历了文字短信、图文 Email 、动图、短（长）视频、交互式 Web 、3D 游戏等演变过程，信息的视觉化程度越来越高、愈加符合人类感官、信息传播效率大大提升。科技界也在向视觉化迈进，iPhone 就是一个典型例子，其相对于传统手机是高度视觉化的，包含精心设计的字体、主题配色、交互动画等。
|
||||
|
||||
近两年，短视频成为最受欢迎的信息媒介，可以在短时间内将高密度的信息“灌”给我们，有着极其舒适的观看体验。阅读则不然，读者与书本之间天然存在一种“疏离感”，我们看书会累、会走神、会停下来想其他事、会划下喜欢的句子、会思考某一片段的含义，这种疏离感给了读者与书本之间对话的可能，拓宽了想象空间。
|
||||
|
||||
本书作为一本入门教材，希望可以保有书本的“慢节奏”，但也会避免与读者产生过多“疏离感”，而是努力将知识完整清晰地推送到你聪明的小脑袋瓜中。我将采用视觉化的方式（例如配图、动画），尽我可能清晰易懂地讲解复杂概念和抽象示例。
|
||||
|
||||
**内容精简化。** 大多数的经典教科书，会把每个主题都讲的很透彻。虽然透彻性正是其获得读者青睐的原因，但对于想要快速入门的初学者来说，这些教材的实用性不足。本书会避免引入非必要的概念、名词、定义等，也避免展开不必要的理论分析，毕竟这不是一本真正意义上的教材，主要任务是尽快地带领读者入门。
|
||||
**内容精简化**。大多数的经典教科书，会把每个主题都讲的很透彻。虽然透彻性正是其获得读者青睐的原因，但对于想要快速入门的初学者来说，这些教材的实用性不足。本书会避免引入非必要的概念、名词、定义等，也避免展开不必要的理论分析，毕竟这不是一本真正意义上的教材，主要任务是尽快地带领读者入门。
|
||||
|
||||
引入一些生活案例或趣味内容，非常适合作为知识点的引子或者解释的补充，但当融入过多额外元素时，内容会稍显冗长，也许反而使读者容易迷失、抓不住重点，这也是本书需要避免的。
|
||||
|
||||
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 210 KiB After Width: | Height: | Size: 200 KiB |
@@ -41,3 +41,8 @@ comments: true
|
||||
|
||||
1. 下载并安装 [.Net 6.0](https://dotnet.microsoft.com/en-us/download) ；
|
||||
2. 在 VSCode 的插件市场中搜索 `c#` ，安装 c# 。
|
||||
|
||||
## Swift 环境
|
||||
|
||||
1. 下载并安装 [Swift](https://www.swift.org/download/)；
|
||||
2. 在 VSCode 的插件市场中搜索 `swift`，安装 [Swift for Visual Studio Code](https://marketplace.visualstudio.com/items?itemName=sswg.swift-lang)。
|
||||
|
||||
@@ -32,7 +32,7 @@ git clone https://github.com/krahets/hello-algo.git
|
||||
|
||||
### 运行源代码
|
||||
|
||||
本书提供配套 Java, C++, Python 代码仓（后续可能拓展支持语言）。书中的代码栏上若标有 `*.java` , `*.cpp` , `*.py` ，则可在仓库 codes 文件夹中找到对应的 **代码源文件** 。
|
||||
本书提供配套 Java, C++, Python 代码仓（后续可能拓展支持语言）。书中的代码栏上若标有 `*.java` , `*.cpp` , `*.py` ，则可在仓库 codes 文件夹中找到对应的 **代码源文件**。
|
||||
|
||||
|
||||
|
||||
@@ -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 道题量，熟悉大多数的算法问题。刚开始刷题时，“遗忘”是最大的困扰点，但这是很正常的，请不要担心。学习中有一种概念叫“周期性回顾”，同一道题隔段时间做一次，当做了三遍以上，往往就能牢记于心了。
|
||||
|
||||
**第三阶段，搭建知识体系。** 在学习方面，可以阅读算法专栏文章、解题框架、算法教材，不断地丰富知识体系。在刷题方面，可以开始采用进阶刷题方案，例如按专题分类、一题多解、一解多题等，刷题方案在社区中可以找到一些讲解，在此不做赘述。
|
||||
**第三阶段，搭建知识体系**。在学习方面，可以阅读算法专栏文章、解题框架、算法教材，不断地丰富知识体系。在刷题方面，可以开始采用进阶刷题方案，例如按专题分类、一题多解、一解多题等，刷题方案在社区中可以找到一些讲解，在此不做赘述。
|
||||
|
||||
|
||||
|
||||
@@ -9,7 +9,7 @@ comments: true
|
||||
使用二分查找有两个前置条件：
|
||||
|
||||
- **要求输入数据是有序的**，这样才能通过判断大小关系来排除一半的搜索区间；
|
||||
- **二分查找仅适用于数组** ，而在链表中使用效率很低，因为其在循环中需要跳跃式（非连续地）访问元素。
|
||||
- **二分查找仅适用于数组**，而在链表中使用效率很低，因为其在循环中需要跳跃式（非连续地）访问元素。
|
||||
|
||||
## 算法实现
|
||||
|
||||
@@ -116,17 +116,17 @@ $$
|
||||
=== "Go"
|
||||
|
||||
```go title="binary_search.go"
|
||||
/* 二分查找（左闭右开） */
|
||||
func binarySearch1(nums []int, target int) int {
|
||||
// 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
|
||||
i, j := 0, len(nums)
|
||||
// 循环，当搜索区间为空时跳出（当 i = j 时为空）
|
||||
for i < j {
|
||||
/* 二分查找（双闭区间） */
|
||||
func binarySearch(nums []int, target int) int {
|
||||
// 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
|
||||
i, j := 0, len(nums)-1
|
||||
// 循环，当搜索区间为空时跳出（当 i > j 时为空）
|
||||
for i <= j {
|
||||
m := (i + j) / 2 // 计算中点索引 m
|
||||
if nums[m] < target { // 此情况说明 target 在区间 [m+1, j) 中
|
||||
if nums[m] < target { // 此情况说明 target 在区间 [m+1, j] 中
|
||||
i = m + 1
|
||||
} else if nums[m] > target { // 此情况说明 target 在区间 [i, m) 中
|
||||
j = m
|
||||
} else if nums[m] > target { // 此情况说明 target 在区间 [i, m-1] 中
|
||||
j = m - 1
|
||||
} else { // 找到目标元素，返回其索引
|
||||
return m
|
||||
}
|
||||
@@ -141,27 +141,43 @@ $$
|
||||
```js title="binary_search.js"
|
||||
/* 二分查找（双闭区间） */
|
||||
function binarySearch(nums, target) {
|
||||
// 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
|
||||
let i = 0, j = nums.length - 1;
|
||||
// 循环，当搜索区间为空时跳出（当 i > j 时为空）
|
||||
while (i <= j) {
|
||||
let m = parseInt((i + j) / 2); // 计算中点索引 m ，在 JS 中需使用 parseInt 函数取整
|
||||
if (nums[m] < target) // 此情况说明 target 在区间 [m+1, j] 中
|
||||
i = m + 1;
|
||||
else if (nums[m] > target) // 此情况说明 target 在区间 [i, m-1] 中
|
||||
j = m - 1;
|
||||
else
|
||||
return m; // 找到目标元素，返回其索引
|
||||
// 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
|
||||
let i = 0, j = nums.length - 1;
|
||||
// 循环，当搜索区间为空时跳出（当 i > j 时为空）
|
||||
while (i <= j) {
|
||||
let m = parseInt((i + j) / 2); // 计算中点索引 m ，在 JS 中需使用 parseInt 函数取整
|
||||
if (nums[m] < target) // 此情况说明 target 在区间 [m+1, j] 中
|
||||
i = m + 1;
|
||||
else if (nums[m] > target) // 此情况说明 target 在区间 [i, m-1] 中
|
||||
j = m - 1;
|
||||
else
|
||||
return m; // 找到目标元素，返回其索引
|
||||
}
|
||||
// 未找到目标元素，返回 -1
|
||||
return -1;
|
||||
// 未找到目标元素，返回 -1
|
||||
return -1;
|
||||
}
|
||||
```
|
||||
|
||||
=== "TypeScript"
|
||||
|
||||
```typescript title="binary_search.ts"
|
||||
|
||||
/* 二分查找（双闭区间） */
|
||||
const binarySearch = function (nums: number[], target: number): number {
|
||||
// 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
|
||||
let i = 0, j = nums.length - 1;
|
||||
// 循环，当搜索区间为空时跳出（当 i > j 时为空）
|
||||
while (i <= j) {
|
||||
const m = Math.floor(i + (j - i) / 2); // 计算中点索引 m
|
||||
if (nums[m] < target) { // 此情况说明 target 在区间 [m+1, j] 中
|
||||
i = m + 1;
|
||||
} else if (nums[m] > target) { // 此情况说明 target 在区间 [i, m-1] 中
|
||||
j = m - 1;
|
||||
} else { // 找到目标元素，返回其索引
|
||||
return m;
|
||||
}
|
||||
}
|
||||
return -1; // 未找到目标元素，返回 -1
|
||||
}
|
||||
```
|
||||
|
||||
=== "C"
|
||||
@@ -194,6 +210,12 @@ $$
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="binary_search.swift"
|
||||
|
||||
```
|
||||
|
||||
### “左闭右开”实现
|
||||
|
||||
当然，我们也可以使用“左闭右开”的表示方法，写出相同功能的二分查找代码。
|
||||
@@ -208,9 +230,9 @@ $$
|
||||
// 循环，当搜索区间为空时跳出（当 i = j 时为空）
|
||||
while (i < j) {
|
||||
int m = (i + j) / 2; // 计算中点索引 m
|
||||
if (nums[m] < target) // 此情况说明 target 在区间 [m+1, j) 中
|
||||
if (nums[m] < target) // 此情况说明 target 在区间 [m+1, j] 中
|
||||
i = m + 1;
|
||||
else if (nums[m] > target) // 此情况说明 target 在区间 [i, m) 中
|
||||
else if (nums[m] > target) // 此情况说明 target 在区间 [i, m] 中
|
||||
j = m;
|
||||
else // 找到目标元素，返回其索引
|
||||
return m;
|
||||
@@ -230,9 +252,9 @@ $$
|
||||
// 循环，当搜索区间为空时跳出（当 i = j 时为空）
|
||||
while (i < j) {
|
||||
int m = (i + j) / 2; // 计算中点索引 m
|
||||
if (nums[m] < target) // 此情况说明 target 在区间 [m+1, j) 中
|
||||
if (nums[m] < target) // 此情况说明 target 在区间 [m+1, j] 中
|
||||
i = m + 1;
|
||||
else if (nums[m] > target) // 此情况说明 target 在区间 [i, m) 中
|
||||
else if (nums[m] > target) // 此情况说明 target 在区间 [i, m] 中
|
||||
j = m;
|
||||
else // 找到目标元素，返回其索引
|
||||
return m;
|
||||
@@ -252,9 +274,9 @@ $$
|
||||
# 循环，当搜索区间为空时跳出（当 i = j 时为空）
|
||||
while i < j:
|
||||
m = (i + j) // 2 # 计算中点索引 m
|
||||
if nums[m] < target: # 此情况说明 target 在区间 [m+1, j) 中
|
||||
if nums[m] < target: # 此情况说明 target 在区间 [m+1, j] 中
|
||||
i = m + 1
|
||||
elif nums[m] > target: # 此情况说明 target 在区间 [i, m) 中
|
||||
elif nums[m] > target: # 此情况说明 target 在区间 [i, m] 中
|
||||
j = m
|
||||
else: # 找到目标元素，返回其索引
|
||||
return m
|
||||
@@ -271,9 +293,9 @@ $$
|
||||
// 循环，当搜索区间为空时跳出（当 i = j 时为空）
|
||||
for i < j {
|
||||
m := (i + j) / 2 // 计算中点索引 m
|
||||
if nums[m] < target { // 此情况说明 target 在区间 [m+1, j) 中
|
||||
if nums[m] < target { // 此情况说明 target 在区间 [m+1, j] 中
|
||||
i = m + 1
|
||||
} else if nums[m] > target { // 此情况说明 target 在区间 [i, m) 中
|
||||
} else if nums[m] > target { // 此情况说明 target 在区间 [i, m] 中
|
||||
j = m
|
||||
} else { // 找到目标元素，返回其索引
|
||||
return m
|
||||
@@ -289,27 +311,43 @@ $$
|
||||
```js title="binary_search.js"
|
||||
/* 二分查找（左闭右开） */
|
||||
function binarySearch1(nums, target) {
|
||||
// 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
|
||||
let i = 0, j = nums.length;
|
||||
// 循环，当搜索区间为空时跳出（当 i = j 时为空）
|
||||
while (i < j) {
|
||||
let m = parseInt((i + j) / 2); // 计算中点索引 m ，在 JS 中需使用 parseInt 函数取整
|
||||
if (nums[m] < target) // 此情况说明 target 在区间 [m+1, j) 中
|
||||
i = m + 1;
|
||||
else if (nums[m] > target) // 此情况说明 target 在区间 [i, m) 中
|
||||
j = m;
|
||||
else // 找到目标元素，返回其索引
|
||||
return m;
|
||||
// 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
|
||||
let i = 0, j = nums.length;
|
||||
// 循环，当搜索区间为空时跳出（当 i = j 时为空）
|
||||
while (i < j) {
|
||||
let m = parseInt((i + j) / 2); // 计算中点索引 m ，在 JS 中需使用 parseInt 函数取整
|
||||
if (nums[m] < target) // 此情况说明 target 在区间 [m+1, j] 中
|
||||
i = m + 1;
|
||||
else if (nums[m] > target) // 此情况说明 target 在区间 [i, m] 中
|
||||
j = m;
|
||||
else // 找到目标元素，返回其索引
|
||||
return m;
|
||||
}
|
||||
// 未找到目标元素，返回 -1
|
||||
return -1;
|
||||
// 未找到目标元素，返回 -1
|
||||
return -1;
|
||||
}
|
||||
```
|
||||
|
||||
=== "TypeScript"
|
||||
|
||||
```typescript title="binary_search.ts"
|
||||
|
||||
/* 二分查找（左闭右开） */
|
||||
const binarySearch1 = function (nums: number[], target: number): number {
|
||||
// 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
|
||||
let i = 0, j = nums.length;
|
||||
// 循环，当搜索区间为空时跳出（当 i = j 时为空）
|
||||
while (i < j) {
|
||||
const m = Math.floor(i + (j - i) / 2); // 计算中点索引 m
|
||||
if (nums[m] < target) { // 此情况说明 target 在区间 [m+1, j] 中
|
||||
i = m + 1;
|
||||
} else if (nums[m] > target) { // 此情况说明 target 在区间 [i, m] 中
|
||||
j = m;
|
||||
} else { // 找到目标元素，返回其索引
|
||||
return m;
|
||||
}
|
||||
}
|
||||
return -1; // 未找到目标元素，返回 -1
|
||||
}
|
||||
```
|
||||
|
||||
=== "C"
|
||||
@@ -330,9 +368,9 @@ $$
|
||||
while (i < j)
|
||||
{
|
||||
int m = (i + j) / 2; // 计算中点索引 m
|
||||
if (nums[m] < target) // 此情况说明 target 在区间 [m+1, j) 中
|
||||
if (nums[m] < target) // 此情况说明 target 在区间 [m+1, j] 中
|
||||
i = m + 1;
|
||||
else if (nums[m] > target) // 此情况说明 target 在区间 [i, m) 中
|
||||
else if (nums[m] > target) // 此情况说明 target 在区间 [i, m] 中
|
||||
j = m;
|
||||
else // 找到目标元素，返回其索引
|
||||
return m;
|
||||
@@ -342,6 +380,12 @@ $$
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="binary_search.swift"
|
||||
|
||||
```
|
||||
|
||||
### 两种表示对比
|
||||
|
||||
对比下来，两种表示的代码写法有以下不同点：
|
||||
@@ -407,7 +451,10 @@ $$
|
||||
=== "TypeScript"
|
||||
|
||||
```typescript title=""
|
||||
|
||||
// (i + j) 有可能超出 Number 的取值范围
|
||||
let m = Math.floor((i + j) / 2);
|
||||
// 更换为此写法则不会越界
|
||||
let m = Math.floor(i + (j - i) / 2);
|
||||
```
|
||||
|
||||
=== "C"
|
||||
@@ -425,21 +472,27 @@ $$
|
||||
int m = i + (j - i) / 2;
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title=""
|
||||
|
||||
```
|
||||
|
||||
## 复杂度分析
|
||||
|
||||
**时间复杂度 $O(\log n)$ ：** 其中 $n$ 为数组或链表长度；每轮排除一半的区间，因此循环轮数为 $\log_2 n$ ，使用 $O(\log n)$ 时间。
|
||||
**时间复杂度 $O(\log n)$** ：其中 $n$ 为数组或链表长度；每轮排除一半的区间，因此循环轮数为 $\log_2 n$ ，使用 $O(\log n)$ 时间。
|
||||
|
||||
**空间复杂度 $O(1)$ ：** 指针 `i` , `j` 使用常数大小空间。
|
||||
**空间复杂度 $O(1)$** ：指针 `i` , `j` 使用常数大小空间。
|
||||
|
||||
## 优缺点
|
||||
## 优点与缺点
|
||||
|
||||
二分查找效率很高，体现在：
|
||||
|
||||
- **二分查找时间复杂度低。** 对数阶在数据量很大时具有巨大优势，例如，当数据大小 $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$ 较小时，线性查找反而比二分查找更快。
|
||||
|
||||
@@ -105,6 +105,12 @@ comments: true
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="hashing_search.swift"
|
||||
|
||||
```
|
||||
|
||||
再比如，如果我们想要给定一个目标结点值 `target` ，获取对应的链表结点对象，那么也可以使用哈希查找实现。
|
||||
|
||||
|
||||
@@ -199,13 +205,19 @@ comments: true
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="hashing_search.swift"
|
||||
|
||||
```
|
||||
|
||||
## 复杂度分析
|
||||
|
||||
**时间复杂度：** $O(1)$ ，哈希表的查找操作使用 $O(1)$ 时间。
|
||||
**时间复杂度 $O(1)$** ：哈希表的查找操作使用 $O(1)$ 时间。
|
||||
|
||||
**空间复杂度：** $O(n)$ ，其中 $n$ 为数组或链表长度。
|
||||
**空间复杂度 $O(n)$** ：其中 $n$ 为数组或链表长度。
|
||||
|
||||
## 优缺点
|
||||
## 优点与缺点
|
||||
|
||||
在哈希表中，**查找、插入、删除操作的平均时间复杂度都为 $O(1)$** ，这意味着无论是高频增删还是高频查找场景，哈希查找的性能表现都非常好。当然，一切的前提是保证哈希表未退化。
|
||||
|
||||
|
||||
@@ -94,7 +94,18 @@ comments: true
|
||||
=== "TypeScript"
|
||||
|
||||
```typescript title="linear_search.ts"
|
||||
|
||||
/* 线性查找（数组）*/
|
||||
function linearSearchArray(nums: number[], target: number): number {
|
||||
// 遍历数组
|
||||
for (let i = 0; i < nums.length; i++) {
|
||||
// 找到目标元素，返回其索引
|
||||
if (nums[i] === target) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
// 未找到目标元素，返回 -1
|
||||
return -1;
|
||||
}
|
||||
```
|
||||
|
||||
=== "C"
|
||||
@@ -122,6 +133,12 @@ comments: true
|
||||
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="linear_search.swift"
|
||||
|
||||
```
|
||||
|
||||
再比如，我们想要在给定一个目标结点值 `target` ，返回此结点对象，也可以在链表中进行线性查找。
|
||||
|
||||
=== "Java"
|
||||
@@ -210,7 +227,19 @@ comments: true
|
||||
=== "TypeScript"
|
||||
|
||||
```typescript title="linear_search.ts"
|
||||
|
||||
/* 线性查找（链表）*/
|
||||
function linearSearchLinkedList(head: ListNode | null, target: number): ListNode | null {
|
||||
// 遍历链表
|
||||
while (head) {
|
||||
// 找到目标结点，返回之
|
||||
if (head.val === target) {
|
||||
return head;
|
||||
}
|
||||
head = head.next;
|
||||
}
|
||||
// 未找到目标结点，返回 null
|
||||
return null;
|
||||
}
|
||||
```
|
||||
|
||||
=== "C"
|
||||
@@ -238,14 +267,20 @@ comments: true
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="linear_search.swift"
|
||||
|
||||
```
|
||||
|
||||
## 复杂度分析
|
||||
|
||||
**时间复杂度 $O(n)$ ：** 其中 $n$ 为数组或链表长度。
|
||||
**时间复杂度 $O(n)$** ：其中 $n$ 为数组或链表长度。
|
||||
|
||||
**空间复杂度 $O(1)$ ：** 无需使用额外空间。
|
||||
**空间复杂度 $O(1)$** ：无需使用额外空间。
|
||||
|
||||
## 优缺点
|
||||
## 优点与缺点
|
||||
|
||||
**线性查找的通用性极佳。** 由于线性查找是依次访问元素的，即没有跳跃访问元素，因此数组或链表皆适用。
|
||||
**线性查找的通用性极佳**。由于线性查找是依次访问元素的，即没有跳跃访问元素，因此数组或链表皆适用。
|
||||
|
||||
**线性查找的时间复杂度太高。** 在数据量 $n$ 很大时，查找效率很低。
|
||||
**线性查找的时间复杂度太高**。在数据量 $n$ 很大时，查找效率很低。
|
||||
|
||||
@@ -85,9 +85,8 @@ comments: true
|
||||
for (int j = 0; j < i; j++) {
|
||||
if (nums[j] > nums[j + 1]) {
|
||||
// 交换 nums[j] 与 nums[j + 1]
|
||||
int tmp = nums[j];
|
||||
nums[j] = nums[j + 1];
|
||||
nums[j + 1] = tmp;
|
||||
// 这里使用了 std::swap() 函数
|
||||
swap(nums[j], nums[j + 1]);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -170,7 +169,23 @@ comments: true
|
||||
=== "C"
|
||||
|
||||
```c title="bubble_sort.c"
|
||||
|
||||
/* 冒泡排序 */
|
||||
void bubble_sort(int nums[], int size) {
|
||||
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
|
||||
for (int i = 0; i < size - 1; i++)
|
||||
{
|
||||
// 内循环：冒泡操作
|
||||
for (int j = 0; j < size - 1 - i; j++)
|
||||
{
|
||||
if (nums[j] > nums[j + 1])
|
||||
{
|
||||
int temp = nums[j];
|
||||
nums[j] = nums[j + 1];
|
||||
nums[j + 1] = temp;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
@@ -197,17 +212,23 @@ 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)$ 时间。
|
||||
**时间复杂度 $O(n^2)$** ：各轮「冒泡」遍历的数组长度为 $n - 1$ , $n - 2$ , $\cdots$ , $2$ , $1$ 次，求和为 $\frac{(n - 1) n}{2}$ ，因此使用 $O(n^2)$ 时间。
|
||||
|
||||
**空间复杂度 $O(1)$ ：** 指针 $i$ , $j$ 使用常数大小的额外空间。
|
||||
**空间复杂度 $O(1)$** ：指针 $i$ , $j$ 使用常数大小的额外空间。
|
||||
|
||||
**原地排序：** 指针变量仅使用常数大小额外空间。
|
||||
**原地排序**：指针变量仅使用常数大小额外空间。
|
||||
|
||||
**稳定排序：** 不交换相等元素。
|
||||
**稳定排序**：不交换相等元素。
|
||||
|
||||
**自适排序：** 引入 `flag` 优化后（见下文），最佳时间复杂度为 $O(N)$ 。
|
||||
**自适排序**：引入 `flag` 优化后（见下文），最佳时间复杂度为 $O(N)$ 。
|
||||
|
||||
## 效率优化
|
||||
|
||||
@@ -250,9 +271,8 @@ comments: true
|
||||
for (int j = 0; j < i; j++) {
|
||||
if (nums[j] > nums[j + 1]) {
|
||||
// 交换 nums[j] 与 nums[j + 1]
|
||||
int tmp = nums[j];
|
||||
nums[j] = nums[j + 1];
|
||||
nums[j + 1] = tmp;
|
||||
// 这里使用了 std::swap() 函数
|
||||
swap(nums[j], nums[j + 1]);
|
||||
flag = true; // 记录交换元素
|
||||
}
|
||||
}
|
||||
@@ -352,7 +372,26 @@ comments: true
|
||||
=== "C"
|
||||
|
||||
```c title="bubble_sort.c"
|
||||
|
||||
/* 冒泡排序 */
|
||||
void bubble_sort(int nums[], int size) {
|
||||
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
|
||||
for (int i = 0; i < size - 1; i++)
|
||||
{
|
||||
bool flag = false;
|
||||
// 内循环：冒泡操作
|
||||
for (int j = 0; j < size - 1 - i; j++)
|
||||
{
|
||||
if (nums[j] > nums[j + 1])
|
||||
{
|
||||
int temp = nums[j];
|
||||
nums[j] = nums[j + 1];
|
||||
nums[j + 1] = temp;
|
||||
flag = true;
|
||||
}
|
||||
}
|
||||
if(!flag) break;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
@@ -381,3 +420,9 @@ comments: true
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="bubble_sort.swift"
|
||||
|
||||
```
|
||||
|
||||
@@ -135,7 +135,23 @@ comments: true
|
||||
=== "C"
|
||||
|
||||
```c title="insertion_sort.c"
|
||||
|
||||
/* 插入排序 */
|
||||
void insertionSort(int nums[], int size) {
|
||||
// 外循环：base = nums[1], nums[2], ..., nums[n-1]
|
||||
for (int i = 1; i < size; i++)
|
||||
{
|
||||
int base = nums[i], j = i - 1;
|
||||
// 内循环：将 base 插入到左边的正确位置
|
||||
while (j >= 0 && nums[j] > base)
|
||||
{
|
||||
// 1. 将 nums[j] 向右移动一位
|
||||
nums[j + 1] = nums[j];
|
||||
j--;
|
||||
}
|
||||
// 2. 将 base 赋值到正确位置
|
||||
nums[j + 1] = base;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
@@ -159,17 +175,23 @@ 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)$ 时间。
|
||||
**时间复杂度 $O(n^2)$** ：最差情况下，各轮插入操作循环 $n - 1$ , $n-2$ , $\cdots$ , $2$ , $1$ 次，求和为 $\frac{(n - 1) n}{2}$ ，使用 $O(n^2)$ 时间。
|
||||
|
||||
**空间复杂度 $O(1)$ ：** 指针 $i$ , $j$ 使用常数大小的额外空间。
|
||||
**空间复杂度 $O(1)$** ：指针 $i$ , $j$ 使用常数大小的额外空间。
|
||||
|
||||
**原地排序：** 指针变量仅使用常数大小额外空间。
|
||||
**原地排序**：指针变量仅使用常数大小额外空间。
|
||||
|
||||
**稳定排序：** 不交换相等元素。
|
||||
**稳定排序**：不交换相等元素。
|
||||
|
||||
**自适应排序：** 最佳情况下，时间复杂度为 $O(n)$ 。
|
||||
**自适应排序**：最佳情况下，时间复杂度为 $O(n)$ 。
|
||||
|
||||
## 插入排序 vs 冒泡排序
|
||||
|
||||
@@ -177,7 +199,7 @@ comments: true
|
||||
|
||||
虽然「插入排序」和「冒泡排序」的时间复杂度皆为 $O(n^2)$ ，但实际运行速度却有很大差别，这是为什么呢？
|
||||
|
||||
回顾复杂度分析，两个方法的循环次数都是 $\frac{(n - 1) n}{2}$ 。但不同的是，「冒泡操作」是在做 **元素交换** ，需要借助一个临时变量实现，共 3 个单元操作；而「插入操作」是在做 **赋值** ，只需 1 个单元操作；因此，可以粗略估计出冒泡排序的计算开销约为插入排序的 3 倍。
|
||||
回顾复杂度分析，两个方法的循环次数都是 $\frac{(n - 1) n}{2}$ 。但不同的是，「冒泡操作」是在做 **元素交换**，需要借助一个临时变量实现，共 3 个单元操作；而「插入操作」是在做 **赋值**，只需 1 个单元操作；因此，可以粗略估计出冒泡排序的计算开销约为插入排序的 3 倍。
|
||||
|
||||
插入排序运行速度快，并且具有原地、稳定、自适应的优点，因此很受欢迎。实际上，包括 Java 在内的许多编程语言的排序库函数的实现都用到了插入排序。库函数的大致思路：
|
||||
|
||||
|
||||
@@ -7,7 +7,7 @@ comments: true
|
||||
「排序算法 Sorting Algorithm」使得列表中的所有元素按照从小到大的顺序排列。
|
||||
|
||||
- 待排序的列表的 **元素类型** 可以是整数、浮点数、字符、或字符串；
|
||||
- 排序算法可以根据需要设定 **判断规则** ，例如数字大小、字符 ASCII 码顺序、自定义规则；
|
||||
- 排序算法可以根据需要设定 **判断规则**，例如数字大小、字符 ASCII 码顺序、自定义规则；
|
||||
|
||||
|
||||
|
||||
@@ -22,7 +22,7 @@ comments: true
|
||||
- 「稳定排序」在完成排序后，**不改变** 相等元素在数组中的相对顺序。
|
||||
- 「非稳定排序」在完成排序后，相等元素在数组中的相对位置 **可能被改变**。
|
||||
|
||||
假设我们有一个存储学生信息当表格，第 1, 2 列分别是姓名和年龄。那么在以下示例中，「非稳定排序」会导致输入数据的有序性丢失。因此「稳定排序」是很好的特性，**在多级排序中是必须的**。
|
||||
假设我们有一个存储学生信息的表格，第 1, 2 列分别是姓名和年龄。那么在以下示例中，「非稳定排序」会导致输入数据的有序性丢失。因此「稳定排序」是很好的特性，**在多级排序中是必须的**。
|
||||
|
||||
```shell
|
||||
# 输入数据是按照姓名排序好的
|
||||
@@ -55,7 +55,7 @@ comments: true
|
||||
- 「自适应排序」的时间复杂度受输入数据影响，即最佳 / 最差 / 平均时间复杂度不相等。
|
||||
- 「非自适应排序」的时间复杂度恒定，与输入数据无关。
|
||||
|
||||
我们希望 **最差 = 平均** ，即不希望排序算法的运行效率在某些输入数据下发生劣化。
|
||||
我们希望 **最差 = 平均**，即不希望排序算法的运行效率在某些输入数据下发生劣化。
|
||||
|
||||
### 比较类
|
||||
|
||||
|
||||
@@ -6,8 +6,8 @@ comments: true
|
||||
|
||||
「归并排序 Merge Sort」是算法中“分治思想”的典型体现，其有「划分」和「合并」两个阶段：
|
||||
|
||||
1. **划分阶段：** 通过递归不断 **将数组从中点位置划分开**，将长数组的排序问题转化为短数组的排序问题；
|
||||
2. **合并阶段：** 划分到子数组长度为 1 时，开始向上合并，不断将 **左、右两个短排序数组** 合并为 **一个长排序数组**，直至合并至原数组时完成排序；
|
||||
1. **划分阶段**：通过递归不断 **将数组从中点位置划分开**，将长数组的排序问题转化为短数组的排序问题；
|
||||
2. **合并阶段**：划分到子数组长度为 1 时，开始向上合并，不断将 **左、右两个短排序数组** 合并为 **一个长排序数组**，直至合并至原数组时完成排序；
|
||||
|
||||
|
||||
|
||||
@@ -15,14 +15,14 @@ comments: true
|
||||
|
||||
## 算法流程
|
||||
|
||||
**「递归划分」** 从顶至底递归地 **将数组从中点切为两个子数组** ，直至长度为 1 ；
|
||||
**「递归划分」** 从顶至底递归地 **将数组从中点切为两个子数组**，直至长度为 1 ；
|
||||
|
||||
1. 计算数组中点 `mid` ，递归划分左子数组（区间 `[left, mid]` ）和右子数组（区间 `[mid + 1, right]` ）；
|
||||
2. 递归执行 `1.` 步骤，直至子数组区间长度为 1 时，终止递归划分；
|
||||
|
||||
**「回溯合并」** 从底至顶地将左子数组和右子数组合并为一个 **有序数组** ；
|
||||
|
||||
需要注意，由于从长度为 1 的子数组开始合并，所以 **每个子数组都是有序的** 。因此，合并任务本质是要 **将两个有序子数组合并为一个有序数组** 。
|
||||
需要注意，由于从长度为 1 的子数组开始合并，所以 **每个子数组都是有序的**。因此，合并任务本质是要 **将两个有序子数组合并为一个有序数组**。
|
||||
|
||||
=== "Step1"
|
||||
|
||||
@@ -56,8 +56,8 @@ comments: true
|
||||
|
||||
观察发现，归并排序的递归顺序就是二叉树的「后序遍历」。
|
||||
|
||||
- **后序遍历：** 先递归左子树、再递归右子树、最后处理根结点。
|
||||
- **归并排序：** 先递归左子树、再递归右子树、最后处理合并。
|
||||
- **后序遍历**：先递归左子树、再递归右子树、最后处理根结点。
|
||||
- **归并排序**：先递归左子树、再递归右子树、最后处理合并。
|
||||
|
||||
=== "Java"
|
||||
|
||||
@@ -81,10 +81,10 @@ comments: true
|
||||
// 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
|
||||
if (i > leftEnd)
|
||||
nums[k] = tmp[j++];
|
||||
// 否则，若“右子数组已全部合并完”或“左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
|
||||
// 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
|
||||
else if (j > rightEnd || tmp[i] <= tmp[j])
|
||||
nums[k] = tmp[i++];
|
||||
// 否则，若“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
|
||||
// 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
|
||||
else
|
||||
nums[k] = tmp[j++];
|
||||
}
|
||||
@@ -125,10 +125,10 @@ comments: true
|
||||
// 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
|
||||
if (i > leftEnd)
|
||||
nums[k] = tmp[j++];
|
||||
// 否则，若“右子数组已全部合并完”或“左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
|
||||
// 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
|
||||
else if (j > rightEnd || tmp[i] <= tmp[j])
|
||||
nums[k] = tmp[i++];
|
||||
// 否则，若“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
|
||||
// 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
|
||||
else
|
||||
nums[k] = tmp[j++];
|
||||
}
|
||||
@@ -170,11 +170,11 @@ comments: true
|
||||
if i > left_end:
|
||||
nums[k] = tmp[j]
|
||||
j += 1
|
||||
# 否则，若“右子数组已全部合并完”或“左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
|
||||
# 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
|
||||
elif j > right_end or tmp[i] <= tmp[j]:
|
||||
nums[k] = tmp[i]
|
||||
i += 1
|
||||
# 否则，若“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
|
||||
# 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
|
||||
else:
|
||||
nums[k] = tmp[j]
|
||||
j += 1
|
||||
@@ -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 {
|
||||
@@ -267,10 +266,10 @@ comments: true
|
||||
// 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
|
||||
if (i > leftEnd) {
|
||||
nums[k] = tmp[j++];
|
||||
// 否则，若“右子数组已全部合并完”或“左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
|
||||
// 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
|
||||
} else if (j > rightEnd || tmp[i] <= tmp[j]) {
|
||||
nums[k] = tmp[i++];
|
||||
// 否则，若“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
|
||||
// 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
|
||||
} else {
|
||||
nums[k] = tmp[j++];
|
||||
}
|
||||
@@ -312,10 +311,10 @@ comments: true
|
||||
// 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
|
||||
if (i > leftEnd) {
|
||||
nums[k] = tmp[j++];
|
||||
// 否则，若“右子数组已全部合并完”或“左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
|
||||
// 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
|
||||
} else if (j > rightEnd || tmp[i] <= tmp[j]) {
|
||||
nums[k] = tmp[i++];
|
||||
// 否则，若“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
|
||||
// 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
|
||||
} else {
|
||||
nums[k] = tmp[j++];
|
||||
}
|
||||
@@ -365,10 +364,10 @@ comments: true
|
||||
// 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
|
||||
if (i > leftEnd)
|
||||
nums[k] = tmp[j++];
|
||||
// 否则，若“右子数组已全部合并完”或“左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
|
||||
// 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
|
||||
else if (j > rightEnd || tmp[i] <= tmp[j])
|
||||
nums[k] = tmp[i++];
|
||||
// 否则，若“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
|
||||
// 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
|
||||
else
|
||||
nums[k] = tmp[j++];
|
||||
}
|
||||
@@ -388,6 +387,12 @@ comments: true
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="merge_sort.swift"
|
||||
|
||||
```
|
||||
|
||||
下面重点解释一下合并方法 `merge()` 的流程：
|
||||
|
||||
1. 初始化一个辅助数组 `tmp` 暂存待合并区间 `[left, right]` 内的元素，后续通过覆盖原数组 `nums` 的元素来实现合并；
|
||||
@@ -401,11 +406,11 @@ comments: true
|
||||
|
||||
## 算法特性
|
||||
|
||||
- **时间复杂度 $O(n \log n)$ ：** 划分形成高度为 $\log n$ 的递归树，每层合并的总操作数量为 $n$ ，总体使用 $O(n \log n)$ 时间。
|
||||
- **空间复杂度 $O(n)$ ：** 需借助辅助数组实现合并，使用 $O(n)$ 大小的额外空间；递归深度为 $\log n$ ，使用 $O(\log n)$ 大小的栈帧空间。
|
||||
- **非原地排序：** 辅助数组需要使用 $O(n)$ 额外空间。
|
||||
- **稳定排序：** 在合并时可保证相等元素的相对位置不变。
|
||||
- **非自适应排序：** 对于任意输入数据，归并排序的时间复杂度皆相同。
|
||||
- **时间复杂度 $O(n \log n)$** ：划分形成高度为 $\log n$ 的递归树，每层合并的总操作数量为 $n$ ，总体使用 $O(n \log n)$ 时间。
|
||||
- **空间复杂度 $O(n)$** ：需借助辅助数组实现合并，使用 $O(n)$ 大小的额外空间；递归深度为 $\log n$ ，使用 $O(\log n)$ 大小的栈帧空间。
|
||||
- **非原地排序**：辅助数组需要使用 $O(n)$ 额外空间。
|
||||
- **稳定排序**：在合并时可保证相等元素的相对位置不变。
|
||||
- **非自适应排序**：对于任意输入数据，归并排序的时间复杂度皆相同。
|
||||
|
||||
## 链表排序 *
|
||||
|
||||
|
||||
@@ -6,13 +6,13 @@ comments: true
|
||||
|
||||
「快速排序 Quick Sort」是一种基于“分治思想”的排序算法，速度很快、应用很广。
|
||||
|
||||
快速排序的核心操作为「哨兵划分」，其目标为：选取数组某个元素为 **基准数** ，将所有小于基准数的元素移动至其左边，大于基准数的元素移动至其右边。「哨兵划分」的实现流程为：
|
||||
快速排序的核心操作为「哨兵划分」，其目标为：选取数组某个元素为 **基准数**，将所有小于基准数的元素移动至其左边，大于基准数的元素移动至其右边。「哨兵划分」的实现流程为：
|
||||
|
||||
1. 以数组最左端元素作为基准数，初始化两个指针 `i` , `j` 指向数组两端；
|
||||
2. 设置一个循环，每轮中使用 `i` / `j` 分别寻找首个比基准数大 / 小的元素，并交换此两元素；
|
||||
3. 不断循环步骤 `2.` ，直至 `i` , `j` 相遇时跳出，最终把基准数交换至两个子数组的分界线；
|
||||
|
||||
「哨兵划分」执行完毕后，原数组被划分成两个部分，即 **左子数组** 和 **右子数组** ，且满足 **左子数组任意元素 < 基准数 < 右子数组任意元素**。因此，接下来我们只需要排序两个子数组即可。
|
||||
「哨兵划分」执行完毕后，原数组被划分成两个部分，即 **左子数组** 和 **右子数组**，且满足 **左子数组任意元素 < 基准数 < 右子数组任意元素**。因此，接下来我们只需要排序两个子数组即可。
|
||||
|
||||
=== "Step 1"
|
||||
|
||||
@@ -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,15 +223,21 @@ comments: true
|
||||
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="quick_sort.swift"
|
||||
|
||||
```
|
||||
|
||||
!!! note "快速排序的分治思想"
|
||||
|
||||
哨兵划分的实质是将 **一个长数组的排序问题** 简化为 **两个短数组的排序问题**。
|
||||
|
||||
## 算法流程
|
||||
|
||||
1. 首先，对数组执行一次「哨兵划分」，得到待排序的 **左子数组** 和 **右子数组** 。
|
||||
1. 首先，对数组执行一次「哨兵划分」，得到待排序的 **左子数组** 和 **右子数组**；
|
||||
2. 接下来，对 **左子数组** 和 **右子数组** 分别 **递归执行**「哨兵划分」……
|
||||
3. 直至子数组长度为 1 时 **终止递归** ，即可完成对整个数组的排序。
|
||||
3. 直至子数组长度为 1 时 **终止递归**，即可完成对整个数组的排序；
|
||||
|
||||
观察发现，快速排序和「二分查找」的原理类似，都是以对数阶的时间复杂度来缩小处理区间。
|
||||
|
||||
@@ -359,33 +365,39 @@ comments: true
|
||||
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="quick_sort.swift"
|
||||
|
||||
```
|
||||
|
||||
## 算法特性
|
||||
|
||||
**平均时间复杂度 $O(n \log n)$ ：** 平均情况下，哨兵划分的递归层数为 $\log n$ ，每层中的总循环数为 $n$ ，总体使用 $O(n \log n)$ 时间。
|
||||
**平均时间复杂度 $O(n \log n)$** ：平均情况下，哨兵划分的递归层数为 $\log n$ ，每层中的总循环数为 $n$ ，总体使用 $O(n \log n)$ 时间。
|
||||
|
||||
**最差时间复杂度 $O(n^2)$ ：** 最差情况下，哨兵划分操作将长度为 $n$ 的数组划分为长度为 $0$ 和 $n - 1$ 的两个子数组，此时递归层数达到 $n$ 层，每层中的循环数为 $n$ ，总体使用 $O(n^2)$ 时间。
|
||||
**最差时间复杂度 $O(n^2)$** ：最差情况下，哨兵划分操作将长度为 $n$ 的数组划分为长度为 $0$ 和 $n - 1$ 的两个子数组，此时递归层数达到 $n$ 层，每层中的循环数为 $n$ ，总体使用 $O(n^2)$ 时间。
|
||||
|
||||
**空间复杂度 $O(n)$ ：** 输入数组完全倒序下，达到最差递归深度 $n$ 。
|
||||
**空间复杂度 $O(n)$** ：输入数组完全倒序下，达到最差递归深度 $n$ 。
|
||||
|
||||
**原地排序：** 只在递归中使用 $O(\log n)$ 大小的栈帧空间。
|
||||
**原地排序**：只在递归中使用 $O(\log n)$ 大小的栈帧空间。
|
||||
|
||||
**非稳定排序：** 哨兵划分操作可能改变相等元素的相对位置。
|
||||
**非稳定排序**：哨兵划分操作可能改变相等元素的相对位置。
|
||||
|
||||
**自适应排序：** 最差情况下，时间复杂度劣化至 $O(n^2)$ 。
|
||||
**自适应排序**：最差情况下，时间复杂度劣化至 $O(n^2)$ 。
|
||||
|
||||
## 快排为什么快？
|
||||
|
||||
从命名能够看出，快速排序在效率方面一定“有两把刷子”。快速排序的平均时间复杂度虽然与「归并排序」和「堆排序」一致，但实际 **效率更高** ，这是因为：
|
||||
从命名能够看出，快速排序在效率方面一定“有两把刷子”。快速排序的平均时间复杂度虽然与「归并排序」和「堆排序」一致，但实际 **效率更高**，这是因为：
|
||||
|
||||
- **出现最差情况的概率很低：** 虽然快速排序的最差时间复杂度为 $O(n^2)$ ，不如归并排序，但绝大部分情况下，快速排序可以达到 $O(n \log n)$ 的复杂度。
|
||||
- **缓存使用效率高：** 哨兵划分操作时，将整个子数组加载入缓存中，访问元素效率很高。而诸如「堆排序」需要跳跃式访问元素，因此不具有此特性。
|
||||
- **复杂度的常数系数低：** 在提及的三种算法中，快速排序的 **比较**、**赋值**、**交换** 三种操作的总体数量最少（类似于「插入排序」快于「冒泡排序」的原因）。
|
||||
- **出现最差情况的概率很低**：虽然快速排序的最差时间复杂度为 $O(n^2)$ ，不如归并排序，但绝大部分情况下，快速排序可以达到 $O(n \log n)$ 的复杂度。
|
||||
- **缓存使用效率高**：哨兵划分操作时，将整个子数组加载入缓存中，访问元素效率很高。而诸如「堆排序」需要跳跃式访问元素，因此不具有此特性。
|
||||
- **复杂度的常数系数低**：在提及的三种算法中，快速排序的 **比较**、**赋值**、**交换** 三种操作的总体数量最少（类似于「插入排序」快于「冒泡排序」的原因）。
|
||||
|
||||
## 基准数优化
|
||||
|
||||
**普通快速排序在某些输入下的时间效率变差。** 举个极端例子，假设输入数组是完全倒序的，由于我们选取最左端元素为基准数，那么在哨兵划分完成后，基准数被交换至数组最右端，从而 **左子数组长度为 $n - 1$ 、右子数组长度为 $0$** 。这样进一步递归下去，**每轮哨兵划分后的右子数组长度都为 $0$** ，分治策略失效，快速排序退化为「冒泡排序」了。
|
||||
**普通快速排序在某些输入下的时间效率变差**。举个极端例子，假设输入数组是完全倒序的，由于我们选取最左端元素为基准数，那么在哨兵划分完成后，基准数被交换至数组最右端，从而 **左子数组长度为 $n - 1$、右子数组长度为 $0$** 。这样进一步递归下去，**每轮哨兵划分后的右子数组长度都为 $0$** ，分治策略失效，快速排序退化为「冒泡排序」了。
|
||||
|
||||
为了尽量避免这种情况发生，我们可以优化一下基准数的选取策略。首先，在哨兵划分中，我们可以 **随机选取一个元素作为基准数** 。但如果运气很差，每次都选择到比较差的基准数，那么效率依然不好。
|
||||
为了尽量避免这种情况发生，我们可以优化一下基准数的选取策略。首先，在哨兵划分中，我们可以 **随机选取一个元素作为基准数**。但如果运气很差，每次都选择到比较差的基准数，那么效率依然不好。
|
||||
|
||||
进一步地，我们可以在数组中选取 3 个候选元素（一般为数组的首、尾、中点元素），**并将三个候选元素的中位数作为基准数**，这样基准数“既不大也不小”的概率就大大提升了。当然，如果数组很长的话，我们也可以选取更多候选元素，来进一步提升算法的稳健性。采取该方法后，时间复杂度劣化至 $O(n^2)$ 的概率极低。
|
||||
|
||||
@@ -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"
|
||||
|
||||
```
|
||||
|
||||
@@ -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,23 +149,52 @@ comments: true
|
||||
=== "JavaScript"
|
||||
|
||||
```js title="deque.js"
|
||||
|
||||
|
||||
```
|
||||
|
||||
=== "TypeScript"
|
||||
|
||||
```typescript title="deque.ts"
|
||||
|
||||
|
||||
```
|
||||
|
||||
=== "C"
|
||||
|
||||
```c title="deque.c"
|
||||
|
||||
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
|
||||
```csharp title="deque.cs"
|
||||
/* 初始化双向队列 */
|
||||
// 在 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"
|
||||
|
||||
```
|
||||
|
||||
@@ -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;
|
||||
@@ -328,12 +334,14 @@ comments: true
|
||||
queSize++;
|
||||
}
|
||||
/* 出队 */
|
||||
int poll() {
|
||||
void poll() {
|
||||
int num = peek();
|
||||
// 删除头结点
|
||||
ListNode *tmp = front;
|
||||
front = front->next;
|
||||
// 释放内存
|
||||
delete tmp;
|
||||
queSize--;
|
||||
return num;
|
||||
}
|
||||
/* 访问队首元素 */
|
||||
int peek() {
|
||||
@@ -353,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
|
||||
@@ -375,7 +383,7 @@ comments: true
|
||||
self.__rear.next = node
|
||||
self.__rear = node
|
||||
self.__size += 1
|
||||
|
||||
|
||||
""" 出队 """
|
||||
def poll(self):
|
||||
num = self.peek()
|
||||
@@ -383,7 +391,7 @@ comments: true
|
||||
self.__front = self.__front.next
|
||||
self.__size -= 1
|
||||
return num
|
||||
|
||||
|
||||
""" 访问队首元素 """
|
||||
def peek(self):
|
||||
if self.size() == 0:
|
||||
@@ -396,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
|
||||
}
|
||||
```
|
||||
@@ -546,7 +560,7 @@ comments: true
|
||||
=== "C"
|
||||
|
||||
```c title="linkedlist_queue.c"
|
||||
|
||||
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
@@ -610,6 +624,12 @@ comments: true
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="linkedlist_queue.swift"
|
||||
|
||||
```
|
||||
|
||||
### 基于数组的实现
|
||||
|
||||
数组的删除首元素的时间复杂度为 $O(n)$ ，因此不适合直接用来实现队列。然而，我们可以借助两个指针 `front` , `rear` 来分别记录队首和队尾的索引位置，在入队 / 出队时分别将 `front` / `rear` 向后移动一位即可，这样每次仅需操作一个元素，时间复杂度降至 $O(1)$ 。
|
||||
@@ -628,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];
|
||||
@@ -684,7 +704,7 @@ comments: true
|
||||
int cap; // 队列容量
|
||||
int front = 0; // 头指针，指向队首
|
||||
int rear = 0; // 尾指针，指向队尾 + 1
|
||||
|
||||
|
||||
public:
|
||||
ArrayQueue(int capacity) {
|
||||
// 初始化数组
|
||||
@@ -716,11 +736,10 @@ comments: true
|
||||
rear = (rear + 1) % capacity();
|
||||
}
|
||||
/* 出队 */
|
||||
int poll() {
|
||||
void poll() {
|
||||
int num = peek();
|
||||
// 队头指针向后移动一位，若越过尾部则返回到数组头部
|
||||
front = (front + 1) % capacity();
|
||||
return num;
|
||||
}
|
||||
/* 访问队首元素 */
|
||||
int peek() {
|
||||
@@ -740,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():
|
||||
@@ -763,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()
|
||||
@@ -792,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
|
||||
}
|
||||
// 尾结点后添加
|
||||
@@ -827,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]
|
||||
@@ -837,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]
|
||||
@@ -949,7 +974,7 @@ comments: true
|
||||
=== "C"
|
||||
|
||||
```c title="array_queue.c"
|
||||
|
||||
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
@@ -1014,7 +1039,13 @@ comments: true
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="array_queue.swift"
|
||||
|
||||
```
|
||||
|
||||
## 队列典型应用
|
||||
|
||||
- **淘宝订单。** 购物者下单后，订单就被加入到队列之中，随后系统再根据顺序依次处理队列中的订单。在双十一时，在短时间内会产生海量的订单，如何处理「高并发」则是工程师们需要重点思考的问题。
|
||||
- **各种待办事项。** 例如打印机的任务队列、餐厅的出餐队列等等。
|
||||
- **淘宝订单**。购物者下单后，订单就被加入到队列之中，随后系统再根据顺序依次处理队列中的订单。在双十一时，在短时间内会产生海量的订单，如何处理「高并发」则是工程师们需要重点思考的问题。
|
||||
- **各种待办事项**。例如打印机的任务队列、餐厅的出餐队列等等。
|
||||
|
||||
@@ -6,7 +6,9 @@ comments: true
|
||||
|
||||
「栈 Stack」是一种遵循「先入后出 first in, last out」数据操作规则的线性数据结构。我们可以将栈类比为放在桌面上的一摞盘子，如果需要拿出底部的盘子，则需要先将上面的盘子依次取出。
|
||||
|
||||
我们将顶部盘子称为「栈顶」，底部盘子称为「栈底」，将把元素添加到栈顶的操作称为「入栈」，将删除栈顶元素的操作称为「出栈」。
|
||||
“盘子”是一种形象比喻，我们将盘子替换为任意一种元素（例如整数、字符、对象等），就得到了栈数据结构。
|
||||
|
||||
我们将这一摞元素的顶部称为「栈顶」，将底部称为「栈底」，将把元素添加到栈顶的操作称为「入栈」，将删除栈顶元素的操作称为「出栈」。
|
||||
|
||||
|
||||
|
||||
@@ -14,7 +16,7 @@ comments: true
|
||||
|
||||
## 栈常用操作
|
||||
|
||||
栈的常用操作见下表，方法名需根据编程语言设定来具体确定。
|
||||
栈的常用操作见下表（方法命名以 Java 为例）。
|
||||
|
||||
<p align="center"> Table. 栈的常用操作 </p>
|
||||
|
||||
@@ -38,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();
|
||||
```
|
||||
@@ -64,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();
|
||||
```
|
||||
@@ -91,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
|
||||
```
|
||||
@@ -118,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
|
||||
```
|
||||
@@ -146,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;
|
||||
```
|
||||
@@ -173,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;
|
||||
```
|
||||
@@ -197,7 +199,7 @@ comments: true
|
||||
=== "C"
|
||||
|
||||
```c title="stack.c"
|
||||
|
||||
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
@@ -205,27 +207,54 @@ 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"
|
||||
/* 初始化栈 */
|
||||
// Swift 没有内置的栈类，可以把 Array 当作栈来使用
|
||||
var stack: [Int] = []
|
||||
|
||||
/* 元素入栈 */
|
||||
stack.append(1)
|
||||
stack.append(3)
|
||||
stack.append(2)
|
||||
stack.append(5)
|
||||
stack.append(4)
|
||||
|
||||
/* 访问栈顶元素 */
|
||||
let peek = stack.last!
|
||||
|
||||
/* 元素出栈 */
|
||||
let pop = stack.removeLast()
|
||||
|
||||
/* 获取栈的长度 */
|
||||
let size = stack.count
|
||||
|
||||
/* 判断是否为空 */
|
||||
let isEmpty = stack.isEmpty
|
||||
```
|
||||
|
||||
## 栈的实现
|
||||
|
||||
为了更加清晰地了解栈的运行机制，接下来我们来自己动手实现一个栈类。
|
||||
@@ -234,7 +263,9 @@ comments: true
|
||||
|
||||
### 基于链表的实现
|
||||
|
||||
使用「链表」实现栈时，将链表的尾结点看作栈顶即可。
|
||||
使用「链表」实现栈时，将链表的头结点看作栈顶，尾结点看作栈底。
|
||||
|
||||
对于入栈操作，将元素插入到链表头部即可，这种结点添加方式被称为“头插法”。而对于出栈操作，则将头结点从链表中删除即可。
|
||||
|
||||
受益于链表的离散存储方式，栈的扩容更加灵活，删除元素的内存也会被系统自动回收；缺点是无法像数组一样高效地随机访问，并且由于链表结点需存储指针，导致单个元素占用空间更大。
|
||||
|
||||
@@ -287,7 +318,7 @@ comments: true
|
||||
private:
|
||||
ListNode* stackTop; // 将头结点作为栈顶
|
||||
int stkSize; // 栈的长度
|
||||
|
||||
|
||||
public:
|
||||
LinkedListStack() {
|
||||
stackTop = nullptr;
|
||||
@@ -309,11 +340,13 @@ comments: true
|
||||
stkSize++;
|
||||
}
|
||||
/* 出栈 */
|
||||
int pop() {
|
||||
void pop() {
|
||||
int num = top();
|
||||
ListNode *tmp = stackTop;
|
||||
stackTop = stackTop->next;
|
||||
// 释放内存
|
||||
delete tmp;
|
||||
stkSize--;
|
||||
return num;
|
||||
}
|
||||
/* 访问栈顶元素 */
|
||||
int top() {
|
||||
@@ -332,29 +365,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):
|
||||
# 判空处理
|
||||
@@ -366,43 +399,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
|
||||
}
|
||||
```
|
||||
@@ -414,21 +453,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);
|
||||
@@ -436,7 +475,7 @@ comments: true
|
||||
this.#stackPeek = node;
|
||||
this.#stkSize++;
|
||||
}
|
||||
|
||||
|
||||
/* 出栈 */
|
||||
pop() {
|
||||
const num = this.peek();
|
||||
@@ -447,7 +486,7 @@ comments: true
|
||||
this.#stkSize--;
|
||||
return num;
|
||||
}
|
||||
|
||||
|
||||
/* 访问栈顶元素 */
|
||||
peek() {
|
||||
if (!this.#stackPeek) {
|
||||
@@ -455,7 +494,7 @@ comments: true
|
||||
}
|
||||
return this.#stackPeek.val;
|
||||
}
|
||||
|
||||
|
||||
/* 将链表转化为 Array 并返回 */
|
||||
toArray() {
|
||||
let node = this.#stackPeek;
|
||||
@@ -476,21 +515,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);
|
||||
@@ -498,7 +537,7 @@ comments: true
|
||||
this.stackPeek = node;
|
||||
this.stkSize++;
|
||||
}
|
||||
|
||||
|
||||
/* 出栈 */
|
||||
pop(): number {
|
||||
const num = this.peek();
|
||||
@@ -509,7 +548,7 @@ comments: true
|
||||
this.stkSize--;
|
||||
return num;
|
||||
}
|
||||
|
||||
|
||||
/* 访问栈顶元素 */
|
||||
peek(): number {
|
||||
if (!this.stackPeek) {
|
||||
@@ -517,7 +556,7 @@ comments: true
|
||||
}
|
||||
return this.stackPeek.val;
|
||||
}
|
||||
|
||||
|
||||
/* 将链表转化为 Array 并返回 */
|
||||
toArray(): number[] {
|
||||
let node = this.stackPeek;
|
||||
@@ -534,7 +573,7 @@ comments: true
|
||||
=== "C"
|
||||
|
||||
```c title="linkedlist_stack.c"
|
||||
|
||||
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
@@ -585,9 +624,66 @@ comments: true
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="linkedlist_stack.swift"
|
||||
/* 基于链表实现的栈 */
|
||||
class LinkedListStack {
|
||||
private var _peek: ListNode? // 将头结点作为栈顶
|
||||
private var _size = 0 // 栈的长度
|
||||
|
||||
init() {}
|
||||
|
||||
/* 获取栈的长度 */
|
||||
func size() -> Int {
|
||||
_size
|
||||
}
|
||||
|
||||
/* 判断栈是否为空 */
|
||||
func isEmpty() -> Bool {
|
||||
_size == 0
|
||||
}
|
||||
|
||||
/* 入栈 */
|
||||
func push(num: Int) {
|
||||
let node = ListNode(x: num)
|
||||
node.next = _peek
|
||||
_peek = node
|
||||
_size += 1
|
||||
}
|
||||
|
||||
/* 出栈 */
|
||||
func pop() -> Int {
|
||||
let num = peek()
|
||||
_peek = _peek?.next
|
||||
_size -= 1
|
||||
return num
|
||||
}
|
||||
|
||||
/* 访问栈顶元素 */
|
||||
func peek() -> Int {
|
||||
if _size == 0 {
|
||||
fatalError("栈为空")
|
||||
}
|
||||
return _peek!.val
|
||||
}
|
||||
|
||||
/* 将 List 转化为 Array 并返回 */
|
||||
func toArray() -> [Int] {
|
||||
var node = _peek
|
||||
var res = Array(repeating: 0, count: _size)
|
||||
for i in sequence(first: res.count - 1, next: { $0 >= 0 + 1 ? $0 - 1 : nil }) {
|
||||
res[i] = node!.val
|
||||
node = node?.next
|
||||
}
|
||||
return res
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### 基于数组的实现
|
||||
|
||||
使用「数组」实现栈时，将数组的尾部当作栈顶。准确地说，我们需要使用「列表」，因为入栈的元素可能是源源不断的，因此使用动态数组可以方便扩容。
|
||||
使用「数组」实现栈时，将数组的尾部当作栈顶，这样可以保证入栈与出栈操作的时间复杂度都为 $O(1)$ 。准确地说，由于入栈的元素可能是源源不断的，我们需要使用可以动态扩容的「列表」。
|
||||
|
||||
基于数组实现的栈，优点是支持随机访问，缺点是会造成一定的空间浪费，因为列表的容量始终 $\geq$ 元素数量。
|
||||
|
||||
@@ -650,10 +746,9 @@ comments: true
|
||||
stack.push_back(num);
|
||||
}
|
||||
/* 出栈 */
|
||||
int pop() {
|
||||
void pop() {
|
||||
int oldTop = top();
|
||||
stack.pop_back();
|
||||
return oldTop;
|
||||
}
|
||||
/* 访问栈顶元素 */
|
||||
int top() {
|
||||
@@ -671,24 +766,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(), "栈为空"
|
||||
@@ -699,41 +794,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]
|
||||
@@ -816,7 +917,7 @@ comments: true
|
||||
=== "C"
|
||||
|
||||
```c title="array_stack.c"
|
||||
|
||||
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
@@ -865,11 +966,61 @@ comments: true
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="array_stack.swift"
|
||||
/* 基于数组实现的栈 */
|
||||
class ArrayStack {
|
||||
private var stack: [Int]
|
||||
|
||||
init() {
|
||||
// 初始化列表（动态数组）
|
||||
stack = []
|
||||
}
|
||||
|
||||
/* 获取栈的长度 */
|
||||
func size() -> Int {
|
||||
stack.count
|
||||
}
|
||||
|
||||
/* 判断栈是否为空 */
|
||||
func isEmpty() -> Bool {
|
||||
stack.isEmpty
|
||||
}
|
||||
|
||||
/* 入栈 */
|
||||
func push(num: Int) {
|
||||
stack.append(num)
|
||||
}
|
||||
|
||||
/* 出栈 */
|
||||
func pop() -> Int {
|
||||
if stack.isEmpty {
|
||||
fatalError("栈为空")
|
||||
}
|
||||
return stack.removeLast()
|
||||
}
|
||||
|
||||
/* 访问栈顶元素 */
|
||||
func peek() -> Int {
|
||||
if stack.isEmpty {
|
||||
fatalError("栈为空")
|
||||
}
|
||||
return stack.last!
|
||||
}
|
||||
|
||||
/* 将 List 转化为 Array 并返回 */
|
||||
func toArray() -> [Int] {
|
||||
stack
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
!!! tip
|
||||
|
||||
实际编程中，我们一般直接将 `ArrayList` 或 `LinkedList` 当作「栈」来使用。我们仅需通过脑补来屏蔽无关操作，而不用专门去包装它。
|
||||
某些语言并未专门提供栈类，但我们可以直接把该语言的「数组」或「链表」看作栈来使用，并通过“脑补”来屏蔽无关操作，而无需像上述代码去特意包装一层。
|
||||
|
||||
## 栈典型应用
|
||||
|
||||
- **浏览器中的后退与前进、软件中的撤销与反撤销。** 每当我们打开新的网页，浏览器就讲上一个网页执行入栈，这样我们就可以通过「后退」操作来回到上一页面，后退操作实际上是在执行出栈。如果要同时支持后退和前进，那么则需要两个栈来配合实现。
|
||||
- **程序内存管理。** 每当调用函数时，系统就会在栈顶添加一个栈帧，用来记录函数的上下文信息。在递归函数中，向下递推会不断执行入栈，向上回溯阶段时出栈。
|
||||
- **浏览器中的后退与前进、软件中的撤销与反撤销**。每当我们打开新的网页，浏览器就将上一个网页执行入栈，这样我们就可以通过「后退」操作来回到上一页面，后退操作实际上是在执行出栈。如果要同时支持后退和前进，那么则需要两个栈来配合实现。
|
||||
- **程序内存管理**。每当调用函数时，系统就会在栈顶添加一个栈帧，用来记录函数的上下文信息。在递归函数中，向下递推会不断执行入栈，向上回溯阶段时出栈。
|
||||
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 77 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 86 KiB After Width: | Height: | Size: 90 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 56 KiB After Width: | Height: | Size: 55 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 59 KiB After Width: | Height: | Size: 60 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 67 KiB After Width: | Height: | Size: 70 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 89 KiB After Width: | Height: | Size: 91 KiB |
+346
-46
@@ -48,13 +48,25 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
|
||||
=== "Python"
|
||||
|
||||
```python title="avl_tree.py"
|
||||
|
||||
""" AVL 树结点类 """
|
||||
class TreeNode:
|
||||
def __init__(self, val=None, left=None, right=None):
|
||||
self.val = val # 结点值
|
||||
self.height = 0 # 结点高度
|
||||
self.left = left # 左子结点引用
|
||||
self.right = right # 右子结点引用
|
||||
```
|
||||
|
||||
=== "Go"
|
||||
|
||||
```go title="avl_tree.go"
|
||||
|
||||
/* AVL 树结点类 */
|
||||
type TreeNode struct {
|
||||
Val int // 结点值
|
||||
Height int // 结点高度
|
||||
Left *TreeNode // 左子结点引用
|
||||
Right *TreeNode // 右子结点引用
|
||||
}
|
||||
```
|
||||
|
||||
=== "JavaScript"
|
||||
@@ -88,7 +100,13 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
|
||||
}
|
||||
```
|
||||
|
||||
「结点高度」是最远叶结点到该结点的距离，即走过的「边」的数量。需要特别注意，**叶结点的高度为 0 ，空结点的高度为 -1** 。我们封装两个工具函数，分别用于获取与更新结点的高度。
|
||||
=== "Swift"
|
||||
|
||||
```swift title="avl_tree.swift"
|
||||
|
||||
```
|
||||
|
||||
「结点高度」是最远叶结点到该结点的距离，即走过的「边」的数量。需要特别注意，**叶结点的高度为 0 ，空结点的高度为 -1**。我们封装两个工具函数，分别用于获取与更新结点的高度。
|
||||
|
||||
=== "Java"
|
||||
|
||||
@@ -115,13 +133,42 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
|
||||
=== "Python"
|
||||
|
||||
```python title="avl_tree.py"
|
||||
""" 获取结点高度 """
|
||||
def height(self, node: Optional[TreeNode]) -> int:
|
||||
# 空结点高度为 -1 ，叶结点高度为 0
|
||||
if node is not None:
|
||||
return node.height
|
||||
return -1
|
||||
|
||||
""" 更新结点高度 """
|
||||
def __update_height(self, node: Optional[TreeNode]):
|
||||
# 结点高度等于最高子树高度 + 1
|
||||
node.height = max([self.height(node.left), self.height(node.right)]) + 1
|
||||
```
|
||||
|
||||
=== "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"
|
||||
@@ -151,7 +198,7 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
|
||||
// 空结点高度为 -1 ，叶结点高度为 0
|
||||
return node == null ? -1 : node.height;
|
||||
}
|
||||
|
||||
|
||||
/* 更新结点高度 */
|
||||
private void updateHeight(TreeNode node)
|
||||
{
|
||||
@@ -160,6 +207,12 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="avl_tree.swift"
|
||||
|
||||
```
|
||||
|
||||
### 结点平衡因子
|
||||
|
||||
结点的「平衡因子 Balance Factor」是 **结点的左子树高度减去右子树高度**，并定义空结点的平衡因子为 0 。同样地，我们将获取结点平衡因子封装成函数，以便后续使用。
|
||||
@@ -185,13 +238,27 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
|
||||
=== "Python"
|
||||
|
||||
```python title="avl_tree.py"
|
||||
|
||||
""" 获取平衡因子 """
|
||||
def balance_factor(self, node: Optional[TreeNode]) -> int:
|
||||
# 空结点平衡因子为 0
|
||||
if node is None:
|
||||
return 0
|
||||
# 结点平衡因子 = 左子树高度 - 右子树高度
|
||||
return self.height(node.left) - self.height(node.right)
|
||||
```
|
||||
|
||||
=== "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"
|
||||
@@ -225,19 +292,25 @@ 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$ 的结点称为「失衡结点」。根据结点的失衡情况，旋转操作分为 **右旋、左旋、先右旋后左旋、先左旋后右旋**，接下来我们来一起来看看它们是如何操作的。
|
||||
|
||||
### Case 1 - 右旋
|
||||
|
||||
如下图所示（结点下方为「平衡因子」），从底至顶看，二叉树中首个失衡结点是 **结点 3** 。我们聚焦在以该失衡结点为根结点的子树上，将该结点记为 `node` ，将其左子节点记为 `child` ，执行「右旋」操作。完成右旋后，该子树已经恢复平衡，并且仍然为二叉搜索树。
|
||||
如下图所示（结点下方为「平衡因子」），从底至顶看，二叉树中首个失衡结点是 **结点 3**。我们聚焦在以该失衡结点为根结点的子树上，将该结点记为 `node` ，将其左子节点记为 `child` ，执行「右旋」操作。完成右旋后，该子树已经恢复平衡，并且仍然为二叉搜索树。
|
||||
|
||||
=== "Step 1"
|
||||
|
||||
@@ -281,13 +354,36 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
|
||||
=== "Python"
|
||||
|
||||
```python title="avl_tree.py"
|
||||
|
||||
""" 右旋操作 """
|
||||
def __right_rotate(self, node: Optional[TreeNode]) -> TreeNode:
|
||||
child = node.left
|
||||
grand_child = child.right
|
||||
# 以 child 为原点，将 node 向右旋转
|
||||
child.right = node
|
||||
node.left = grand_child
|
||||
# 更新结点高度
|
||||
self.__update_height(node)
|
||||
self.__update_height(child)
|
||||
# 返回旋转后子树的根节点
|
||||
return child
|
||||
```
|
||||
|
||||
=== "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"
|
||||
@@ -328,13 +424,23 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
|
||||
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="avl_tree.swift"
|
||||
|
||||
```
|
||||
|
||||
### Case 2 - 左旋
|
||||
|
||||
类似地，如果将取上述失衡二叉树的“镜像”，那么则需要「左旋」操作。观察发现，**「左旋」和「右旋」操作是镜像对称的，两者对应解决的两种失衡情况也是对称的**。
|
||||
类似地，如果将取上述失衡二叉树的“镜像”，那么则需要「左旋」操作。
|
||||
|
||||
|
||||
|
||||
同理，若结点 `child` 本身有左子结点（记为 `grandChild`），则需要在「左旋」中添加一步：将 `grandChild` 作为 `node` 的右子结点。
|
||||
|
||||
|
||||
|
||||
根据对称性，我们可以很方便地从「右旋」推导出「左旋」。具体地，把所有的 `left` 替换为 `right` 、所有的 `right` 替换为 `left` 即可。
|
||||
观察发现，**「左旋」和「右旋」操作是镜像对称的，两者对应解决的两种失衡情况也是对称的**。根据对称性，我们可以很方便地从「右旋」推导出「左旋」。具体地，只需将「右旋」代码中的把所有的 `left` 替换为 `right` 、所有的 `right` 替换为 `left` ，即可得到「左旋」代码。
|
||||
|
||||
=== "Java"
|
||||
|
||||
@@ -363,13 +469,36 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
|
||||
=== "Python"
|
||||
|
||||
```python title="avl_tree.py"
|
||||
|
||||
""" 左旋操作 """
|
||||
def __left_rotate(self, node: Optional[TreeNode]) -> TreeNode:
|
||||
child = node.right
|
||||
grand_child = child.left
|
||||
# 以 child 为原点，将 node 向左旋转
|
||||
child.left = node
|
||||
node.right = grand_child
|
||||
# 更新结点高度
|
||||
self.__update_height(node)
|
||||
self.__update_height(child)
|
||||
# 返回旋转后子树的根节点
|
||||
return child
|
||||
```
|
||||
|
||||
=== "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"
|
||||
@@ -409,6 +538,12 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="avl_tree.swift"
|
||||
|
||||
```
|
||||
|
||||
### Case 3 - 先左后右
|
||||
|
||||
对于下图的失衡结点 3 ，**单一使用左旋或右旋都无法使子树恢复平衡**，此时需要「先左旋后右旋」，即先对 `child` 执行「左旋」，再对 `node` 执行「右旋」。
|
||||
@@ -423,11 +558,11 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
|
||||
|
||||
### 旋转的选择
|
||||
|
||||
下图描述的四种失衡情况与上述 Cases 一一对应，分别采用右旋、左旋、先右后左、先左后右的旋转组合。
|
||||
下图描述的四种失衡情况与上述 Cases 逐个对应，分别需采用 **右旋、左旋、先右后左、先左后右** 的旋转操作。
|
||||
|
||||
|
||||
|
||||
具体地，需要使用 **失衡结点的平衡因子、较高一侧子结点的平衡因子** 来确定失衡结点属于上图中的哪种情况。
|
||||
具体地，在代码中使用 **失衡结点的平衡因子、较高一侧子结点的平衡因子** 来确定失衡结点属于上图中的哪种情况。
|
||||
|
||||
<div class="center-table" markdown>
|
||||
|
||||
@@ -440,7 +575,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
|
||||
|
||||
</div>
|
||||
|
||||
根据以上规则，我们将旋转操作封装成一个函数。至此，**我们可以使用此函数来旋转各种失衡情况，使失衡结点重新恢复平衡**。
|
||||
为方便使用，我们将旋转操作封装成一个函数。至此，**我们可以使用此函数来旋转各种失衡情况，使失衡结点重新恢复平衡**。
|
||||
|
||||
=== "Java"
|
||||
|
||||
@@ -485,13 +620,65 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
|
||||
=== "Python"
|
||||
|
||||
```python title="avl_tree.py"
|
||||
|
||||
""" 执行旋转操作，使该子树重新恢复平衡 """
|
||||
def __rotate(self, node: Optional[TreeNode]) -> TreeNode:
|
||||
# 获取结点 node 的平衡因子
|
||||
balance_factor = self.balance_factor(node)
|
||||
# 左偏树
|
||||
if balance_factor > 1:
|
||||
if self.balance_factor(node.left) >= 0:
|
||||
# 右旋
|
||||
return self.__right_rotate(node)
|
||||
else:
|
||||
# 先左旋后右旋
|
||||
node.left = self.__left_rotate(node.left)
|
||||
return self.__right_rotate(node)
|
||||
# 右偏树
|
||||
elif balance_factor < -1:
|
||||
if self.balance_factor(node.right) <= 0:
|
||||
# 左旋
|
||||
return self.__left_rotate(node)
|
||||
else:
|
||||
# 先右旋后左旋
|
||||
node.right = self.__right_rotate(node.right)
|
||||
return self.__left_rotate(node)
|
||||
# 平衡树，无需旋转，直接返回
|
||||
return node
|
||||
```
|
||||
|
||||
=== "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"
|
||||
@@ -555,6 +742,12 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="avl_tree.swift"
|
||||
|
||||
```
|
||||
|
||||
## AVL 树常用操作
|
||||
|
||||
### 插入结点
|
||||
@@ -597,13 +790,58 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
|
||||
=== "Python"
|
||||
|
||||
```python title="avl_tree.py"
|
||||
""" 插入结点 """
|
||||
def insert(self, val) -> TreeNode:
|
||||
self.root = self.__insert_helper(self.root, val)
|
||||
return self.root
|
||||
|
||||
""" 递归插入结点（辅助函数）"""
|
||||
def __insert_helper(self, node: Optional[TreeNode], val: int) -> TreeNode:
|
||||
if node is None:
|
||||
return TreeNode(val)
|
||||
# 1. 查找插入位置，并插入结点
|
||||
if val < node.val:
|
||||
node.left = self.__insert_helper(node.left, val)
|
||||
elif val > node.val:
|
||||
node.right = self.__insert_helper(node.right, val)
|
||||
else:
|
||||
# 重复结点不插入，直接返回
|
||||
return node
|
||||
# 更新结点高度
|
||||
self.__update_height(node)
|
||||
# 2. 执行旋转操作，使该子树重新恢复平衡
|
||||
return self.__rotate(node)
|
||||
```
|
||||
|
||||
=== "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"
|
||||
@@ -633,7 +871,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
|
||||
root = insertHelper(root, val);
|
||||
return root;
|
||||
}
|
||||
|
||||
|
||||
/* 递归插入结点（辅助函数） */
|
||||
private TreeNode? insertHelper(TreeNode? node, int val)
|
||||
{
|
||||
@@ -653,6 +891,12 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="avl_tree.swift"
|
||||
|
||||
```
|
||||
|
||||
### 删除结点
|
||||
|
||||
「AVL 树」删除结点操作与「二叉搜索树」删除结点操作总体相同。类似地，**在删除结点后，也需要从底至顶地执行旋转操作，使所有失衡结点恢复平衡**。
|
||||
@@ -685,7 +929,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
|
||||
node = child;
|
||||
} else {
|
||||
// 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
|
||||
TreeNode temp = minNode(node.right);
|
||||
TreeNode temp = getInOrderNext(node.right);
|
||||
node.right = removeHelper(node.right, temp.val);
|
||||
node.val = temp.val;
|
||||
}
|
||||
@@ -696,16 +940,6 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
|
||||
// 返回子树的根节点
|
||||
return node;
|
||||
}
|
||||
|
||||
/* 获取最小结点 */
|
||||
TreeNode minNode(TreeNode node) {
|
||||
if (node == null) return node;
|
||||
// 循环访问左子结点，直到叶结点时为最小结点，跳出
|
||||
while (node.left != null) {
|
||||
node = node.left;
|
||||
}
|
||||
return node;
|
||||
}
|
||||
```
|
||||
|
||||
=== "C++"
|
||||
@@ -717,13 +951,85 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
|
||||
=== "Python"
|
||||
|
||||
```python title="avl_tree.py"
|
||||
""" 删除结点 """
|
||||
def remove(self, val: int):
|
||||
root = self.__remove_helper(self.root, val)
|
||||
return root
|
||||
|
||||
""" 递归删除结点（辅助函数） """
|
||||
def __remove_helper(self, node: Optional[TreeNode], val: int) -> Optional[TreeNode]:
|
||||
if node is None:
|
||||
return None
|
||||
# 1. 查找结点，并删除之
|
||||
if val < node.val:
|
||||
node.left = self.__remove_helper(node.left, val)
|
||||
elif val > node.val:
|
||||
node.right = self.__remove_helper(node.right, val)
|
||||
else:
|
||||
if node.left is None or node.right is None:
|
||||
child = node.left or node.right
|
||||
# 子结点数量 = 0 ，直接删除 node 并返回
|
||||
if child is None:
|
||||
return None
|
||||
# 子结点数量 = 1 ，直接删除 node
|
||||
else:
|
||||
node = child
|
||||
else: # 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
|
||||
temp = self.__get_inorder_next(node.right)
|
||||
node.right = self.__remove_helper(node.right, temp.val)
|
||||
node.val = temp.val
|
||||
# 更新结点高度
|
||||
self.__update_height(node)
|
||||
# 2. 执行旋转操作，使该子树重新恢复平衡
|
||||
return self.__rotate(node)
|
||||
```
|
||||
|
||||
=== "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"
|
||||
@@ -753,7 +1059,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
|
||||
root = removeHelper(root, val);
|
||||
return root;
|
||||
}
|
||||
|
||||
|
||||
/* 递归删除结点（辅助函数） */
|
||||
private TreeNode? removeHelper(TreeNode? node, int val)
|
||||
{
|
||||
@@ -778,7 +1084,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
|
||||
else
|
||||
{
|
||||
// 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
|
||||
TreeNode? temp = minNode(node.right);
|
||||
TreeNode? temp = getInOrderNext(node.right);
|
||||
node.right = removeHelper(node.right, temp.val);
|
||||
node.val = temp.val;
|
||||
}
|
||||
@@ -789,18 +1095,12 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
|
||||
// 返回子树的根节点
|
||||
return node;
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="avl_tree.swift"
|
||||
|
||||
/* 获取最小结点 */
|
||||
private TreeNode? minNode(TreeNode? node)
|
||||
{
|
||||
if (node == null) return node;
|
||||
// 循环访问左子结点，直到叶结点时为最小结点，跳出
|
||||
while (node.left != null)
|
||||
{
|
||||
node = node.left;
|
||||
}
|
||||
return node;
|
||||
}
|
||||
```
|
||||
|
||||
### 查找结点
|
||||
|
||||
@@ -17,9 +17,9 @@ comments: true
|
||||
|
||||
给定目标结点值 `num` ，可以根据二叉搜索树的性质来查找。我们声明一个结点 `cur` ，从二叉树的根结点 `root` 出发，循环比较结点值 `cur.val` 和 `num` 之间的大小关系
|
||||
|
||||
- 若 `cur.val < val` ，说明目标结点在 `cur` 的右子树中，因此执行 `cur = cur.right` ；
|
||||
- 若 `cur.val > val` ，说明目标结点在 `cur` 的左子树中，因此执行 `cur = cur.left` ；
|
||||
- 若 `cur.val = val` ，说明找到目标结点，跳出循环并返回该结点即可；
|
||||
- 若 `cur.val < num` ，说明目标结点在 `cur` 的右子树中，因此执行 `cur = cur.right` ；
|
||||
- 若 `cur.val > num` ，说明目标结点在 `cur` 的左子树中，因此执行 `cur = cur.left` ；
|
||||
- 若 `cur.val = num` ，说明找到目标结点，跳出循环并返回该结点即可；
|
||||
|
||||
=== "Step 1"
|
||||
|
||||
@@ -82,14 +82,28 @@ comments: true
|
||||
=== "Python"
|
||||
|
||||
```python title="binary_search_tree.py"
|
||||
|
||||
""" 查找结点 """
|
||||
def search(self, num: int) -> Optional[TreeNode]:
|
||||
cur = self.root
|
||||
# 循环查找，越过叶结点后跳出
|
||||
while cur is not None:
|
||||
# 目标结点在 root 的右子树中
|
||||
if cur.val < num:
|
||||
cur = cur.right
|
||||
# 目标结点在 root 的左子树中
|
||||
elif cur.val > num:
|
||||
cur = cur.left
|
||||
# 找到目标结点，跳出循环
|
||||
else:
|
||||
break
|
||||
return cur
|
||||
```
|
||||
|
||||
=== "Go"
|
||||
|
||||
```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 {
|
||||
@@ -178,12 +192,18 @@ comments: true
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="binary_search_tree.swift"
|
||||
|
||||
```
|
||||
|
||||
### 插入结点
|
||||
|
||||
给定一个待插入元素 `num` ，为了保持二叉搜索树“左子树 < 根结点 < 右子树”的性质，插入操作分为两步：
|
||||
|
||||
1. **查找插入位置：** 与查找操作类似，我们从根结点出发，根据当前结点值和 `num` 的大小关系循环向下搜索，直到越过叶结点（遍历到 $\text{null}$ ）时跳出循环；
|
||||
2. **在该位置插入结点：** 初始化结点 `num` ，将该结点放到 $\text{null}$ 的位置 ；
|
||||
1. **查找插入位置**：与查找操作类似，我们从根结点出发，根据当前结点值和 `num` 的大小关系循环向下搜索，直到越过叶结点（遍历到 $\text{null}$ ）时跳出循环；
|
||||
2. **在该位置插入结点**：初始化结点 `num` ，将该结点放到 $\text{null}$ 的位置 ；
|
||||
|
||||
二叉搜索树不允许存在重复结点，否则将会违背其定义。因此若待插入结点在树中已经存在，则不执行插入，直接返回即可。
|
||||
|
||||
@@ -244,14 +264,42 @@ comments: true
|
||||
=== "Python"
|
||||
|
||||
```python title="binary_search_tree.py"
|
||||
""" 插入结点 """
|
||||
def insert(self, num: int) -> Optional[TreeNode]:
|
||||
root = self.root
|
||||
# 若树为空，直接提前返回
|
||||
if root is None:
|
||||
return None
|
||||
|
||||
cur = root
|
||||
pre = None
|
||||
|
||||
# 循环查找，越过叶结点后跳出
|
||||
while cur is not None:
|
||||
# 找到重复结点，直接返回
|
||||
if cur.val == num:
|
||||
return None
|
||||
pre = cur
|
||||
|
||||
if cur.val < num: # 插入位置在 root 的右子树中
|
||||
cur = cur.right
|
||||
else: # 插入位置在 root 的左子树中
|
||||
cur = cur.left
|
||||
|
||||
# 插入结点 val
|
||||
node = TreeNode(num)
|
||||
if pre.val < num:
|
||||
pre.right = node
|
||||
else:
|
||||
pre.left = node
|
||||
return node
|
||||
```
|
||||
|
||||
=== "Go"
|
||||
|
||||
```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 {
|
||||
@@ -380,6 +428,12 @@ comments: true
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="binary_search_tree.swift"
|
||||
|
||||
```
|
||||
|
||||
为了插入结点，需要借助 **辅助结点 `prev`** 保存上一轮循环的结点，这样在遍历到 $\text{null}$ 时，我们也可以获取到其父结点，从而完成结点插入操作。
|
||||
|
||||
与查找结点相同，插入结点使用 $O(\log n)$ 时间。
|
||||
@@ -388,34 +442,30 @@ comments: true
|
||||
|
||||
与插入结点一样，我们需要在删除操作后维持二叉搜索树的“左子树 < 根结点 < 右子树”的性质。首先，我们需要在二叉树中执行查找操作，获取待删除结点。接下来，根据待删除结点的子结点数量，删除操作需要分为三种情况：
|
||||
|
||||
**待删除结点的子结点数量 $= 0$ 。** 表明待删除结点是叶结点，直接删除即可。
|
||||
**当待删除结点的子结点数量 $= 0$ 时**，表明待删除结点是叶结点，直接删除即可。
|
||||
|
||||
|
||||
|
||||
**待删除结点的子结点数量 $= 1$ 。** 将待删除结点替换为其子结点。
|
||||
**当待删除结点的子结点数量 $= 1$ 时**，将待删除结点替换为其子结点即可。
|
||||
|
||||
|
||||
|
||||
**待删除结点的子结点数量 $= 2$ 。** 删除操作分为三步：
|
||||
**当待删除结点的子结点数量 $= 2$ 时**，删除操作分为三步：
|
||||
|
||||
1. 找到待删除结点在 **中序遍历序列** 中的下一个结点，记为 `nex` ；
|
||||
2. 在树中递归删除结点 `nex` ；
|
||||
3. 使用 `nex` 替换待删除结点；
|
||||
|
||||
=== "Step 1"
|
||||
|
||||
|
||||
|
||||
=== "Step 2"
|
||||
|
||||
|
||||
|
||||
=== "Step 3"
|
||||
|
||||
|
||||
|
||||
=== "Step 4"
|
||||
|
||||
|
||||
|
||||
删除结点操作也使用 $O(\log n)$ 时间，其中查找待删除结点 $O(\log n)$ ，获取中序遍历后继结点 $O(\log n)$ 。
|
||||
@@ -447,11 +497,13 @@ comments: true
|
||||
// 删除结点 cur
|
||||
if (pre.left == cur) pre.left = child;
|
||||
else pre.right = child;
|
||||
// 释放内存
|
||||
delete cur;
|
||||
}
|
||||
// 子结点数量 = 2
|
||||
else {
|
||||
// 获取中序遍历中 cur 的下一个结点
|
||||
TreeNode nex = min(cur.right);
|
||||
TreeNode nex = getInOrderNext(cur.right);
|
||||
int tmp = nex.val;
|
||||
// 递归删除结点 nex
|
||||
remove(nex.val);
|
||||
@@ -460,15 +512,6 @@ comments: true
|
||||
}
|
||||
return cur;
|
||||
}
|
||||
/* 获取最小结点 */
|
||||
TreeNode min(TreeNode root) {
|
||||
if (root == null) return root;
|
||||
// 循环访问左子结点，直到叶结点时为最小结点，跳出
|
||||
while (root.left != null) {
|
||||
root = root.left;
|
||||
}
|
||||
return root;
|
||||
}
|
||||
```
|
||||
|
||||
=== "C++"
|
||||
@@ -502,7 +545,7 @@ comments: true
|
||||
// 子结点数量 = 2
|
||||
else {
|
||||
// 获取中序遍历中 cur 的下一个结点
|
||||
TreeNode* nex = min(cur->right);
|
||||
TreeNode* nex = getInOrderNext(cur->right);
|
||||
int tmp = nex->val;
|
||||
// 递归删除结点 nex
|
||||
remove(nex->val);
|
||||
@@ -511,28 +554,62 @@ comments: true
|
||||
}
|
||||
return cur;
|
||||
}
|
||||
/* 获取最小结点 */
|
||||
TreeNode* min(TreeNode* root) {
|
||||
if (root == nullptr) return root;
|
||||
// 循环访问左子结点，直到叶结点时为最小结点，跳出
|
||||
while (root->left != nullptr) {
|
||||
root = root->left;
|
||||
}
|
||||
return root;
|
||||
}
|
||||
```
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python title="binary_search_tree.py"
|
||||
""" 删除结点 """
|
||||
def remove(self, num: int) -> Optional[TreeNode]:
|
||||
root = self.root
|
||||
# 若树为空，直接提前返回
|
||||
if root is None:
|
||||
return None
|
||||
|
||||
cur = root
|
||||
pre = None
|
||||
|
||||
# 循环查找，越过叶结点后跳出
|
||||
while cur is not None:
|
||||
# 找到待删除结点，跳出循环
|
||||
if cur.val == num:
|
||||
break
|
||||
pre = cur
|
||||
if cur.val < num: # 待删除结点在 root 的右子树中
|
||||
cur = cur.right
|
||||
else: # 待删除结点在 root 的左子树中
|
||||
cur = cur.left
|
||||
|
||||
# 若无待删除结点，则直接返回
|
||||
if cur is None:
|
||||
return None
|
||||
|
||||
# 子结点数量 = 0 or 1
|
||||
if cur.left is None or cur.right is None:
|
||||
# 当子结点数量 = 0 / 1 时， child = null / 该子结点
|
||||
child = cur.left or cur.right
|
||||
# 删除结点 cur
|
||||
if pre.left == cur:
|
||||
pre.left = child
|
||||
else:
|
||||
pre.right = child
|
||||
# 子结点数量 = 2
|
||||
else:
|
||||
# 获取中序遍历中 cur 的下一个结点
|
||||
nex = self.get_inorder_next(cur.right)
|
||||
tmp = nex.val
|
||||
# 递归删除结点 nex
|
||||
self.remove(nex.val)
|
||||
# 将 nex 的值复制给 cur
|
||||
cur.val = tmp
|
||||
return cur
|
||||
```
|
||||
|
||||
=== "Go"
|
||||
|
||||
```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 {
|
||||
@@ -576,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
|
||||
}
|
||||
@@ -618,7 +695,7 @@ comments: true
|
||||
// 子结点数量 = 2
|
||||
else {
|
||||
// 获取中序遍历中 cur 的下一个结点
|
||||
let nex = min(cur.right);
|
||||
let nex = getInOrderNext(cur.right);
|
||||
let tmp = nex.val;
|
||||
// 递归删除结点 nex
|
||||
remove(nex.val);
|
||||
@@ -671,7 +748,7 @@ comments: true
|
||||
// 子结点数量 = 2
|
||||
else {
|
||||
// 获取中序遍历中 cur 的下一个结点
|
||||
let next = min(cur.right);
|
||||
let next = getInOrderNext(cur.right);
|
||||
let tmp = next!.val;
|
||||
// 递归删除结点 nex
|
||||
remove(next!.val);
|
||||
@@ -729,7 +806,7 @@ comments: true
|
||||
else
|
||||
{
|
||||
// 获取中序遍历中 cur 的下一个结点
|
||||
TreeNode? nex = min(cur.right);
|
||||
TreeNode? nex = getInOrderNext(cur.right);
|
||||
if (nex != null)
|
||||
{
|
||||
int tmp = nex.val;
|
||||
@@ -741,35 +818,29 @@ comments: true
|
||||
}
|
||||
return cur;
|
||||
}
|
||||
|
||||
/* 获取最小结点 */
|
||||
TreeNode? min(TreeNode? root)
|
||||
{
|
||||
if (root == null) return root;
|
||||
// 循环访问左子结点，直到叶结点时为最小结点，跳出
|
||||
while (root.left != null)
|
||||
{
|
||||
root = root.left;
|
||||
}
|
||||
return root;
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="binary_search_tree.swift"
|
||||
|
||||
```
|
||||
|
||||
## 二叉搜索树的优势
|
||||
|
||||
假设给定 $n$ 个数字，最常用的存储方式是「数组」，那么对于这串乱序的数字，常见操作的效率为：
|
||||
|
||||
- **查找元素：** 由于数组是无序的，因此需要遍历数组来确定，使用 $O(n)$ 时间；
|
||||
- **插入元素：** 只需将元素添加至数组尾部即可，使用 $O(1)$ 时间；
|
||||
- **删除元素：** 先查找元素，使用 $O(\log n)$ 时间，再在数组中删除该元素，使用 $O(n)$ 时间；
|
||||
- **获取最小 / 最大元素：** 需要遍历数组来确定，使用 $O(n)$ 时间；
|
||||
- **查找元素**：由于数组是无序的，因此需要遍历数组来确定，使用 $O(n)$ 时间；
|
||||
- **插入元素**：只需将元素添加至数组尾部即可，使用 $O(1)$ 时间；
|
||||
- **删除元素**：先查找元素，使用 $O(n)$ 时间，再在数组中删除该元素，使用 $O(n)$ 时间；
|
||||
- **获取最小 / 最大元素**：需要遍历数组来确定，使用 $O(n)$ 时间；
|
||||
|
||||
为了得到先验信息，我们也可以预先将数组元素进行排序，得到一个「排序数组」，此时操作效率为：
|
||||
|
||||
- **查找元素：** 由于数组已排序，可以使用二分查找，使用 $O(\log n)$ 时间；
|
||||
- **插入元素：** 为了保持数组是有序的，需插入到数组某位置，平均使用 $O(n)$ 时间；
|
||||
- **删除元素：** 与无序数组中的情况相同，使用 $O(n)$ 时间；
|
||||
- **获取最小 / 最大元素：** 数组头部和尾部元素即是最小和最大元素，使用 $O(1)$ 时间；
|
||||
- **查找元素**：由于数组已排序，可以使用二分查找，平均使用 $O(\log n)$ 时间；
|
||||
- **插入元素**：先查找插入位置，使用 $O(\log n)$ 时间，再插入到指定位置，使用 $O(n)$ 时间；
|
||||
- **删除元素**：先查找元素，使用 $O(\log n)$ 时间，再在数组中删除该元素，使用 $O(n)$ 时间；
|
||||
- **获取最小 / 最大元素**：数组头部和尾部元素即是最小和最大元素，使用 $O(1)$ 时间；
|
||||
|
||||
观察发现，无序数组和有序数组中的各项操作的时间复杂度是“偏科”的，即有的快有的慢；**而二叉搜索树的各项操作的时间复杂度都是对数阶，在数据量 $n$ 很大时有巨大优势**。
|
||||
|
||||
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 76 KiB After Width: | Height: | Size: 78 KiB |
@@ -35,7 +35,7 @@ comments: true
|
||||
```python title=""
|
||||
""" 链表结点类 """
|
||||
class TreeNode:
|
||||
def __init__(self, val=0, left=None, right=None):
|
||||
def __init__(self, val=None, left=None, right=None):
|
||||
self.val = val # 结点值
|
||||
self.left = left # 左子结点指针
|
||||
self.right = right # 右子结点指针
|
||||
@@ -44,13 +44,13 @@ comments: true
|
||||
=== "Go"
|
||||
|
||||
```go title=""
|
||||
""" 链表结点类 """
|
||||
/* 链表结点类 */
|
||||
type TreeNode struct {
|
||||
Val int
|
||||
Left *TreeNode
|
||||
Right *TreeNode
|
||||
}
|
||||
""" 结点初始化方法 """
|
||||
/* 结点初始化方法 */
|
||||
func NewTreeNode(v int) *TreeNode {
|
||||
return &TreeNode{
|
||||
Left: nil,
|
||||
@@ -106,9 +106,15 @@ comments: true
|
||||
}
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title=""
|
||||
|
||||
```
|
||||
|
||||
结点的两个指针分别指向「左子结点 Left Child Node」和「右子结点 Right Child Node」，并且称该结点为两个子结点的「父结点 Parent Node」。给定二叉树某结点，将左子结点以下的树称为该结点的「左子树 Left Subtree」，右子树同理。
|
||||
|
||||
除了叶结点外，每个结点都有子结点和子树。例如，若将上图的「结点 2」看作父结点，那么其左子结点和右子结点分别为「结点 4」和「结点 5」，左子树和右子树分别为「结点 4 以下的树」和「结点 5 以下的树」。
|
||||
除了叶结点外，每个结点都有子结点和子树。例如，若将上图的「结点 2」看作父结点，那么其左子结点和右子结点分别为「结点 4」和「结点 5」，左子树和右子树分别为「结点 4 及其以下结点形成的树」和「结点 5 及其以下结点形成的树」。
|
||||
|
||||
|
||||
|
||||
@@ -120,8 +126,8 @@ comments: true
|
||||
|
||||
- 「根结点 Root Node」：二叉树最顶层的结点，其没有父结点；
|
||||
- 「叶结点 Leaf Node」：没有子结点的结点，其两个指针都指向 $\text{null}$ ；
|
||||
- 结点所处「层 Level」：从顶置底依次增加，根结点所处层为 1 ；
|
||||
- 结点「度 Degree」：结点的子结点数量，二叉树中度的范围是 0, 1, 2 ；
|
||||
- 结点所处「层 Level」：从顶至底依次增加，根结点所处层为 1 ；
|
||||
- 结点「度 Degree」：结点的子结点数量。二叉树中，度的范围是 0, 1, 2 ；
|
||||
- 「边 Edge」：连接两个结点的边，即结点指针；
|
||||
- 二叉树「高度」：二叉树中根结点到最远叶结点走过边的数量；
|
||||
- 结点「深度 Depth」 ：根结点到该结点走过边的数量；
|
||||
@@ -137,7 +143,7 @@ comments: true
|
||||
|
||||
## 二叉树基本操作
|
||||
|
||||
**初始化二叉树。** 与链表类似，先初始化结点，再构建引用指向（即指针）。
|
||||
**初始化二叉树**。与链表类似，先初始化结点，再构建引用指向（即指针）。
|
||||
|
||||
=== "Java"
|
||||
|
||||
@@ -175,7 +181,18 @@ comments: true
|
||||
=== "Python"
|
||||
|
||||
```python title="binary_tree.py"
|
||||
|
||||
""" 初始化二叉树 """
|
||||
# 初始化节点
|
||||
n1 = TreeNode(val=1)
|
||||
n2 = TreeNode(val=2)
|
||||
n3 = TreeNode(val=3)
|
||||
n4 = TreeNode(val=4)
|
||||
n5 = TreeNode(val=5)
|
||||
# 构建引用指向（即指针）
|
||||
n1.left = n2
|
||||
n1.right = n3
|
||||
n2.left = n4
|
||||
n2.right = n5
|
||||
```
|
||||
|
||||
=== "Go"
|
||||
@@ -252,7 +269,13 @@ comments: true
|
||||
n2.right = n5;
|
||||
```
|
||||
|
||||
**插入与删除结点。** 与链表类似，插入与删除结点都可以通过修改指针实现。
|
||||
=== "Swift"
|
||||
|
||||
```swift title="binary_tree.swift"
|
||||
|
||||
```
|
||||
|
||||
**插入与删除结点**。与链表类似，插入与删除结点都可以通过修改指针实现。
|
||||
|
||||
|
||||
|
||||
@@ -284,7 +307,13 @@ comments: true
|
||||
=== "Python"
|
||||
|
||||
```python title="binary_tree.py"
|
||||
|
||||
""" 插入与删除结点 """
|
||||
p = TreeNode(0)
|
||||
# 在 n1 -> n2 中间插入结点 P
|
||||
n1.left = p
|
||||
p.left = n2
|
||||
# 删除节点 P
|
||||
n1.left = n2
|
||||
```
|
||||
|
||||
=== "Go"
|
||||
@@ -341,6 +370,12 @@ comments: true
|
||||
n1.left = n2;
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="binary_tree.swift"
|
||||
|
||||
```
|
||||
|
||||
!!! note
|
||||
|
||||
插入结点会改变二叉树的原有逻辑结构，删除结点往往意味着删除了该结点的所有子树。因此，二叉树中的插入与删除一般都是由一套操作配合完成的，这样才能实现有意义的操作。
|
||||
@@ -437,7 +472,7 @@ comments: true
|
||||
=== "Python"
|
||||
|
||||
```python title=""
|
||||
“”“ 二叉树的数组表示 ”“”
|
||||
""" 二叉树的数组表示 """
|
||||
# 直接使用 None 来表示空位
|
||||
tree = [1, 2, 3, 4, None, 6, 7, 8, 9, None, None, 12, None, None, 15]
|
||||
```
|
||||
@@ -478,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=""
|
||||
|
||||
```
|
||||
|
||||
|
||||
|
||||
回顾「完全二叉树」的满足条件，其只有最底层有空结点，并且最底层的结点尽量靠左，因而所有空结点都一定出现在层序遍历序列的末尾。**因为我们先验地确定了空位的位置，所以在使用数组表示完全二叉树时，可以省略存储“空位”**。“便于使用数组表示”也是完全二叉树受欢迎的原因之一。
|
||||
回顾「完全二叉树」的定义，其只有最底层有空结点，并且最底层的结点尽量靠左，因而所有空结点都一定出现在层序遍历序列的末尾。**因为我们先验地确定了空位的位置，所以在使用数组表示完全二叉树时，可以省略存储“空位”**。因此，完全二叉树非常适合使用数组来表示。
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -51,12 +51,12 @@ comments: true
|
||||
vector<int> vec;
|
||||
while (!queue.empty()) {
|
||||
TreeNode* node = queue.front();
|
||||
queue.pop(); // 队列出队
|
||||
vec.push_back(node->val); // 保存结点
|
||||
queue.pop(); // 队列出队
|
||||
vec.push_back(node->val); // 保存结点
|
||||
if (node->left != nullptr)
|
||||
queue.push(node->left); // 左子结点入队
|
||||
queue.push(node->left); // 左子结点入队
|
||||
if (node->right != nullptr)
|
||||
queue.push(node->right); // 右子结点入队
|
||||
queue.push(node->right); // 右子结点入队
|
||||
}
|
||||
return vec;
|
||||
}
|
||||
@@ -65,7 +65,21 @@ comments: true
|
||||
=== "Python"
|
||||
|
||||
```python title="binary_tree_bfs.py"
|
||||
|
||||
""" 层序遍历 """
|
||||
def hier_order(root: Optional[TreeNode]):
|
||||
# 初始化队列，加入根结点
|
||||
queue = collections.deque()
|
||||
queue.append(root)
|
||||
# 初始化一个列表，用于保存遍历序列
|
||||
res = []
|
||||
while queue:
|
||||
node = queue.popleft() # 队列出队
|
||||
res.append(node.val) # 保存节点值
|
||||
if node.left is not None:
|
||||
queue.append(node.left) # 左子结点入队
|
||||
if node.right is not None:
|
||||
queue.append(node.right) # 右子结点入队
|
||||
return res
|
||||
```
|
||||
|
||||
=== "Go"
|
||||
@@ -171,6 +185,12 @@ comments: true
|
||||
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="binary_tree_bfs.swift"
|
||||
|
||||
```
|
||||
|
||||
## 前序、中序、后序遍历
|
||||
|
||||
相对地，前、中、后序遍历皆属于「深度优先遍历 Depth-First Traversal」，其体现着一种“先走到尽头，再回头继续”的回溯遍历方式。
|
||||
@@ -256,7 +276,32 @@ comments: true
|
||||
=== "Python"
|
||||
|
||||
```python title="binary_tree_dfs.py"
|
||||
|
||||
""" 前序遍历 """
|
||||
def pre_order(root: Optional[TreeNode]):
|
||||
if root is None:
|
||||
return
|
||||
# 访问优先级：根结点 -> 左子树 -> 右子树
|
||||
res.append(root.val)
|
||||
pre_order(root=root.left)
|
||||
pre_order(root=root.right)
|
||||
|
||||
""" 中序遍历 """
|
||||
def in_order(root: Optional[TreeNode]):
|
||||
if root is None:
|
||||
return
|
||||
# 访问优先级：左子树 -> 根结点 -> 右子树
|
||||
in_order(root=root.left)
|
||||
res.append(root.val)
|
||||
in_order(root=root.right)
|
||||
|
||||
""" 后序遍历 """
|
||||
def post_order(root: Optional[TreeNode]):
|
||||
if root is None:
|
||||
return
|
||||
# 访问优先级：左子树 -> 右子树 -> 根结点
|
||||
post_order(root=root.left)
|
||||
post_order(root=root.right)
|
||||
res.append(root.val)
|
||||
```
|
||||
|
||||
=== "Go"
|
||||
@@ -402,7 +447,12 @@ comments: true
|
||||
postOrder(root.right);
|
||||
list.Add(root.val);
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
=== "Swift"
|
||||
|
||||
```swift title="binary_tree_dfs.swift"
|
||||
|
||||
```
|
||||
|
||||
!!! note
|
||||
|
||||
+1
-1
@@ -10,7 +10,7 @@ hide:
|
||||
{ align=left width=350 }
|
||||
</br></br></br></br></br>
|
||||
<h1 align="center"> 《 Hello，算法 》 </h1>
|
||||
<p align="center"> 动画图解、能运行、可讨论的</br>数据结构与算法快速入门教程 </p>
|
||||
<p align="center"> 动画图解、能运行、可提问的</br>数据结构与算法快速入门教程 </p>
|
||||
<p align="center"> [](https://github.com/krahets/hello-algo)</p>
|
||||
<h6 align="center"> [@Krahets](https://leetcode.cn/u/jyd/) </h6>
|
||||
</div>
|
||||
|
||||
Reference in New Issue
Block a user