mirror of
https://github.com/krahets/hello-algo.git
synced 2026-04-13 14:39:44 +08:00
Merge branch 'master' into master
This commit is contained in:
Yudong Jin
@@ -74,9 +74,6 @@ comments: true
|
||||
/* 初始化数组 */
|
||||
int[] arr = new int[5]; // { 0, 0, 0, 0, 0 }
|
||||
int[] nums = { 1, 3, 2, 5, 4 };
|
||||
|
||||
var arr2=new int[5]; // { 0, 0, 0, 0, 0 }
|
||||
var nums2=new int[]{1,2,3,4,5};
|
||||
```
|
||||
|
||||
## 数组优点
|
||||
@@ -298,7 +295,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
|
||||
}
|
||||
```
|
||||
|
||||
**数组中插入或删除元素效率低下。** 假设我们想要在数组中间某位置插入一个元素，由于数组元素在内存中是 “紧挨着的” ，它们之间没有空间再放任何数据。因此，我们不得不将此索引之后的所有元素都向后移动一位，然后再把元素赋值给该索引。删除元素也是类似，需要把此索引之后的元素都向前移动一位。总体看有以下缺点：
|
||||
**数组中插入或删除元素效率低下。** 假设我们想要在数组中间某位置插入一个元素，由于数组元素在内存中是“紧挨着的”，它们之间没有空间再放任何数据。因此，我们不得不将此索引之后的所有元素都向后移动一位，然后再把元素赋值给该索引。删除元素也是类似，需要把此索引之后的元素都向前移动一位。总体看有以下缺点：
|
||||
|
||||
- **时间复杂度高：** 数组的插入和删除的平均时间复杂度均为 $O(N)$ ，其中 $N$ 为数组长度。
|
||||
- **丢失元素：** 由于数组的长度不可变，因此在插入元素后，超出数组长度范围的元素会被丢失。
|
||||
@@ -314,7 +311,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
|
||||
/* 在数组的索引 index 处插入元素 num */
|
||||
void insert(int[] nums, int num, int index) {
|
||||
// 把索引 index 以及之后的所有元素向后移动一位
|
||||
for (int i = nums.length - 1; i >= index; i--) {
|
||||
for (int i = nums.length - 1; i > index; i--) {
|
||||
nums[i] = nums[i - 1];
|
||||
}
|
||||
// 将 num 赋给 index 处元素
|
||||
@@ -336,7 +333,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
|
||||
/* 在数组的索引 index 处插入元素 num */
|
||||
void insert(int* nums, int size, int num, int index) {
|
||||
// 把索引 index 以及之后的所有元素向后移动一位
|
||||
for (int i = size - 1; i >= index; i--) {
|
||||
for (int i = size - 1; i > index; i--) {
|
||||
nums[i] = nums[i - 1];
|
||||
}
|
||||
// 将 num 赋给 index 处元素
|
||||
@@ -358,7 +355,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
|
||||
""" 在数组的索引 index 处插入元素 num """
|
||||
def insert(nums, num, index):
|
||||
# 把索引 index 以及之后的所有元素向后移动一位
|
||||
for i in range(len(nums) - 1, index - 1, -1):
|
||||
for i in range(len(nums) - 1, index, -1):
|
||||
nums[i] = nums[i - 1]
|
||||
# 将 num 赋给 index 处元素
|
||||
nums[index] = num
|
||||
@@ -382,7 +379,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
|
||||
/* 在数组的索引 index 处插入元素 num */
|
||||
function insert(nums, num, index) {
|
||||
// 把索引 index 以及之后的所有元素向后移动一位
|
||||
for (let i = nums.length - 1; i >= index; i--) {
|
||||
for (let i = nums.length - 1; i > index; i--) {
|
||||
nums[i] = nums[i - 1];
|
||||
}
|
||||
// 将 num 赋给 index 处元素
|
||||
@@ -404,7 +401,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
|
||||
/* 在数组的索引 index 处插入元素 num */
|
||||
function insert(nums: number[], num: number, index: number): void {
|
||||
// 把索引 index 以及之后的所有元素向后移动一位
|
||||
for (let i = nums.length - 1; i >= index; i--) {
|
||||
for (let i = nums.length - 1; i > index; i--) {
|
||||
nums[i] = nums[i - 1];
|
||||
}
|
||||
// 将 num 赋给 index 处元素
|
||||
@@ -433,7 +430,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
|
||||
void Insert(int[] nums, int num, int index)
|
||||
{
|
||||
// 把索引 index 以及之后的所有元素向后移动一位
|
||||
for (int i = nums.Length - 1; i >= index; i--)
|
||||
for (int i = nums.Length - 1; i > index; i--)
|
||||
{
|
||||
nums[i] = nums[i - 1];
|
||||
}
|
||||
@@ -661,6 +658,6 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
|
||||
|
||||
**随机访问。** 如果我们想要随机抽取一些样本，那么可以用数组存储，并生成一个随机序列，根据索引实现样本的随机抽取。
|
||||
|
||||
**二分查找。** 例如前文查字典的例子，我们可以将字典中的所有字按照拼音顺序存储在数组中，然后使用与日常查纸质字典相同的 “翻开中间，排除一半” 的方式，来实现一个查电子字典的算法。
|
||||
**二分查找。** 例如前文查字典的例子，我们可以将字典中的所有字按照拼音顺序存储在数组中，然后使用与日常查纸质字典相同的“翻开中间，排除一半”的方式，来实现一个查电子字典的算法。
|
||||
|
||||
**深度学习。** 神经网络中大量使用了向量、矩阵、张量之间的线性代数运算，这些数据都是以数组的形式构建的。数组是神经网络编程中最常使用的数据结构。
|
||||
|
||||
@@ -91,7 +91,7 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```csharp title=""
|
||||
// 链表结点类
|
||||
/* 链表结点类 */
|
||||
class ListNode
|
||||
{
|
||||
int val; // 结点值
|
||||
@@ -208,13 +208,13 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```csharp title=""
|
||||
// 初始化链表 1 -> 3 -> 2 -> 5 -> 4
|
||||
// 初始化各结点
|
||||
n0 = new ListNode(1);
|
||||
n1 = new ListNode(3);
|
||||
n2 = new ListNode(2);
|
||||
n3 = new ListNode(5);
|
||||
n4 = new ListNode(4);
|
||||
/* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
|
||||
// 初始化各个结点
|
||||
ListNode n0 = new ListNode(1);
|
||||
ListNode n1 = new ListNode(3);
|
||||
ListNode n2 = new ListNode(2);
|
||||
ListNode n3 = new ListNode(5);
|
||||
ListNode n4 = new ListNode(4);
|
||||
// 构建引用指向
|
||||
n0.next = n1;
|
||||
n1.next = n2;
|
||||
@@ -613,7 +613,7 @@ comments: true
|
||||
int val; // 结点值
|
||||
ListNode *next; // 指向后继结点的指针（引用）
|
||||
ListNode *prev; // 指向前驱结点的指针（引用）
|
||||
ListNode(int x) : val(x), next(nullptr) {} // 构造函数
|
||||
ListNode(int x) : val(x), next(nullptr), prev(nullptr) {} // 构造函数
|
||||
};
|
||||
```
|
||||
|
||||
@@ -644,8 +644,8 @@ comments: true
|
||||
prev;
|
||||
constructor(val, next) {
|
||||
this.val = val === undefined ? 0 : val; // 结点值
|
||||
this.next = next === undefined ? null : next; // 指向后继结点的引用
|
||||
this.prev = prev === undefined ? null : prev; // 指向前驱结点的引用
|
||||
this.next = next === undefined ? null : next; // 指向后继结点的指针（引用）
|
||||
this.prev = prev === undefined ? null : prev; // 指向前驱结点的指针（引用）
|
||||
}
|
||||
}
|
||||
```
|
||||
@@ -660,8 +660,8 @@ comments: true
|
||||
prev: ListNode | null;
|
||||
constructor(val?: number, next?: ListNode | null, prev?: ListNode | null) {
|
||||
this.val = val === undefined ? 0 : val; // 结点值
|
||||
this.next = next === undefined ? null : next; // 指向后继结点的引用
|
||||
this.prev = prev === undefined ? null : prev; // 指向前驱结点的引用
|
||||
this.next = next === undefined ? null : next; // 指向后继结点的指针（引用）
|
||||
this.prev = prev === undefined ? null : prev; // 指向前驱结点的指针（引用）
|
||||
}
|
||||
}
|
||||
```
|
||||
@@ -675,7 +675,7 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```csharp title=""
|
||||
// 双向链表结点类
|
||||
/* 双向链表结点类 */
|
||||
class ListNode {
|
||||
int val; // 结点值
|
||||
ListNode next; // 指向后继结点的指针（引用）
|
||||
|
||||
@@ -10,13 +10,15 @@ comments: true
|
||||
|
||||
## 列表常用操作
|
||||
|
||||
**初始化列表。** 我们通常使用 `Integer[]` 包装类和 `Arrays.asList()` 作为中转，来初始化一个带有初始值的列表。
|
||||
**初始化列表。** 我们通常会使用到“无初始值”和“有初始值”的两种初始化方法。
|
||||
|
||||
=== "Java"
|
||||
|
||||
```java title="list.java"
|
||||
/* 初始化列表 */
|
||||
// 注意数组的元素类型是 int[] 的包装类 Integer[]
|
||||
// 无初始值
|
||||
List<Integer> list1 = new ArrayList<>();
|
||||
// 有初始值（注意数组的元素类型需为 int[] 的包装类 Integer[]）
|
||||
Integer[] numbers = new Integer[] { 1, 3, 2, 5, 4 };
|
||||
List<Integer> list = new ArrayList<>(Arrays.asList(numbers));
|
||||
```
|
||||
@@ -25,6 +27,10 @@ comments: true
|
||||
|
||||
```cpp title="list.cpp"
|
||||
/* 初始化列表 */
|
||||
// 需注意，C++ 中 vector 即是本文描述的 list
|
||||
// 无初始值
|
||||
vector<int> list1;
|
||||
// 有初始值
|
||||
vector<int> list = { 1, 3, 2, 5, 4 };
|
||||
```
|
||||
|
||||
@@ -32,6 +38,9 @@ comments: true
|
||||
|
||||
```python title="list.py"
|
||||
""" 初始化列表 """
|
||||
# 无初始值
|
||||
list1 = []
|
||||
# 有初始值
|
||||
list = [1, 3, 2, 5, 4]
|
||||
```
|
||||
|
||||
@@ -39,6 +48,9 @@ comments: true
|
||||
|
||||
```go title="list_test.go"
|
||||
/* 初始化列表 */
|
||||
// 无初始值
|
||||
list1 := []int
|
||||
// 有初始值
|
||||
list := []int{1, 3, 2, 5, 4}
|
||||
```
|
||||
|
||||
@@ -46,6 +58,9 @@ comments: true
|
||||
|
||||
```js title="list.js"
|
||||
/* 初始化列表 */
|
||||
// 无初始值
|
||||
const list1 = [];
|
||||
// 有初始值
|
||||
const list = [1, 3, 2, 5, 4];
|
||||
```
|
||||
|
||||
@@ -53,6 +68,9 @@ comments: true
|
||||
|
||||
```typescript title="list.ts"
|
||||
/* 初始化列表 */
|
||||
// 无初始值
|
||||
const list1: number[] = [];
|
||||
// 有初始值
|
||||
const list: number[] = [1, 3, 2, 5, 4];
|
||||
```
|
||||
|
||||
@@ -65,7 +83,12 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```csharp title="list.cs"
|
||||
|
||||
/* 初始化列表 */
|
||||
// 无初始值
|
||||
List<int> list1 = new ();
|
||||
// 有初始值（注意数组的元素类型需为 int[] 的包装类 Integer[]）
|
||||
int[] numbers = new int[] { 1, 3, 2, 5, 4 };
|
||||
List<int> list = numbers.ToList();
|
||||
```
|
||||
|
||||
**访问与更新元素。** 列表的底层数据结构是数组，因此可以在 $O(1)$ 时间内访问与更新元素，效率很高。
|
||||
@@ -114,20 +137,20 @@ comments: true
|
||||
|
||||
```js title="list.js"
|
||||
/* 访问元素 */
|
||||
const num = list[1];
|
||||
const num = list[1]; // 访问索引 1 处的元素
|
||||
|
||||
/* 更新元素 */
|
||||
list[1] = 0;
|
||||
list[1] = 0; // 将索引 1 处的元素更新为 0
|
||||
```
|
||||
|
||||
=== "TypeScript"
|
||||
|
||||
```typescript title="list.ts"
|
||||
/* 访问元素 */
|
||||
const num: number = list[1];
|
||||
const num: number = list[1]; // 访问索引 1 处的元素
|
||||
|
||||
/* 更新元素 */
|
||||
list[1] = 0;
|
||||
list[1] = 0; // 将索引 1 处的元素更新为 0
|
||||
```
|
||||
|
||||
=== "C"
|
||||
@@ -139,7 +162,11 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```csharp title="list.cs"
|
||||
/* 访问元素 */
|
||||
int num = list[1]; // 访问索引 1 处的元素
|
||||
|
||||
/* 更新元素 */
|
||||
list[1] = 0; // 将索引 1 处的元素更新为 0
|
||||
```
|
||||
|
||||
**在列表中添加、插入、删除元素。** 相对于数组，列表可以自由地添加与删除元素。在列表尾部添加元素的时间复杂度为 $O(1)$ ，但是插入与删除元素的效率仍与数组一样低，时间复杂度为 $O(N)$ 。
|
||||
@@ -273,7 +300,21 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```csharp title="list.cs"
|
||||
/* 清空列表 */
|
||||
list.Clear();
|
||||
|
||||
/* 尾部添加元素 */
|
||||
list.Add(1);
|
||||
list.Add(3);
|
||||
list.Add(2);
|
||||
list.Add(5);
|
||||
list.Add(4);
|
||||
|
||||
/* 中间插入元素 */
|
||||
list.Insert(3, 6);
|
||||
|
||||
/* 删除元素 */
|
||||
list.RemoveAt(3);
|
||||
```
|
||||
|
||||
**遍历列表。** 与数组一样，列表可以使用索引遍历，也可以使用 `for-each` 直接遍历。
|
||||
@@ -335,9 +376,9 @@ comments: true
|
||||
|
||||
/* 直接遍历列表元素 */
|
||||
count = 0
|
||||
for range list {
|
||||
count++
|
||||
}
|
||||
for range list {
|
||||
count++
|
||||
}
|
||||
```
|
||||
|
||||
=== "JavaScript"
|
||||
@@ -381,7 +422,19 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```csharp title="list.cs"
|
||||
/* 通过索引遍历列表 */
|
||||
int count = 0;
|
||||
for (int i = 0; i < list.Count(); i++)
|
||||
{
|
||||
count++;
|
||||
}
|
||||
|
||||
/* 直接遍历列表元素 */
|
||||
count = 0;
|
||||
foreach (int n in list)
|
||||
{
|
||||
count++;
|
||||
}
|
||||
```
|
||||
|
||||
**拼接两个列表。** 再创建一个新列表 `list1` ，我们可以将其中一个列表拼接到另一个的尾部。
|
||||
@@ -424,7 +477,7 @@ comments: true
|
||||
```js title="list.js"
|
||||
/* 拼接两个列表 */
|
||||
const list1 = [6, 8, 7, 10, 9];
|
||||
list.push(...list1);
|
||||
list.push(...list1); // 将列表 list1 拼接到 list 之后
|
||||
```
|
||||
|
||||
=== "TypeScript"
|
||||
@@ -432,7 +485,7 @@ comments: true
|
||||
```typescript title="list.ts"
|
||||
/* 拼接两个列表 */
|
||||
const list1: number[] = [6, 8, 7, 10, 9];
|
||||
list.push(...list1);
|
||||
list.push(...list1); // 将列表 list1 拼接到 list 之后
|
||||
```
|
||||
|
||||
=== "C"
|
||||
@@ -444,7 +497,9 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```csharp title="list.cs"
|
||||
|
||||
/* 拼接两个列表 */
|
||||
List<int> list1 = new() { 6, 8, 7, 10, 9 };
|
||||
list.AddRange(list1); // 将列表 list1 拼接到 list 之后
|
||||
```
|
||||
|
||||
**排序列表。** 排序也是常用的方法之一，完成列表排序后，我们就可以使用在数组类算法题中经常考察的「二分查找」和「双指针」算法了。
|
||||
@@ -481,7 +536,7 @@ comments: true
|
||||
|
||||
```js title="list.js"
|
||||
/* 排序列表 */
|
||||
list.sort((a, b) => a - b);
|
||||
list.sort((a, b) => a - b); // 排序后，列表元素从小到大排列
|
||||
```
|
||||
|
||||
=== "TypeScript"
|
||||
@@ -500,7 +555,8 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```csharp title="list.cs"
|
||||
|
||||
/* 排序列表 */
|
||||
list.Sort(); // 排序后，列表元素从小到大排列
|
||||
```
|
||||
|
||||
## 列表简易实现 *
|
||||
@@ -1066,5 +1122,101 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```csharp title="my_list.cs"
|
||||
class MyList
|
||||
{
|
||||
private int[] nums; // 数组（存储列表元素）
|
||||
private int capacity = 10; // 列表容量
|
||||
private int size = 0; // 列表长度（即当前元素数量）
|
||||
private int extendRatio = 2; // 每次列表扩容的倍数
|
||||
|
||||
/* 构造函数 */
|
||||
public MyList()
|
||||
{
|
||||
nums = new int[capacity];
|
||||
}
|
||||
|
||||
/* 获取列表长度（即当前元素数量）*/
|
||||
public int Size()
|
||||
{
|
||||
return size;
|
||||
}
|
||||
|
||||
/* 获取列表容量 */
|
||||
public int Capacity()
|
||||
{
|
||||
return capacity;
|
||||
}
|
||||
|
||||
/* 访问元素 */
|
||||
public int Get(int index)
|
||||
{
|
||||
// 索引如果越界则抛出异常，下同
|
||||
if (index >= size)
|
||||
throw new IndexOutOfRangeException("索引越界");
|
||||
return nums[index];
|
||||
}
|
||||
|
||||
/* 更新元素 */
|
||||
public void Set(int index, int num)
|
||||
{
|
||||
if (index >= size)
|
||||
throw new IndexOutOfRangeException("索引越界");
|
||||
nums[index] = num;
|
||||
}
|
||||
|
||||
/* 尾部添加元素 */
|
||||
public void Add(int num)
|
||||
{
|
||||
// 元素数量超出容量时，触发扩容机制
|
||||
if (size == Capacity())
|
||||
ExtendCapacity();
|
||||
nums[size] = num;
|
||||
// 更新元素数量
|
||||
size++;
|
||||
}
|
||||
|
||||
/* 中间插入元素 */
|
||||
public void Insert(int index, int num)
|
||||
{
|
||||
if (index >= size)
|
||||
throw new IndexOutOfRangeException("索引越界");
|
||||
// 元素数量超出容量时，触发扩容机制
|
||||
if (size == Capacity())
|
||||
ExtendCapacity();
|
||||
// 将索引 index 以及之后的元素都向后移动一位
|
||||
for (int j = size - 1; j >= index; j--)
|
||||
{
|
||||
nums[j + 1] = nums[j];
|
||||
}
|
||||
nums[index] = num;
|
||||
// 更新元素数量
|
||||
size++;
|
||||
}
|
||||
|
||||
/* 删除元素 */
|
||||
public int Remove(int index)
|
||||
{
|
||||
if (index >= size)
|
||||
throw new IndexOutOfRangeException("索引越界");
|
||||
int num = nums[index];
|
||||
// 将索引 index 之后的元素都向前移动一位
|
||||
for (int j = index; j < size - 1; j++)
|
||||
{
|
||||
nums[j] = nums[j + 1];
|
||||
}
|
||||
// 更新元素数量
|
||||
size--;
|
||||
// 返回被删除元素
|
||||
return num;
|
||||
}
|
||||
|
||||
/* 列表扩容 */
|
||||
public void ExtendCapacity()
|
||||
{
|
||||
// 新建一个长度为 size 的数组，并将原数组拷贝到新数组
|
||||
System.Array.Resize(ref nums, Capacity() * extendRatio);
|
||||
// 更新列表容量
|
||||
capacity = nums.Length;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
@@ -16,7 +16,7 @@ comments: true
|
||||
- **时间效率** ，即算法的运行速度的快慢。
|
||||
- **空间效率** ，即算法占用的内存空间大小。
|
||||
|
||||
数据结构与算法追求 “运行得快、内存占用少” ，而如何去评价算法效率则是非常重要的问题，因为只有知道如何评价算法，才能去做算法之间的对比分析，以及优化算法设计。
|
||||
数据结构与算法追求“运行得快、内存占用少”，而如何去评价算法效率则是非常重要的问题，因为只有知道如何评价算法，才能去做算法之间的对比分析，以及优化算法设计。
|
||||
|
||||
## 效率评估方法
|
||||
|
||||
@@ -38,6 +38,6 @@ comments: true
|
||||
|
||||
## 复杂度分析的重要性
|
||||
|
||||
复杂度分析给出一把评价算法效率的 “标尺” ，告诉我们执行某个算法需要多少时间和空间资源，也让我们可以开展不同算法之间的效率对比。
|
||||
复杂度分析给出一把评价算法效率的“标尺”，告诉我们执行某个算法需要多少时间和空间资源，也让我们可以开展不同算法之间的效率对比。
|
||||
|
||||
计算复杂度是个数学概念，对于初学者可能比较抽象，学习难度相对较高。从这个角度出发，其并不适合作为第一章内容。但是，当我们讨论某个数据结构或者算法的特点时，难以避免需要分析它的运行速度和空间使用情况。**因此，在展开学习数据结构与算法之前，建议读者先对计算复杂度建立起初步的了解，并且能够完成简单案例的复杂度分析**。
|
||||
|
||||
@@ -38,7 +38,7 @@ comments: true
|
||||
Node(int x) { val = x; }
|
||||
}
|
||||
|
||||
/* 函数（或称方法） */
|
||||
/* 函数 */
|
||||
int function() {
|
||||
// do something...
|
||||
return 0;
|
||||
@@ -63,7 +63,7 @@ comments: true
|
||||
Node(int x) : val(x), next(nullptr) {}
|
||||
};
|
||||
|
||||
/* 函数（或称方法） */
|
||||
/* 函数 */
|
||||
int func() {
|
||||
// do something...
|
||||
return 0;
|
||||
@@ -87,7 +87,7 @@ comments: true
|
||||
self.val = x # 结点值
|
||||
self.next = None # 指向下一结点的指针（引用）
|
||||
|
||||
""" 函数（或称方法） """
|
||||
""" 函数 """
|
||||
def function():
|
||||
# do something...
|
||||
return 0
|
||||
@@ -113,7 +113,7 @@ comments: true
|
||||
return &Node{val: val}
|
||||
}
|
||||
|
||||
/* 函数（或称方法）*/
|
||||
/* 函数 */
|
||||
func function() int {
|
||||
// do something...
|
||||
return 0
|
||||
@@ -149,14 +149,36 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```csharp title=""
|
||||
/* 类 */
|
||||
class Node
|
||||
{
|
||||
int val;
|
||||
Node next;
|
||||
Node(int x) { val = x; }
|
||||
}
|
||||
|
||||
/* 函数 */
|
||||
int function()
|
||||
{
|
||||
// do something...
|
||||
return 0;
|
||||
}
|
||||
|
||||
int algorithm(int n) // 输入数据
|
||||
{
|
||||
int a = 0; // 暂存数据（常量）
|
||||
int b = 0; // 暂存数据（变量）
|
||||
Node node = new Node(0); // 暂存数据（对象）
|
||||
int c = function(); // 栈帧空间（调用函数）
|
||||
return a + b + c; // 输出数据
|
||||
}
|
||||
```
|
||||
|
||||
## 推算方法
|
||||
|
||||
空间复杂度的推算方法和时间复杂度总体类似，只是从统计 “计算操作数量” 变为统计 “使用空间大小” 。与时间复杂度不同的是，**我们一般只关注「最差空间复杂度」**。这是因为内存空间是一个硬性要求，我们必须保证在所有输入数据下都有足够的内存空间预留。
|
||||
空间复杂度的推算方法和时间复杂度总体类似，只是从统计“计算操作数量”变为统计“使用空间大小”。与时间复杂度不同的是，**我们一般只关注「最差空间复杂度」**。这是因为内存空间是一个硬性要求，我们必须保证在所有输入数据下都有足够的内存空间预留。
|
||||
|
||||
**最差空间复杂度中的 “最差” 有两层含义**，分别为输入数据的最差分布、算法运行中的最差时间点。
|
||||
**最差空间复杂度中的“最差”有两层含义**，分别为输入数据的最差分布、算法运行中的最差时间点。
|
||||
|
||||
- **以最差输入数据为准。** 当 $n < 10$ 时，空间复杂度为 $O(1)$ ；但是当 $n > 10$ 时，初始化的数组 `nums` 使用 $O(n)$ 空间；因此最差空间复杂度为 $O(n)$ ；
|
||||
- **以算法运行过程中的峰值内存为准。** 程序在执行最后一行之前，使用 $O(1)$ 空间；当初始化数组 `nums` 时，程序使用 $O(n)$ 空间；因此最差空间复杂度为 $O(n)$ ；
|
||||
@@ -228,7 +250,15 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```csharp title=""
|
||||
|
||||
void algorithm(int n)
|
||||
{
|
||||
int a = 0; // O(1)
|
||||
int[] b = new int[10000]; // O(1)
|
||||
if (n > 10)
|
||||
{
|
||||
int[] nums = new int[n]; // O(n)
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**在递归函数中，需要注意统计栈帧空间。** 例如函数 `loop()`，在循环中调用了 $n$ 次 `function()` ，每轮中的 `function()` 都返回并释放了栈帧空间，因此空间复杂度仍为 $O(1)$ 。而递归函数 `recur()` 在运行中会同时存在 $n$ 个未返回的 `recur()` ，从而使用 $O(n)$ 的栈帧空间。
|
||||
@@ -330,13 +360,31 @@ comments: true
|
||||
=== "C"
|
||||
|
||||
```c title=""
|
||||
|
||||
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
|
||||
```csharp title=""
|
||||
|
||||
int function()
|
||||
{
|
||||
// do something
|
||||
return 0;
|
||||
}
|
||||
/* 循环 O(1) */
|
||||
void loop(int n)
|
||||
{
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
function();
|
||||
}
|
||||
}
|
||||
/* 递归 O(n) */
|
||||
int recur(int n)
|
||||
{
|
||||
if (n == 1) return 1;
|
||||
return recur(n - 1);
|
||||
}
|
||||
```
|
||||
|
||||
## 常见类型
|
||||
@@ -467,7 +515,25 @@ $$
|
||||
=== "C#"
|
||||
|
||||
```csharp title="space_complexity.cs"
|
||||
|
||||
/* 常数阶 */
|
||||
void constant(int n)
|
||||
{
|
||||
// 常量、变量、对象占用 O(1) 空间
|
||||
int a = 0;
|
||||
int b = 0;
|
||||
int[] nums = new int[10000];
|
||||
ListNode node = new ListNode(0);
|
||||
// 循环中的变量占用 O(1) 空间
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
int c = 0;
|
||||
}
|
||||
// 循环中的函数占用 O(1) 空间
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
function();
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### 线性阶 $O(n)$
|
||||
@@ -540,7 +606,7 @@ $$
|
||||
nodes = append(nodes, newNode(i))
|
||||
}
|
||||
// 长度为 n 的哈希表占用 O(n) 空间
|
||||
m := make(map[int]string, n)
|
||||
m := make(map[int]string, n)
|
||||
for i := 0; i < n; i++ {
|
||||
m[i] = strconv.Itoa(i)
|
||||
}
|
||||
@@ -568,7 +634,24 @@ $$
|
||||
=== "C#"
|
||||
|
||||
```csharp title="space_complexity.cs"
|
||||
|
||||
/* 线性阶 */
|
||||
void linear(int n)
|
||||
{
|
||||
// 长度为 n 的数组占用 O(n) 空间
|
||||
int[] nums = new int[n];
|
||||
// 长度为 n 的列表占用 O(n) 空间
|
||||
List<ListNode> nodes = new();
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
nodes.Add(new ListNode(i));
|
||||
}
|
||||
// 长度为 n 的哈希表占用 O(n) 空间
|
||||
Dictionary<int, String> map = new();
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
map.Add(i, i.ToString());
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
以下递归函数会同时存在 $n$ 个未返回的 `algorithm()` 函数，使用 $O(n)$ 大小的栈帧空间。
|
||||
@@ -639,7 +722,13 @@ $$
|
||||
=== "C#"
|
||||
|
||||
```csharp title="space_complexity.cs"
|
||||
|
||||
/* 线性阶（递归实现） */
|
||||
void linearRecur(int n)
|
||||
{
|
||||
Console.WriteLine("递归 n = " + n);
|
||||
if (n == 1) return;
|
||||
linearRecur(n - 1);
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
@@ -729,6 +818,23 @@ $$
|
||||
=== "C#"
|
||||
|
||||
```csharp title="space_complexity.cs"
|
||||
/* 平方阶 */
|
||||
void quadratic(int n)
|
||||
{
|
||||
// 矩阵占用 O(n^2) 空间
|
||||
int[,] numMatrix = new int[n, n];
|
||||
// 二维列表占用 O(n^2) 空间
|
||||
List<List<int>> numList = new();
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
List<int> tmp = new();
|
||||
for (int j = 0; j < n; j++)
|
||||
{
|
||||
tmp.Add(0);
|
||||
}
|
||||
numList.Add(tmp);
|
||||
}
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
@@ -777,8 +883,8 @@ $$
|
||||
if n <= 0 {
|
||||
return 0
|
||||
}
|
||||
// 数组 nums 长度为 n, n-1, ..., 2, 1
|
||||
nums := make([]int, n)
|
||||
fmt.Printf("递归 n = %d 中的 nums 长度 = %d \n", n, len(nums))
|
||||
return spaceQuadraticRecur(n - 1)
|
||||
}
|
||||
```
|
||||
@@ -804,6 +910,14 @@ $$
|
||||
=== "C#"
|
||||
|
||||
```csharp title="space_complexity.cs"
|
||||
/* 平方阶（递归实现） */
|
||||
int quadraticRecur(int n)
|
||||
{
|
||||
if (n <= 0) return 0;
|
||||
// 数组 nums 长度为 n, n-1, ..., 2, 1
|
||||
int[] nums = new int[n];
|
||||
return quadraticRecur(n - 1);
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
@@ -889,7 +1003,15 @@ $$
|
||||
=== "C#"
|
||||
|
||||
```csharp title="space_complexity.cs"
|
||||
|
||||
/* 指数阶（建立满二叉树） */
|
||||
TreeNode? buildTree(int n)
|
||||
{
|
||||
if (n == 0) return null;
|
||||
TreeNode root = new TreeNode(0);
|
||||
root.left = buildTree(n - 1);
|
||||
root.right = buildTree(n - 1);
|
||||
return root;
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
|
||||
@@ -130,7 +130,23 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```csharp title="leetcode_two_sum.cs"
|
||||
|
||||
class SolutionBruteForce
|
||||
{
|
||||
public int[] twoSum(int[] nums, int target)
|
||||
{
|
||||
int size = nums.Length;
|
||||
// 两层循环，时间复杂度 O(n^2)
|
||||
for (int i = 0; i < size - 1; i++)
|
||||
{
|
||||
for (int j = i + 1; j < size; j++)
|
||||
{
|
||||
if (nums[i] + nums[j] == target)
|
||||
return new int[] { i, j };
|
||||
}
|
||||
}
|
||||
return new int[0];
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### 方法二：辅助哈希表
|
||||
@@ -258,5 +274,23 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```csharp title="leetcode_two_sum.cs"
|
||||
|
||||
class SolutionHashMap
|
||||
{
|
||||
public int[] twoSum(int[] nums, int target)
|
||||
{
|
||||
int size = nums.Length;
|
||||
// 辅助哈希表，空间复杂度 O(n)
|
||||
Dictionary<int, int> dic = new();
|
||||
// 单层循环，时间复杂度 O(n)
|
||||
for (int i = 0; i < size; i++)
|
||||
{
|
||||
if (dic.ContainsKey(target - nums[i]))
|
||||
{
|
||||
return new int[] { dic[target - nums[i]], i };
|
||||
}
|
||||
dic.Add(nums[i], i);
|
||||
}
|
||||
return new int[0];
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
@@ -23,6 +23,6 @@ comments: true
|
||||
|
||||
- 与时间复杂度的定义类似，「空间复杂度」统计算法占用空间随着数据量变大时的增长趋势。
|
||||
|
||||
- 算法运行中相关内存空间可分为输入空间、暂存空间、输出空间。通常情况下，空间复杂度不计入输入空间。暂存空间可分为指令空间、数据空间、栈帧空间，其中栈帧空间一般在递归函数中才会影响到空间复杂度。
|
||||
- 算法运行中相关内存空间可分为输入空间、暂存空间、输出空间。通常情况下，输入空间不计入空间复杂度计算。暂存空间可分为指令空间、数据空间、栈帧空间，其中栈帧空间一般在递归函数中才会影响到空间复杂度。
|
||||
- 我们一般只关心「最差空间复杂度」，即统计算法在「最差输入数据」和「最差运行时间点」下的空间复杂度。
|
||||
- 常见空间复杂度从小到大排列有 $O(1)$ , $O(\log n)$ , $O(n)$ , $O(n^2)$ , $O(2^n)$ 。
|
||||
|
||||
@@ -97,7 +97,18 @@ $$
|
||||
=== "C#"
|
||||
|
||||
```csharp title=""
|
||||
|
||||
// 在某运行平台下
|
||||
void algorithm(int n)
|
||||
{
|
||||
int a = 2; // 1 ns
|
||||
a = a + 1; // 1 ns
|
||||
a = a * 2; // 10 ns
|
||||
// 循环 n 次
|
||||
for (int i = 0; i < n; i++)
|
||||
{ // 1 ns ，每轮都要执行 i++
|
||||
Console.WriteLine(0); // 5 ns
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
但实际上， **统计算法的运行时间既不合理也不现实。** 首先，我们不希望预估时间和运行平台绑定，毕竟算法需要跑在各式各样的平台之上。其次，我们很难获知每一种操作的运行时间，这为预估过程带来了极大的难度。
|
||||
@@ -106,7 +117,7 @@ $$
|
||||
|
||||
「时间复杂度分析」采取了不同的做法，其统计的不是算法运行时间，而是 **算法运行时间随着数据量变大时的增长趋势** 。
|
||||
|
||||
“时间增长趋势” 这个概念比较抽象，我们借助一个例子来理解。设输入数据大小为 $n$ ，给定三个算法 `A` , `B` , `C` 。
|
||||
“时间增长趋势”这个概念比较抽象，我们借助一个例子来理解。设输入数据大小为 $n$ ，给定三个算法 `A` , `B` , `C` 。
|
||||
|
||||
- 算法 `A` 只有 $1$ 个打印操作，算法运行时间不随着 $n$ 增大而增长。我们称此算法的时间复杂度为「常数阶」。
|
||||
- 算法 `B` 中的打印操作需要循环 $n$ 次，算法运行时间随着 $n$ 增大成线性增长。此算法的时间复杂度被称为「线性阶」。
|
||||
@@ -212,7 +223,27 @@ $$
|
||||
=== "C#"
|
||||
|
||||
```csharp title=""
|
||||
|
||||
// 算法 A 时间复杂度：常数阶
|
||||
void algorithm_A(int n)
|
||||
{
|
||||
Console.WriteLine(0);
|
||||
}
|
||||
// 算法 B 时间复杂度：线性阶
|
||||
void algorithm_B(int n)
|
||||
{
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
Console.WriteLine(0);
|
||||
}
|
||||
}
|
||||
// 算法 C 时间复杂度：常数阶
|
||||
void algorithm_C(int n)
|
||||
{
|
||||
for (int i = 0; i < 1000000; i++)
|
||||
{
|
||||
Console.WriteLine(0);
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
@@ -223,7 +254,7 @@ $$
|
||||
|
||||
**时间复杂度可以有效评估算法效率。** 算法 `B` 运行时间的增长是线性的，在 $n > 1$ 时慢于算法 `A` ，在 $n > 1000000$ 时慢于算法 `C` 。实质上，只要输入数据大小 $n$ 足够大，复杂度为「常数阶」的算法一定优于「线性阶」的算法，这也正是时间增长趋势的含义。
|
||||
|
||||
**时间复杂度分析将统计「计算操作的运行时间」简化为统计「计算操作的数量」。** 这是因为，无论是运行平台、还是计算操作类型，都与算法运行时间的增长趋势无关。因此，我们可以简单地将所有计算操作的执行时间统一看作是相同的 “单位时间” 。
|
||||
**时间复杂度分析将统计「计算操作的运行时间」简化为统计「计算操作的数量」。** 这是因为，无论是运行平台、还是计算操作类型，都与算法运行时间的增长趋势无关。因此，我们可以简单地将所有计算操作的执行时间统一看作是相同的“单位时间”。
|
||||
|
||||
**时间复杂度也存在一定的局限性。** 比如，虽然算法 `A` 和 `C` 的时间复杂度相同，但是实际的运行时间有非常大的差别。再比如，虽然算法 `B` 比 `C` 的时间复杂度要更高，但在输入数据大小 $n$ 比较小时，算法 `B` 是要明显优于算法 `C` 的。即使存在这些问题，计算复杂度仍然是评判算法效率的最有效、最常用方法。
|
||||
|
||||
@@ -310,7 +341,15 @@ $$
|
||||
=== "C#"
|
||||
|
||||
```csharp title=""
|
||||
|
||||
void algorithm(int n) {
|
||||
int a = 1; // +1
|
||||
a = a + 1; // +1
|
||||
a = a * 2; // +1
|
||||
// 循环 n 次
|
||||
for (int i = 0; i < n; i++) { // +1（每轮都执行 i ++）
|
||||
Console.WriteLine(0); // +1
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
$T(n)$ 是个一次函数，说明时间增长趋势是线性的，因此易得时间复杂度是线性阶。
|
||||
@@ -325,7 +364,7 @@ $T(n)$ 是个一次函数，说明时间增长趋势是线性的，因此易得
|
||||
$$
|
||||
T(n) \leq c \cdot f(n)
|
||||
$$
|
||||
则可认为 $f(n)$ 给出了 $T(n)$ 的一个渐近上界，记为
|
||||
则可认为 $f(n)$ 给出了 $T(n)$ 的一个渐近上界，记为
|
||||
$$
|
||||
T(n) = O(f(n))
|
||||
$$
|
||||
@@ -457,14 +496,31 @@ $$
|
||||
=== "C#"
|
||||
|
||||
```csharp title=""
|
||||
|
||||
void algorithm(int n)
|
||||
{
|
||||
int a = 1; // +0（技巧 1）
|
||||
a = a + n; // +0（技巧 1）
|
||||
// +n（技巧 2）
|
||||
for (int i = 0; i < 5 * n + 1; i++)
|
||||
{
|
||||
Console.WriteLine(0);
|
||||
}
|
||||
// +n*n（技巧 3）
|
||||
for (int i = 0; i < 2 * n; i++)
|
||||
{
|
||||
for (int j = 0; j < n + 1; j++)
|
||||
{
|
||||
Console.WriteLine(0);
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### 2. 判断渐近上界
|
||||
|
||||
**时间复杂度由多项式 $T(n)$ 中最高阶的项来决定**。这是因为在 $n$ 趋于无穷大时，最高阶的项将处于主导作用，其它项的影响都可以被忽略。
|
||||
|
||||
以下表格给出了一些例子，其中有一些夸张的值，是想要向大家强调 **系数无法撼动阶数** 这一结论。在 $n$ 趋于无穷大时，这些常数都是 “浮云” 。
|
||||
以下表格给出了一些例子，其中有一些夸张的值，是想要向大家强调 **系数无法撼动阶数** 这一结论。在 $n$ 趋于无穷大时，这些常数都是“浮云”。
|
||||
|
||||
<div class="center-table" markdown>
|
||||
|
||||
@@ -576,7 +632,15 @@ $$
|
||||
=== "C#"
|
||||
|
||||
```csharp title="time_complexity.cs"
|
||||
|
||||
/* 常数阶 */
|
||||
int constant(int n)
|
||||
{
|
||||
int count = 0;
|
||||
int size = 100000;
|
||||
for (int i = 0; i < size; i++)
|
||||
count++;
|
||||
return count;
|
||||
}
|
||||
```
|
||||
|
||||
### 线性阶 $O(n)$
|
||||
@@ -652,7 +716,14 @@ $$
|
||||
=== "C#"
|
||||
|
||||
```csharp title="time_complexity.cs"
|
||||
|
||||
/* 线性阶 */
|
||||
int linear(int n)
|
||||
{
|
||||
int count = 0;
|
||||
for (int i = 0; i < n; i++)
|
||||
count++;
|
||||
return count;
|
||||
}
|
||||
```
|
||||
|
||||
「遍历数组」和「遍历链表」等操作，时间复杂度都为 $O(n)$ ，其中 $n$ 为数组或链表的长度。
|
||||
@@ -736,7 +807,17 @@ $$
|
||||
=== "C#"
|
||||
|
||||
```csharp title="time_complexity.cs"
|
||||
|
||||
/* 线性阶（遍历数组） */
|
||||
int arrayTraversal(int[] nums)
|
||||
{
|
||||
int count = 0;
|
||||
// 循环次数与数组长度成正比
|
||||
foreach(int num in nums)
|
||||
{
|
||||
count++;
|
||||
}
|
||||
return count;
|
||||
}
|
||||
```
|
||||
|
||||
### 平方阶 $O(n^2)$
|
||||
@@ -825,7 +906,20 @@ $$
|
||||
=== "C#"
|
||||
|
||||
```csharp title="time_complexity.cs"
|
||||
|
||||
/* 平方阶 */
|
||||
int quadratic(int n)
|
||||
{
|
||||
int count = 0;
|
||||
// 循环次数与数组长度成平方关系
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
for (int j = 0; j < n; j++)
|
||||
{
|
||||
count++;
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
@@ -947,6 +1041,28 @@ $$
|
||||
=== "C#"
|
||||
|
||||
```csharp title="time_complexity.cs"
|
||||
/* 平方阶（冒泡排序） */
|
||||
int bubbleSort(int[] nums)
|
||||
{
|
||||
int count = 0; // 计数器
|
||||
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
|
||||
for (int i = nums.Length - 1; i > 0; i--)
|
||||
{
|
||||
// 内循环：冒泡操作
|
||||
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;
|
||||
count += 3; // 元素交换包含 3 个单元操作
|
||||
}
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
@@ -954,7 +1070,7 @@ $$
|
||||
|
||||
!!! note
|
||||
|
||||
生物学科中的 “细胞分裂” 即是指数阶增长：初始状态为 $1$ 个细胞，分裂一轮后为 $2$ 个，分裂两轮后为 $4$ 个，……，分裂 $n$ 轮后有 $2^n$ 个细胞。
|
||||
生物学科中的“细胞分裂”即是指数阶增长：初始状态为 $1$ 个细胞，分裂一轮后为 $2$ 个，分裂两轮后为 $4$ 个，……，分裂 $n$ 轮后有 $2^n$ 个细胞。
|
||||
|
||||
指数阶增长得非常快，在实际应用中一般是不能被接受的。若一个问题使用「暴力枚举」求解的时间复杂度是 $O(2^n)$ ，那么一般都需要使用「动态规划」或「贪心算法」等算法来求解。
|
||||
|
||||
@@ -1048,7 +1164,22 @@ $$
|
||||
=== "C#"
|
||||
|
||||
```csharp title="time_complexity.cs"
|
||||
|
||||
/* 指数阶（循环实现） */
|
||||
int exponential(int n)
|
||||
{
|
||||
int count = 0, bas = 1;
|
||||
// cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
for (int j = 0; j < bas; j++)
|
||||
{
|
||||
count++;
|
||||
}
|
||||
bas *= 2;
|
||||
}
|
||||
// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
|
||||
return count;
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
@@ -1119,14 +1250,19 @@ $$
|
||||
=== "C#"
|
||||
|
||||
```csharp title="time_complexity.cs"
|
||||
|
||||
/* 指数阶（递归实现） */
|
||||
int expRecur(int n)
|
||||
{
|
||||
if (n == 1) return 1;
|
||||
return expRecur(n - 1) + expRecur(n - 1) + 1;
|
||||
}
|
||||
```
|
||||
|
||||
### 对数阶 $O(\log n)$
|
||||
|
||||
对数阶与指数阶正好相反，后者反映 “每轮增加到两倍的情况” ，而前者反映 “每轮缩减到一半的情况” 。对数阶仅次于常数阶，时间增长的很慢，是理想的时间复杂度。
|
||||
对数阶与指数阶正好相反，后者反映“每轮增加到两倍的情况”，而前者反映“每轮缩减到一半的情况”。对数阶仅次于常数阶，时间增长的很慢，是理想的时间复杂度。
|
||||
|
||||
对数阶常出现于「二分查找」和「分治算法」中，体现 “一分为多” 、“化繁为简” 的算法思想。
|
||||
对数阶常出现于「二分查找」和「分治算法」中，体现“一分为多”、“化繁为简”的算法思想。
|
||||
|
||||
设输入数据大小为 $n$ ，由于每轮缩减到一半，因此循环次数是 $\log_2 n$ ，即 $2^n$ 的反函数。
|
||||
|
||||
@@ -1205,7 +1341,17 @@ $$
|
||||
=== "C#"
|
||||
|
||||
```csharp title="time_complexity.cs"
|
||||
|
||||
/* 对数阶（循环实现） */
|
||||
int logarithmic(float n)
|
||||
{
|
||||
int count = 0;
|
||||
while (n > 1)
|
||||
{
|
||||
n = n / 2;
|
||||
count++;
|
||||
}
|
||||
return count;
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
@@ -1276,7 +1422,12 @@ $$
|
||||
=== "C#"
|
||||
|
||||
```csharp title="time_complexity.cs"
|
||||
|
||||
/* 对数阶（递归实现） */
|
||||
int logRecur(float n)
|
||||
{
|
||||
if (n <= 1) return 0;
|
||||
return logRecur(n / 2) + 1;
|
||||
}
|
||||
```
|
||||
|
||||
### 线性对数阶 $O(n \log n)$
|
||||
@@ -1366,7 +1517,18 @@ $$
|
||||
=== "C#"
|
||||
|
||||
```csharp title="time_complexity.cs"
|
||||
|
||||
/* 线性对数阶 */
|
||||
int linearLogRecur(float n)
|
||||
{
|
||||
if (n <= 1) return 1;
|
||||
int count = linearLogRecur(n / 2) +
|
||||
linearLogRecur(n / 2);
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
count++;
|
||||
}
|
||||
return count;
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
@@ -1464,7 +1626,18 @@ $$
|
||||
=== "C#"
|
||||
|
||||
```csharp title="time_complexity.cs"
|
||||
|
||||
/* 阶乘阶（递归实现） */
|
||||
int factorialRecur(int n)
|
||||
{
|
||||
if (n == 0) return 1;
|
||||
int count = 0;
|
||||
// 从 1 个分裂出 n 个
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
count += factorialRecur(n - 1);
|
||||
}
|
||||
return count;
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
@@ -1485,7 +1658,7 @@ $$
|
||||
```java title="worst_best_time_complexity.java"
|
||||
public class worst_best_time_complexity {
|
||||
/* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */
|
||||
static int[] randomNumbers(int n) {
|
||||
int[] randomNumbers(int n) {
|
||||
Integer[] nums = new Integer[n];
|
||||
// 生成数组 nums = { 1, 2, 3, ..., n }
|
||||
for (int i = 0; i < n; i++) {
|
||||
@@ -1502,7 +1675,7 @@ $$
|
||||
}
|
||||
|
||||
/* 查找数组 nums 中数字 1 所在索引 */
|
||||
static int findOne(int[] nums) {
|
||||
int findOne(int[] nums) {
|
||||
for (int i = 0; i < nums.length; i++) {
|
||||
if (nums[i] == 1)
|
||||
return i;
|
||||
@@ -1511,7 +1684,7 @@ $$
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
public static void main(String[] args) {
|
||||
public void main(String[] args) {
|
||||
for (int i = 0; i < 10; i++) {
|
||||
int n = 100;
|
||||
int[] nums = randomNumbers(n);
|
||||
@@ -1652,14 +1825,58 @@ $$
|
||||
=== "C#"
|
||||
|
||||
```csharp title="worst_best_time_complexity.cs"
|
||||
/* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */
|
||||
int[] randomNumbers(int n)
|
||||
{
|
||||
int[] nums = new int[n];
|
||||
// 生成数组 nums = { 1, 2, 3, ..., n }
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
nums[i] = i + 1;
|
||||
}
|
||||
|
||||
// 随机打乱数组元素
|
||||
for (int i = 0; i < nums.Length; i++)
|
||||
{
|
||||
var index = new Random().Next(i, nums.Length);
|
||||
var tmp = nums[i];
|
||||
var ran = nums[index];
|
||||
nums[i] = ran;
|
||||
nums[index] = tmp;
|
||||
}
|
||||
return nums;
|
||||
}
|
||||
|
||||
/* 查找数组 nums 中数字 1 所在索引 */
|
||||
int findOne(int[] nums)
|
||||
{
|
||||
for (int i = 0; i < nums.Length; i++)
|
||||
{
|
||||
if (nums[i] == 1)
|
||||
return i;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
public void main(String[] args)
|
||||
{
|
||||
for (int i = 0; i < 10; i++)
|
||||
{
|
||||
int n = 100;
|
||||
int[] nums = randomNumbers(n);
|
||||
int index = findOne(nums);
|
||||
Console.WriteLine("\n数组 [ 1, 2, ..., n ] 被打乱后 = " + string.Join(",", nums));
|
||||
Console.WriteLine("数字 1 的索引为 " + index);
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
!!! tip
|
||||
|
||||
我们在实际应用中很少使用「最佳时间复杂度」，因为往往只有很小概率下才能达到，会带来一定的误导性。反之，「最差时间复杂度」最为实用，因为它给出了一个 “效率安全值” ，让我们可以放心地使用算法。
|
||||
我们在实际应用中很少使用「最佳时间复杂度」，因为往往只有很小概率下才能达到，会带来一定的误导性。反之，「最差时间复杂度」最为实用，因为它给出了一个“效率安全值”，让我们可以放心地使用算法。
|
||||
|
||||
从上述示例可以看出，最差或最佳时间复杂度只出现在 “特殊分布的数据” 中，这些情况的出现概率往往很小，因此并不能最真实地反映算法运行效率。**相对地，「平均时间复杂度」可以体现算法在随机输入数据下的运行效率，用 $\Theta$ 记号（Theta Notation）来表示**。
|
||||
从上述示例可以看出，最差或最佳时间复杂度只出现在“特殊分布的数据”中，这些情况的出现概率往往很小，因此并不能最真实地反映算法运行效率。**相对地，「平均时间复杂度」可以体现算法在随机输入数据下的运行效率，用 $\Theta$ 记号（Theta Notation）来表示**。
|
||||
|
||||
对于部分算法，我们可以简单地推算出随机数据分布下的平均情况。比如上述示例，由于输入数组是被打乱的，因此元素 $1$ 出现在任意索引的概率都是相等的，那么算法的平均循环次数则是数组长度的一半 $\frac{n}{2}$ ，平均时间复杂度为 $\Theta(\frac{n}{2}) = \Theta(n)$ 。
|
||||
|
||||
|
||||
@@ -10,7 +10,7 @@ comments: true
|
||||
|
||||
**「逻辑结构」反映了数据之间的逻辑关系。** 数组和链表的数据按照顺序依次排列，反映了数据间的线性关系；树从顶至底按层级排列，反映了祖先与后代之间的派生关系；图由结点和边组成，反映了复杂网络关系。
|
||||
|
||||
我们一般将逻辑结构分为「线性」和「非线性」两种。“线性” 这个概念很直观，即表明数据在逻辑关系上是排成一条线的；而如果数据之间的逻辑关系是非线形的（例如是网状或树状的），那么就是非线性数据结构。
|
||||
我们一般将逻辑结构分为「线性」和「非线性」两种。“线性”这个概念很直观，即表明数据在逻辑关系上是排成一条线的；而如果数据之间的逻辑关系是非线形的（例如是网状或树状的），那么就是非线性数据结构。
|
||||
|
||||
- **线性数据结构：** 数组、链表、栈、队列、哈希表；
|
||||
- **非线性数据结构：** 树、图、堆、哈希表；
|
||||
@@ -40,4 +40,4 @@ comments: true
|
||||
|
||||
!!! tip
|
||||
|
||||
数组与链表是其他所有数据结构的 “底层积木”，建议读者一定要多花些时间了解。
|
||||
数组与链表是其他所有数据结构的“底层积木”，建议读者一定要多花些时间了解。
|
||||
|
||||
@@ -10,10 +10,10 @@ comments: true
|
||||
|
||||
**「基本数据类型」是 CPU 可以直接进行运算的类型，在算法中直接被使用。**
|
||||
|
||||
- 「整数」根据不同的长度分为 byte, short, int, long ，根据算法需求选用，即在满足取值范围的情况下尽量减小内存空间占用。
|
||||
- 「浮点数」代表小数，根据长度分为 float, double ，同样根据算法的实际需求选用。
|
||||
- 「字符」在计算机中是以字符集的形式保存的，char 的值实际上是数字，代表字符集中的编号，计算机通过字符集查表来完成编号到字符的转换。
|
||||
- 「布尔」代表逻辑中的 ”是“ 与 ”否“ ，其占用空间需要具体根据编程语言确定，通常为 1 byte 或 1 bit 。
|
||||
- 「整数」根据不同的长度分为 byte, short, int, long ，根据算法需求选用，即在满足取值范围的情况下尽量减小内存空间占用；
|
||||
- 「浮点数」代表小数，根据长度分为 float, double ，同样根据算法的实际需求选用；
|
||||
- 「字符」在计算机中是以字符集的形式保存的，char 的值实际上是数字，代表字符集中的编号，计算机通过字符集查表来完成编号到字符的转换。占用空间与具体编程语言有关，通常为 2 bytes 或 1 byte ；
|
||||
- 「布尔」代表逻辑中的 ”是“ 与 ”否“ ，其占用空间需要具体根据编程语言确定，通常为 1 byte 或 1 bit ；
|
||||
|
||||
!!! note "字节与比特"
|
||||
|
||||
@@ -31,7 +31,7 @@ comments: true
|
||||
| | long | 8 bytes | $-2^{63}$ ~ $2^{63} - 1$ | $0$ |
|
||||
| 浮点数 | **float** | 4 bytes | $-3.4 \times 10^{38}$ ~ $3.4 \times 10^{38}$ | $0.0$ f |
|
||||
| | double | 8 bytes | $-1.7 \times 10^{308}$ ~ $1.7 \times 10^{308}$ | $0.0$ |
|
||||
| 字符 | **char** | 2 bytes | $0$ ~ $2^{16} - 1$ | $0$ |
|
||||
| 字符 | **char** | 2 bytes / 1 byte | $0$ ~ $2^{16} - 1$ | $0$ |
|
||||
| 布尔 | **boolean(bool)** | 1 byte / 1 bit | $\text{true}$ 或 $\text{false}$ | $\text{false}$ |
|
||||
|
||||
</div>
|
||||
@@ -42,7 +42,7 @@ comments: true
|
||||
|
||||
**「基本数据类型」与「数据结构」之间的联系与区别**
|
||||
|
||||
我们知道，数据结构是在计算机中 **组织与存储数据的方式** ，它的主语是 “结构” ，而不是 “数据” 。比如，我们想要表示 “一排数字” ，自然应该使用「数组」这个数据结构。数组的存储方式使之可以表示数字的相邻关系、先后关系等一系列我们需要的信息，但至于其中存储的是整数 int ，还是小数 float ，或是字符 char ，**则与所谓的数据的结构无关了**。
|
||||
我们知道，数据结构是在计算机中 **组织与存储数据的方式** ，它的主语是“结构”，而不是“数据”。比如，我们想要表示“一排数字”，自然应该使用「数组」这个数据结构。数组的存储方式使之可以表示数字的相邻关系、先后关系等一系列我们需要的信息，但至于其中存储的是整数 int ，还是小数 float ，或是字符 char ，**则与所谓的数据的结构无关了**。
|
||||
|
||||
=== "Java"
|
||||
|
||||
@@ -57,13 +57,18 @@ comments: true
|
||||
=== "C++"
|
||||
|
||||
```cpp title=""
|
||||
|
||||
/* 使用多种「基本数据类型」来初始化「数组」 */
|
||||
int numbers[5];
|
||||
float decimals[5];
|
||||
char characters[5];
|
||||
bool booleans[5];
|
||||
```
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python title=""
|
||||
|
||||
""" Python 的 list 可以自由存储各种基本数据类型和对象 """
|
||||
list = [0, 0.0, 'a', False]
|
||||
```
|
||||
|
||||
=== "Go"
|
||||
@@ -87,13 +92,22 @@ comments: true
|
||||
=== "C"
|
||||
|
||||
```c title=""
|
||||
/* 使用多种「基本数据类型」来初始化「数组」 */
|
||||
int numbers[10];
|
||||
float decimals[10];
|
||||
char characters[10];
|
||||
bool booleans[10];
|
||||
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
|
||||
```csharp title=""
|
||||
|
||||
/* 使用多种「基本数据类型」来初始化「数组」 */
|
||||
int[] numbers = new int[5];
|
||||
float[] decimals = new float[5];
|
||||
char[] characters = new char[5];
|
||||
bool[] booleans = new bool[5];
|
||||
```
|
||||
|
||||
## 计算机内存
|
||||
|
||||
@@ -4,7 +4,7 @@ comments: true
|
||||
|
||||
# 哈希冲突处理
|
||||
|
||||
理想情况下，哈希函数应该为每个输入产生唯一的输出，使得 key 和 value 一一对应。而实际上，往往存在不同 key 对应相同 value 的情况，这种情况被称为「哈希冲突 Hash Collision」。
|
||||
理想情况下，哈希函数应该为每个输入产生唯一的输出，使得 key 和 value 一一对应。而实际上，往往存在向哈希函数输入不同的 key 而产生相同输出的情况，这种情况被称为「哈希冲突 Hash Collision」。
|
||||
|
||||
**哈希冲突会严重影响哈希表的实用性**。试想一下，如果在哈希表中总是查找到错误的结果，那么我们肯定不会继续使用这样的数据结构了。
|
||||
|
||||
@@ -40,7 +40,7 @@ comments: true
|
||||
|
||||
## 开放寻址
|
||||
|
||||
「开放寻址」不引入额外数据结构，而是通过 “向后探测” 来解决哈希冲突。根据探测方法的不同，主要分为 **线性探测、平方探测、多次哈希**。
|
||||
「开放寻址」不引入额外数据结构，而是通过“向后探测”来解决哈希冲突。根据探测方法的不同，主要分为 **线性探测、平方探测、多次哈希**。
|
||||
|
||||
### 线性探测
|
||||
|
||||
@@ -58,7 +58,7 @@ comments: true
|
||||
线性探测有以下缺陷：
|
||||
|
||||
- **不能直接删除元素**。删除元素会导致桶内出现一个空位，在查找其他元素时，该空位有可能导致程序认为元素不存在（即上述第 `2.` 种情况）。因此需要借助一个标志位来标记删除元素。
|
||||
- **容易产生聚集**。桶内被占用的连续位置越长，这些连续位置发生哈希冲突的可能性越大，从而进一步促进这一位置的 “聚堆生长” ，最终导致增删查改操作效率的劣化。
|
||||
- **容易产生聚集**。桶内被占用的连续位置越长，这些连续位置发生哈希冲突的可能性越大，从而进一步促进这一位置的“聚堆生长”，最终导致增删查改操作效率的劣化。
|
||||
|
||||
### 多次哈希
|
||||
|
||||
|
||||
@@ -6,7 +6,7 @@ comments: true
|
||||
|
||||
哈希表通过建立「键 key」和「值 value」之间的映射，实现高效的元素查找。具体地，输入一个 key ，在哈希表中查询并获取 value ，时间复杂度为 $O(1)$ 。
|
||||
|
||||
例如，给定一个包含 $n$ 个学生的数据库，每个学生有 "姓名 `name` ” 和 “学号 `id` ” 两项数据，希望实现一个查询功能：**输入一个学号，返回对应的姓名**，则可以使用哈希表实现。
|
||||
例如，给定一个包含 $n$ 个学生的数据库，每个学生有“姓名 `name` ”和“学号 `id` ”两项数据，希望实现一个查询功能：**输入一个学号，返回对应的姓名**，则可以使用哈希表实现。
|
||||
|
||||
|
||||
|
||||
@@ -132,13 +132,50 @@ comments: true
|
||||
=== "JavaScript"
|
||||
|
||||
```js title="hash_map.js"
|
||||
/* 初始化哈希表 */
|
||||
const map = new ArrayHashMap();
|
||||
/* 添加操作 */
|
||||
// 在哈希表中添加键值对 (key, value)
|
||||
map.set(12836, '小哈');
|
||||
map.set(15937, '小啰');
|
||||
map.set(16750, '小算');
|
||||
map.set(13276, '小法');
|
||||
map.set(10583, '小鸭');
|
||||
|
||||
/* 查询操作 */
|
||||
// 向哈希表输入键 key ，得到值 value
|
||||
let name = map.get(15937);
|
||||
|
||||
/* 删除操作 */
|
||||
// 在哈希表中删除键值对 (key, value)
|
||||
map.delete(10583);
|
||||
```
|
||||
|
||||
=== "TypeScript"
|
||||
|
||||
```typescript title="hash_map.ts"
|
||||
/* 初始化哈希表 */
|
||||
const map = new Map<number, string>();
|
||||
/* 添加操作 */
|
||||
// 在哈希表中添加键值对 (key, value)
|
||||
map.set(12836, '小哈');
|
||||
map.set(15937, '小啰');
|
||||
map.set(16750, '小算');
|
||||
map.set(13276, '小法');
|
||||
map.set(10583, '小鸭');
|
||||
console.info('\n添加完成后，哈希表为\nKey -> Value');
|
||||
console.info(map);
|
||||
|
||||
/* 查询操作 */
|
||||
// 向哈希表输入键 key ，得到值 value
|
||||
let name = map.get(15937);
|
||||
console.info('\n输入学号 15937 ，查询到姓名 ' + name);
|
||||
|
||||
/* 删除操作 */
|
||||
// 在哈希表中删除键值对 (key, value)
|
||||
map.delete(10583);
|
||||
console.info('\n删除 10583 后，哈希表为\nKey -> Value');
|
||||
console.info(map);
|
||||
```
|
||||
|
||||
=== "C"
|
||||
@@ -150,7 +187,24 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```csharp title="hash_map.cs"
|
||||
/* 初始化哈希表 */
|
||||
Dictionary<int, String> map = new ();
|
||||
|
||||
/* 添加操作 */
|
||||
// 在哈希表中添加键值对 (key, value)
|
||||
map.Add(12836, "小哈");
|
||||
map.Add(15937, "小啰");
|
||||
map.Add(16750, "小算");
|
||||
map.Add(13276, "小法");
|
||||
map.Add(10583, "小鸭");
|
||||
|
||||
/* 查询操作 */
|
||||
// 向哈希表输入键 key ，得到值 value
|
||||
String name = map[15937];
|
||||
|
||||
/* 删除操作 */
|
||||
// 在哈希表中删除键值对 (key, value)
|
||||
map.Remove(10583);
|
||||
```
|
||||
|
||||
遍历哈希表有三种方式，即 **遍历键值对、遍历键、遍历值**。
|
||||
@@ -227,13 +281,38 @@ comments: true
|
||||
=== "JavaScript"
|
||||
|
||||
```js title="hash_map.js"
|
||||
|
||||
/* 遍历哈希表 */
|
||||
// 遍历键值对 key->value
|
||||
for (const entry of map.entries()) {
|
||||
if (!entry) continue;
|
||||
console.info(entry.key + ' -> ' + entry.val);
|
||||
}
|
||||
// 单独遍历键 key
|
||||
for (const key of map.keys()) {
|
||||
console.info(key);
|
||||
}
|
||||
// 单独遍历值 value
|
||||
for (const val of map.values()) {
|
||||
console.info(val);
|
||||
}
|
||||
```
|
||||
|
||||
=== "TypeScript"
|
||||
|
||||
```typescript title="hash_map.ts"
|
||||
|
||||
/* 遍历哈希表 */
|
||||
console.info('\n遍历键值对 Key->Value');
|
||||
for (const [k, v] of map.entries()) {
|
||||
console.info(k + ' -> ' + v);
|
||||
}
|
||||
console.info('\n单独遍历键 Key');
|
||||
for (const k of map.keys()) {
|
||||
console.info(k);
|
||||
}
|
||||
console.info('\n单独遍历值 Value');
|
||||
for (const v of map.values()) {
|
||||
console.info(v);
|
||||
}
|
||||
```
|
||||
|
||||
=== "C"
|
||||
@@ -245,7 +324,19 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```csharp title="hash_map.cs"
|
||||
|
||||
/* 遍历哈希表 */
|
||||
// 遍历键值对 Key->Value
|
||||
foreach (var kv in map) {
|
||||
Console.WriteLine(kv.Key + " -> " + kv.Value);
|
||||
}
|
||||
// 单独遍历键 key
|
||||
foreach (int key in map.Keys) {
|
||||
Console.WriteLine(key);
|
||||
}
|
||||
// 单独遍历值 value
|
||||
foreach (String val in map.Values) {
|
||||
Console.WriteLine(val);
|
||||
}
|
||||
```
|
||||
|
||||
## 哈希函数
|
||||
@@ -471,13 +562,133 @@ $$
|
||||
=== "JavaScript"
|
||||
|
||||
```js title="array_hash_map.js"
|
||||
/* 键值对 Number -> String */
|
||||
class Entry {
|
||||
constructor(key, val) {
|
||||
this.key = key;
|
||||
this.val = val;
|
||||
}
|
||||
}
|
||||
|
||||
/* 基于数组简易实现的哈希表 */
|
||||
class ArrayHashMap {
|
||||
#bucket;
|
||||
constructor() {
|
||||
// 初始化一个长度为 100 的桶（数组）
|
||||
this.#bucket = new Array(100).fill(null);
|
||||
}
|
||||
|
||||
/* 哈希函数 */
|
||||
#hashFunc(key) {
|
||||
return key % 100;
|
||||
}
|
||||
|
||||
/* 查询操作 */
|
||||
get(key) {
|
||||
let index = this.#hashFunc(key);
|
||||
let entry = this.#bucket[index];
|
||||
if (entry === null) return null;
|
||||
return entry.val;
|
||||
}
|
||||
|
||||
/* 添加操作 */
|
||||
set(key, val) {
|
||||
let index = this.#hashFunc(key);
|
||||
this.#bucket[index] = new Entry(key, val);
|
||||
}
|
||||
|
||||
/* 删除操作 */
|
||||
delete(key) {
|
||||
let index = this.#hashFunc(key);
|
||||
// 置为 null ，代表删除
|
||||
this.#bucket[index] = null;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
=== "TypeScript"
|
||||
|
||||
```typescript title="array_hash_map.ts"
|
||||
|
||||
/* 键值对 Number -> String */
|
||||
class Entry {
|
||||
public key: number;
|
||||
public val: string;
|
||||
|
||||
constructor(key: number, val: string) {
|
||||
this.key = key;
|
||||
this.val = val;
|
||||
}
|
||||
}
|
||||
|
||||
/* 基于数组简易实现的哈希表 */
|
||||
class ArrayHashMap {
|
||||
|
||||
private readonly bucket: (Entry | null)[];
|
||||
|
||||
constructor() {
|
||||
// 初始化一个长度为 100 的桶（数组）
|
||||
this.bucket = (new Array(100)).fill(null);
|
||||
}
|
||||
|
||||
/* 哈希函数 */
|
||||
private hashFunc(key: number): number {
|
||||
return key % 100;
|
||||
}
|
||||
|
||||
/* 查询操作 */
|
||||
public get(key: number): string | null {
|
||||
let index = this.hashFunc(key);
|
||||
let entry = this.bucket[index];
|
||||
if (entry === null) return null;
|
||||
return entry.val;
|
||||
}
|
||||
|
||||
/* 添加操作 */
|
||||
public set(key: number, val: string) {
|
||||
let index = this.hashFunc(key);
|
||||
this.bucket[index] = new Entry(index, val);
|
||||
}
|
||||
|
||||
/* 删除操作 */
|
||||
public delete(key: number) {
|
||||
let index = this.hashFunc(key);
|
||||
// 置为 null ，代表删除
|
||||
this.bucket[index] = null;
|
||||
}
|
||||
|
||||
/* 获取所有键值对 */
|
||||
public entries(): (Entry | null)[] {
|
||||
let arr: (Entry | null)[] = [];
|
||||
for (let i = 0; i < this.bucket.length; i++) {
|
||||
if (this.bucket[i]) {
|
||||
arr.push(this.bucket[i]);
|
||||
}
|
||||
}
|
||||
return arr;
|
||||
}
|
||||
|
||||
/* 获取所有键 */
|
||||
public keys(): (number | undefined)[] {
|
||||
let arr: (number | undefined)[] = [];
|
||||
for (let i = 0; i < this.bucket.length; i++) {
|
||||
if (this.bucket[i]) {
|
||||
arr.push(this.bucket[i]?.key);
|
||||
}
|
||||
}
|
||||
return arr;
|
||||
}
|
||||
|
||||
/* 获取所有值 */
|
||||
public values(): (string | undefined)[] {
|
||||
let arr: (string | undefined)[] = [];
|
||||
for (let i = 0; i < this.bucket.length; i++) {
|
||||
if (this.bucket[i]) {
|
||||
arr.push(this.bucket[i]?.val);
|
||||
}
|
||||
}
|
||||
return arr;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
=== "C"
|
||||
@@ -489,7 +700,60 @@ $$
|
||||
=== "C#"
|
||||
|
||||
```csharp title="array_hash_map.cs"
|
||||
/* 键值对 int->String */
|
||||
class Entry
|
||||
{
|
||||
public int key;
|
||||
public String val;
|
||||
public Entry(int key, String val)
|
||||
{
|
||||
this.key = key;
|
||||
this.val = val;
|
||||
}
|
||||
}
|
||||
|
||||
/* 基于数组简易实现的哈希表 */
|
||||
class ArrayHashMap
|
||||
{
|
||||
private List<Entry?> bucket;
|
||||
public ArrayHashMap()
|
||||
{
|
||||
// 初始化一个长度为 100 的桶（数组）
|
||||
bucket = new ();
|
||||
for (int i = 0; i < 100; i++)
|
||||
{
|
||||
bucket.Add(null);
|
||||
}
|
||||
}
|
||||
/* 哈希函数 */
|
||||
private int hashFunc(int key)
|
||||
{
|
||||
int index = key % 100;
|
||||
return index;
|
||||
}
|
||||
/* 查询操作 */
|
||||
public String? get(int key)
|
||||
{
|
||||
int index = hashFunc(key);
|
||||
Entry? pair = bucket[index];
|
||||
if (pair == null) return null;
|
||||
return pair.val;
|
||||
}
|
||||
/* 添加操作 */
|
||||
public void put(int key, String val)
|
||||
{
|
||||
Entry pair = new Entry(key, val);
|
||||
int index = hashFunc(key);
|
||||
bucket[index]=pair;
|
||||
}
|
||||
/* 删除操作 */
|
||||
public void remove(int key)
|
||||
{
|
||||
int index = hashFunc(key);
|
||||
// 置为 null ，代表删除
|
||||
bucket[index]=null;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## 哈希冲突
|
||||
@@ -510,4 +774,4 @@ $$
|
||||
|
||||
- 尽量少地发生哈希冲突；
|
||||
- 时间复杂度 $O(1)$ ，计算尽可能高效；
|
||||
- 空间使用率高，即 “键值对占用空间 / 哈希表总占用空间” 尽可能大；
|
||||
- 空间使用率高，即“键值对占用空间 / 哈希表总占用空间”尽可能大；
|
||||
|
||||
@@ -4,7 +4,7 @@ comments: true
|
||||
|
||||
# 算法无处不在
|
||||
|
||||
听到 “算法” 这个词，我们一般会联想到数学。但实际上，大多数算法并不包含复杂的数学，而更像是在考察基本逻辑，而这些逻辑在我们日常生活中处处可见。
|
||||
听到“算法”这个词，我们一般会联想到数学。但实际上，大多数算法并不包含复杂的数学，而更像是在考察基本逻辑，而这些逻辑在我们日常生活中处处可见。
|
||||
|
||||
在正式介绍算法之前，我想告诉你一件有趣的事：**其实，你在过去已经学会了很多算法，并且已经习惯将它们应用到日常生活中。** 接下来，我将介绍两个具体例子来佐证。
|
||||
|
||||
|
||||
@@ -31,12 +31,23 @@ comments: true
|
||||
- 算法是发挥数据结构优势的舞台。数据结构仅存储数据信息，结合算法才可解决特定问题。
|
||||
- 算法有对应最优的数据结构。给定算法，一般可基于不同的数据结构实现，而最终执行效率往往相差很大。
|
||||
|
||||
如果将数据结构与算法比作「LEGO 乐高」，数据结构就是乐高「积木」，而算法就是把积木拼成目标形态的一系列「操作步骤」。
|
||||
|
||||
|
||||
|
||||
<p align="center"> Fig. 数据结构与算法的关系 </p>
|
||||
|
||||
如果将「LEGO 乐高」类比到「数据结构与算法」，那么可以得到下表所示的对应关系。
|
||||
|
||||
<div class="center-table" markdown>
|
||||
|
||||
| 数据结构与算法 | LEGO 乐高 |
|
||||
| -------------- | ---------------------------------------- |
|
||||
| 输入数据 | 未拼装的积木 |
|
||||
| 数据结构 | 积木组织形式，包括形状、大小、连接方式等 |
|
||||
| 算法 | 把积木拼成目标形态的一系列操作步骤 |
|
||||
| 输出数据 | 积木模型 |
|
||||
|
||||
</div>
|
||||
|
||||
!!! tip "约定俗成的简称"
|
||||
|
||||
在实际讨论中，我们通常会将「数据结构与算法」直接简称为「算法」。例如，我们熟称的 LeetCode 算法题目，实际上同时考察了数据结构和算法两部分知识。
|
||||
|
||||
@@ -4,11 +4,11 @@ comments: true
|
||||
|
||||
# 关于本书
|
||||
|
||||
五年前发生的一件事，成为了我职业生涯的重要转折点。当时的我在交大读研，对互联网求职一无所知，但仍然硬着头皮申请了 Microsoft 软件工程师实习。面试官让我在白板上写出 “快速排序” 代码，我畏畏缩缩地写了一个 “冒泡排序” ，并且还写错了` (ToT) ` 。从面试官的表情上，我看到了一个大大的 "GG" 。
|
||||
五年前发生的一件事，成为了我职业生涯的重要转折点。当时的我在交大读研，对互联网求职一无所知，但仍然硬着头皮申请了 Microsoft 软件工程师实习。面试官让我在白板上写出“快速排序”代码，我畏畏缩缩地写了一个“冒泡排序”，并且还写错了` (ToT) ` 。从面试官的表情上，我看到了一个大大的 "GG" 。
|
||||
|
||||
此次失利倒逼我开始刷算法题。我采用 “扫雷游戏” 式的学习方法，两眼一抹黑刷题，扫到不会的 “雷” 就通过查资料把它 “排掉” ，配合周期性总结，逐渐形成了数据结构与算法的知识图景。幸运地，我在秋招斩获了多家大厂的 Offer 。
|
||||
此次失利倒逼我开始刷算法题。我采用“扫雷游戏”式的学习方法，两眼一抹黑刷题，扫到不会的“雷”就通过查资料把它“排掉”，配合周期性总结，逐渐形成了数据结构与算法的知识图景。幸运地，我在秋招斩获了多家大厂的 Offer 。
|
||||
|
||||
回想自己当初在 “扫雷式” 刷题中被炸的满头包的痛苦，思考良久，我意识到一本 “前期刷题必看” 的读物可以使算法小白少走许多弯路。写作意愿滚滚袭来，那就动笔吧：
|
||||
回想自己当初在“扫雷式”刷题中被炸的满头包的痛苦，思考良久，我意识到一本“前期刷题必看”的读物可以使算法小白少走许多弯路。写作意愿滚滚袭来，那就动笔吧：
|
||||
|
||||
<h4 align="center"> Hello，算法！ </h4>
|
||||
|
||||
@@ -28,7 +28,7 @@ comments: true
|
||||
|
||||
- 本书篇幅不长，可以帮助你提纲挈领地回顾算法知识。
|
||||
- 书中包含许多对比性、总结性的算法内容，可以帮助你梳理算法知识体系。
|
||||
- 源代码实现了各种经典数据结构和算法，可以作为 “刷题工具库” 来使用。
|
||||
- 源代码实现了各种经典数据结构和算法，可以作为“刷题工具库”来使用。
|
||||
|
||||
如果您是 **算法大佬**，请受我膜拜！希望您可以抽时间提出意见建议，或者[一起参与创作](https://www.hello-algo.com/chapter_preface/contribution/)，帮助各位同学获取更好的学习内容，感谢！
|
||||
|
||||
@@ -99,15 +99,15 @@ comments: true
|
||||
|
||||
**视觉化学习。** 信息时代以来，视觉化的脚步从未停止。媒体形式经历了文字短信、图文 Email 、动图、短（长）视频、交互式 Web 、3D 游戏等演变过程，信息的视觉化程度越来越高、愈加符合人类感官、信息传播效率大大提升。科技界也在向视觉化迈进，iPhone 就是一个典型例子，其相对于传统手机是高度视觉化的，包含精心设计的字体、主题配色、交互动画等。
|
||||
|
||||
近两年，短视频成为最受欢迎的信息媒介，可以在短时间内将高密度的信息 “灌” 给我们，有着极其舒适的观看体验。阅读则不然，读者与书本之间天然存在一种 “疏离感”，我们看书会累、会走神、会停下来想其他事、会划下喜欢的句子、会思考某一片段的含义，这种疏离感给了读者与书本之间对话的可能，拓宽了想象空间。
|
||||
近两年，短视频成为最受欢迎的信息媒介，可以在短时间内将高密度的信息“灌”给我们，有着极其舒适的观看体验。阅读则不然，读者与书本之间天然存在一种“疏离感”，我们看书会累、会走神、会停下来想其他事、会划下喜欢的句子、会思考某一片段的含义，这种疏离感给了读者与书本之间对话的可能，拓宽了想象空间。
|
||||
|
||||
本书作为一本入门教材，希望可以保有书本的 “慢节奏” ，但也会避免与读者产生过多 “疏离感” ，而是努力将知识完整清晰地推送到你聪明的小脑袋瓜中。我将采用视觉化的方式（例如配图、动画），尽我可能清晰易懂地讲解复杂概念和抽象示例。
|
||||
本书作为一本入门教材，希望可以保有书本的“慢节奏”，但也会避免与读者产生过多“疏离感”，而是努力将知识完整清晰地推送到你聪明的小脑袋瓜中。我将采用视觉化的方式（例如配图、动画），尽我可能清晰易懂地讲解复杂概念和抽象示例。
|
||||
|
||||
**内容精简化。** 大多数的经典教科书，会把每个主题都讲的很透彻。虽然透彻性正是其获得读者青睐的原因，但对于想要快速入门的初学者来说，这些教材的实用性不足。本书会避免引入非必要的概念、名词、定义等，也避免展开不必要的理论分析，毕竟这不是一本真正意义上的教材，主要任务是尽快地带领读者入门。
|
||||
|
||||
引入一些生活案例或趣味内容，非常适合作为知识点的引子或者解释的补充，但当融入过多额外元素时，内容会稍显冗长，也许反而使读者容易迷失、抓不住重点，这也是本书需要避免的。
|
||||
|
||||
敲代码如同写字，“美” 是统一的追求。本书力求美观的代码，保证规范的变量命名、统一的空格与换行、对齐的缩进、整齐的注释等。
|
||||
敲代码如同写字，“美”是统一的追求。本书力求美观的代码，保证规范的变量命名、统一的空格与换行、对齐的缩进、整齐的注释等。
|
||||
|
||||
## 致谢
|
||||
|
||||
@@ -115,7 +115,7 @@ comments: true
|
||||
|
||||
- 感谢我的女朋友泡泡担任本书的首位读者，从算法小白的视角为本书的写作提出了许多建议，使这本书更加适合算法初学者来阅读。
|
||||
- 感谢腾宝、琦宝、飞宝为本书起了个响当当的名字，好听又有梗，直接唤起我最初敲下第一行代码 "Hello, World!" 的回忆。
|
||||
- 感谢我的导师李博，在小酌畅谈时您告诉我 “觉得适合、想做就去做” ，坚定了我写这本书的决心。
|
||||
- 感谢我的导师李博，在小酌畅谈时您告诉我“觉得适合、想做就去做”，坚定了我写这本书的决心。
|
||||
- 感谢苏潼为本书设计了封面和 LOGO ，我有些强迫症，前后多次修改，谢谢你的耐心。
|
||||
- 感谢 @squidfunk ，包括 [Material-for-MkDocs](https://github.com/squidfunk/mkdocs-material/tree/master) 顶级开源项目以及给出的写作排版建议。
|
||||
|
||||
|
||||
@@ -14,10 +14,10 @@ comments: true
|
||||
|
||||
每个页面的右上角都有一个「编辑」按钮，你可以按照以下步骤修改文章：
|
||||
|
||||
1. 点击编辑按钮，如果遇到提示 “需要 Fork 此仓库” ，请通过；
|
||||
1. 点击编辑按钮，如果遇到提示“需要 Fork 此仓库”，请通过；
|
||||
2. 修改 Markdown 源文件内容；
|
||||
3. 在页面底部填写更改说明，然后单击 “Propose file change” 按钮；
|
||||
4. 页面跳转后，点击 “Create pull request” 按钮发起拉取请求即可，我会第一时间查看处理并及时更新内容。
|
||||
3. 在页面底部填写更改说明，然后单击“Propose file change”按钮；
|
||||
4. 页面跳转后，点击“Create pull request”按钮发起拉取请求即可，我会第一时间查看处理并及时更新内容。
|
||||
|
||||
|
||||
|
||||
@@ -37,7 +37,7 @@ comments: true
|
||||
2. 进入 Fork 仓库网页，使用 `git clone` 克隆该仓库至本地；
|
||||
3. 在本地进行内容创作（建议通过运行测试来验证代码正确性）；
|
||||
4. 将本地更改 Commit ，并 Push 至远程仓库；
|
||||
5. 刷新仓库网页，点击 “Create pull request” 按钮发起拉取请求（Pull Request）即可；
|
||||
5. 刷新仓库网页，点击“Create pull request”按钮发起拉取请求（Pull Request）即可；
|
||||
|
||||
非常欢迎您和我一同来创作本书！
|
||||
|
||||
|
||||
@@ -12,9 +12,10 @@ comments: true
|
||||
|
||||
## Java 环境
|
||||
|
||||
1. 下载并安装 [OpenJDK](https://jdk.java.net/18/) 。
|
||||
1. 下载并安装 [OpenJDK](https://jdk.java.net/18/)（版本需满足 > JDK 9）。
|
||||
2. 在 VSCode 的插件市场中搜索 `java` ，安装 Java Extension Pack 。
|
||||
|
||||
|
||||
## C++ 环境
|
||||
|
||||
1. Windows 系统需要安装 [MinGW](https://www.mingw-w64.org/downloads/) ，MacOS 自带 Clang 无需安装。
|
||||
|
||||
@@ -26,7 +26,7 @@ comments: true
|
||||
git clone https://github.com/krahets/hello-algo.git
|
||||
```
|
||||
|
||||
当然，你也可以点击 “Download ZIP” 直接下载代码压缩包，解压即可。
|
||||
当然，你也可以点击“Download ZIP”直接下载代码压缩包，解压即可。
|
||||
|
||||
|
||||
|
||||
@@ -46,17 +46,17 @@ git clone https://github.com/krahets/hello-algo.git
|
||||
|
||||
## 提问讨论学
|
||||
|
||||
阅读本书时，请不要 “惯着” 那些弄不明白的知识点。如果有任何疑惑，**可以在评论区留下你的问题**，小伙伴们和我都会给予解答（您一般 3 天内会得到回复）。
|
||||
阅读本书时，请不要“惯着”那些弄不明白的知识点。如果有任何疑惑，**可以在评论区留下你的问题**，小伙伴们和我都会给予解答（您一般 3 天内会得到回复）。
|
||||
|
||||
同时，也希望你可以多花时间逛逛评论区。一方面，可以看看大家遇到了什么问题，反过来查漏补缺，这往往可以引起更加深度的思考。另一方面，也希望你可以慷慨地解答小伙伴们的问题、分享自己的见解，大家一起加油与进步！
|
||||
|
||||
|
||||
|
||||
## 算法学习 “三步走”
|
||||
## 算法学习“三步走”
|
||||
|
||||
**第一阶段，算法入门，也正是本书的定位。** 熟悉各种数据结构的特点、用法，学习各种算法的工作原理、用途、效率等。
|
||||
|
||||
**第二阶段，刷算法题。** 可以先从热门题单开刷，推荐 [剑指 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 道题量，熟悉大多数的算法问题。刚开始刷题时，“遗忘”是最大的困扰点，但这是很正常的，请不要担心。学习中有一种概念叫“周期性回顾”，同一道题隔段时间做一次，当做了三遍以上，往往就能牢记于心了。
|
||||
|
||||
**第三阶段，搭建知识体系。** 在学习方面，可以阅读算法专栏文章、解题框架、算法教材，不断地丰富知识体系。在刷题方面，可以开始采用进阶刷题方案，例如按专题分类、一题多解、一解多题等，刷题方案在社区中可以找到一些讲解，在此不做赘述。
|
||||
|
||||
|
||||
@@ -24,39 +24,32 @@ $$
|
||||
1. **双闭区间 $[0, n-1]$** ，即两个边界都包含自身；此方法下，区间 $[0, 0]$ 仍包含一个元素；
|
||||
2. **左闭右开 $[0, n)$** ，即左边界包含自身、右边界不包含自身；此方法下，区间 $[0, 0)$ 为空；
|
||||
|
||||
### “双闭区间” 实现
|
||||
### “双闭区间”实现
|
||||
|
||||
首先，我们先采用 “双闭区间” 的表示，在数组 `nums` 中查找目标元素 `target` 的对应索引。
|
||||
首先，我们先采用“双闭区间”的表示，在数组 `nums` 中查找目标元素 `target` 的对应索引。
|
||||
|
||||
=== "Step 1"
|
||||
|
||||
|
||||
|
||||
=== "Step 2"
|
||||
|
||||
|
||||
|
||||
=== "Step 3"
|
||||
|
||||
|
||||
|
||||
=== "Step 4"
|
||||
|
||||
|
||||
|
||||
=== "Step 5"
|
||||
|
||||
|
||||
|
||||
=== "Step 6"
|
||||
|
||||
|
||||
|
||||
=== "Step 7"
|
||||
|
||||
|
||||
|
||||
二分查找 “双闭区间” 表示下的代码如下所示。
|
||||
二分查找“双闭区间”表示下的代码如下所示。
|
||||
|
||||
=== "Java"
|
||||
|
||||
@@ -146,7 +139,23 @@ $$
|
||||
=== "JavaScript"
|
||||
|
||||
```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; // 找到目标元素，返回其索引
|
||||
}
|
||||
// 未找到目标元素，返回 -1
|
||||
return -1;
|
||||
}
|
||||
```
|
||||
|
||||
=== "TypeScript"
|
||||
@@ -164,12 +173,30 @@ $$
|
||||
=== "C#"
|
||||
|
||||
```csharp title="binary_search.cs"
|
||||
|
||||
/* 二分查找（双闭区间） */
|
||||
int binarySearch(int[] nums, int target)
|
||||
{
|
||||
// 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
|
||||
int i = 0, j = nums.Length - 1;
|
||||
// 循环，当搜索区间为空时跳出（当 i > j 时为空）
|
||||
while (i <= j)
|
||||
{
|
||||
int m = (i + j) / 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;
|
||||
}
|
||||
// 未找到目标元素，返回 -1
|
||||
return -1;
|
||||
}
|
||||
```
|
||||
|
||||
### “左闭右开” 实现
|
||||
### “左闭右开”实现
|
||||
|
||||
当然，我们也可以使用 “左闭右开” 的表示方法，写出相同功能的二分查找代码。
|
||||
当然，我们也可以使用“左闭右开”的表示方法，写出相同功能的二分查找代码。
|
||||
|
||||
=== "Java"
|
||||
|
||||
@@ -260,7 +287,23 @@ $$
|
||||
=== "JavaScript"
|
||||
|
||||
```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;
|
||||
}
|
||||
// 未找到目标元素，返回 -1
|
||||
return -1;
|
||||
}
|
||||
```
|
||||
|
||||
=== "TypeScript"
|
||||
@@ -278,7 +321,25 @@ $$
|
||||
=== "C#"
|
||||
|
||||
```csharp title="binary_search.cs"
|
||||
|
||||
/* 二分查找（左闭右开） */
|
||||
int binarySearch1(int[] nums, int target)
|
||||
{
|
||||
// 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
|
||||
int i = 0, j = nums.Length;
|
||||
// 循环，当搜索区间为空时跳出（当 i = j 时为空）
|
||||
while (i < j)
|
||||
{
|
||||
int m = (i + j) / 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;
|
||||
}
|
||||
// 未找到目标元素，返回 -1
|
||||
return -1;
|
||||
}
|
||||
```
|
||||
|
||||
### 两种表示对比
|
||||
@@ -294,7 +355,7 @@ $$
|
||||
|
||||
</div>
|
||||
|
||||
观察发现，在 “双闭区间” 表示中，由于对左右两边界的定义是相同的，因此缩小区间的 $i$ , $j$ 处理方法也是对称的，这样更不容易出错。综上所述，**建议你采用 “双闭区间” 的写法。**
|
||||
观察发现，在“双闭区间”表示中，由于对左右两边界的定义是相同的，因此缩小区间的 $i$ , $j$ 处理方法也是对称的，这样更不容易出错。综上所述，**建议你采用“双闭区间”的写法。**
|
||||
|
||||
### 大数越界处理
|
||||
|
||||
@@ -337,7 +398,10 @@ $$
|
||||
=== "JavaScript"
|
||||
|
||||
```js title=""
|
||||
|
||||
// (i + j) 有可能超出 int 的取值范围
|
||||
let m = parseInt((i + j) / 2);
|
||||
// 更换为此写法则不会越界
|
||||
let m = parseInt(i + (j - i) / 2);
|
||||
```
|
||||
|
||||
=== "TypeScript"
|
||||
@@ -355,7 +419,10 @@ $$
|
||||
=== "C#"
|
||||
|
||||
```csharp title=""
|
||||
|
||||
// (i + j) 有可能超出 int 的取值范围
|
||||
int m = (i + j) / 2;
|
||||
// 更换为此写法则不会越界
|
||||
int m = i + (j - i) / 2;
|
||||
```
|
||||
|
||||
## 复杂度分析
|
||||
|
||||
@@ -8,7 +8,7 @@ comments: true
|
||||
|
||||
在数据量很大时，「线性查找」太慢；而「二分查找」要求数据必须是有序的，并且只能在数组中应用。那么是否有方法可以同时避免上述缺点呢？答案是肯定的，此方法被称为「哈希查找」。
|
||||
|
||||
「哈希查找 Hash Searching」借助一个哈希表来存储需要的「键值对 Key Value Pair」，我们可以在 $O(1)$ 时间下实现 “键 $\rightarrow$ 值” 映射查找，体现着 “以空间换时间” 的算法思想。
|
||||
「哈希查找 Hash Searching」借助一个哈希表来存储需要的「键值对 Key Value Pair」，我们可以在 $O(1)$ 时间下实现“键 $\rightarrow$ 值”映射查找，体现着“以空间换时间”的算法思想。
|
||||
|
||||
## 算法实现
|
||||
|
||||
@@ -86,7 +86,13 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```csharp title="hashing_search.cs"
|
||||
|
||||
/* 哈希查找（数组） */
|
||||
int hashingSearch(Dictionary<int, int> map, int target)
|
||||
{
|
||||
// 哈希表的 key: 目标元素，value: 索引
|
||||
// 若哈希表中无此 key ，返回 -1
|
||||
return map.GetValueOrDefault(target, -1);
|
||||
}
|
||||
```
|
||||
|
||||
再比如，如果我们想要给定一个目标结点值 `target` ，获取对应的链表结点对象，那么也可以使用哈希查找实现。
|
||||
@@ -163,7 +169,14 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```csharp title="hashing_search.cs"
|
||||
/* 哈希查找（链表） */
|
||||
ListNode? hashingSearch1(Dictionary<int, ListNode> map, int target)
|
||||
{
|
||||
|
||||
// 哈希表的 key: 目标结点值，value: 结点对象
|
||||
// 若哈希表中无此 key ，返回 null
|
||||
return map.GetValueOrDefault(target);
|
||||
}
|
||||
```
|
||||
|
||||
## 复杂度分析
|
||||
|
||||
@@ -76,6 +76,18 @@ comments: true
|
||||
=== "JavaScript"
|
||||
|
||||
```js title="linear_search.js"
|
||||
/* 线性查找（数组） */
|
||||
function linearSearchArray(nums, target) {
|
||||
// 遍历数组
|
||||
for (let i = 0; i < nums.length; i++) {
|
||||
// 找到目标元素，返回其索引
|
||||
if (nums[i] === target) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
// 未找到目标元素，返回 -1
|
||||
return -1;
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
@@ -94,6 +106,19 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```csharp title="linear_search.cs"
|
||||
/* 线性查找（数组） */
|
||||
int linearSearch(int[] nums, int target)
|
||||
{
|
||||
// 遍历数组
|
||||
for (int i = 0; i < nums.Length; i++)
|
||||
{
|
||||
// 找到目标元素，返回其索引
|
||||
if (nums[i] == target)
|
||||
return i;
|
||||
}
|
||||
// 未找到目标元素，返回 -1
|
||||
return -1;
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
@@ -167,7 +192,19 @@ comments: true
|
||||
=== "JavaScript"
|
||||
|
||||
```js title="linear_search.js"
|
||||
|
||||
/* 线性查找（链表）*/
|
||||
function linearSearchLinkedList(head, target) {
|
||||
// 遍历链表
|
||||
while(head) {
|
||||
// 找到目标结点，返回之
|
||||
if(head.val === target) {
|
||||
return head;
|
||||
}
|
||||
head = head.next;
|
||||
}
|
||||
// 未找到目标结点，返回 null
|
||||
return null;
|
||||
}
|
||||
```
|
||||
|
||||
=== "TypeScript"
|
||||
@@ -185,7 +222,20 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```csharp title="linear_search.cs"
|
||||
|
||||
/* 线性查找（链表） */
|
||||
ListNode? linearSearch(ListNode head, int target)
|
||||
{
|
||||
// 遍历链表
|
||||
while (head != null)
|
||||
{
|
||||
// 找到目标结点，返回之
|
||||
if (head.val == target)
|
||||
return head;
|
||||
head = head.next;
|
||||
}
|
||||
// 未找到目标结点，返回 null
|
||||
return null;
|
||||
}
|
||||
```
|
||||
|
||||
## 复杂度分析
|
||||
|
||||
@@ -6,7 +6,7 @@ comments: true
|
||||
|
||||
「冒泡排序 Bubble Sort」是一种最基础的排序算法，非常适合作为第一个学习的排序算法。顾名思义，「冒泡」是该算法的核心操作。
|
||||
|
||||
!!! question "为什么叫 “冒泡”"
|
||||
!!! question "为什么叫“冒泡”"
|
||||
|
||||
在水中，越大的泡泡浮力越大，所以最大的泡泡会最先浮到水面。
|
||||
|
||||
@@ -176,7 +176,25 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```csharp title="bubble_sort.cs"
|
||||
|
||||
/* 冒泡排序 */
|
||||
void bubbleSort(int[] nums)
|
||||
{
|
||||
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
|
||||
for (int i = nums.Length - 1; i > 0; i--)
|
||||
{
|
||||
// 内循环：冒泡操作
|
||||
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;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## 算法特性
|
||||
@@ -340,5 +358,26 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```csharp title="bubble_sort.cs"
|
||||
|
||||
/* 冒泡排序（标志优化）*/
|
||||
void bubbleSortWithFlag(int[] nums)
|
||||
{
|
||||
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
|
||||
for (int i = nums.Length - 1; i > 0; i--)
|
||||
{
|
||||
bool flag = false; // 初始化标志位
|
||||
// 内循环：冒泡操作
|
||||
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;
|
||||
flag = true; // 记录交换元素
|
||||
}
|
||||
}
|
||||
if (!flag) break; // 此轮冒泡未交换任何元素，直接跳出
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
@@ -6,7 +6,7 @@ comments: true
|
||||
|
||||
「插入排序 Insertion Sort」是一种基于 **数组插入操作** 的排序算法。
|
||||
|
||||
「插入操作」的思想：选定数组的某个元素为基准数 `base` ，将 `base` 与其左边的元素依次对比大小，并 “插入” 到正确位置。
|
||||
「插入操作」的思想：选定数组的某个元素为基准数 `base` ，将 `base` 与其左边的元素依次对比大小，并“插入”到正确位置。
|
||||
|
||||
然而，由于数组在内存中的存储方式是连续的，我们无法直接把 `base` 插入到目标位置，而是需要将从目标位置到 `base` 之间的所有元素向右移动一位（本质上是一次数组插入操作）。
|
||||
|
||||
@@ -141,7 +141,22 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```csharp title="insertion_sort.cs"
|
||||
|
||||
/* 插入排序 */
|
||||
void insertionSort(int[] nums)
|
||||
{
|
||||
// 外循环：base = nums[1], nums[2], ..., nums[n-1]
|
||||
for (int i = 1; i < nums.Length; i++)
|
||||
{
|
||||
int bas = nums[i], j = i - 1;
|
||||
// 内循环：将 base 插入到左边的正确位置
|
||||
while (j >= 0 && nums[j] > bas)
|
||||
{
|
||||
nums[j + 1] = nums[j]; // 1. 将 nums[j] 向右移动一位
|
||||
j--;
|
||||
}
|
||||
nums[j + 1] = bas; // 2. 将 base 赋值到正确位置
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## 算法特性
|
||||
|
||||
@@ -4,7 +4,7 @@ comments: true
|
||||
|
||||
# 归并排序
|
||||
|
||||
「归并排序 Merge Sort」是算法中 “分治思想” 的典型体现，其有「划分」和「合并」两个阶段：
|
||||
「归并排序 Merge Sort」是算法中“分治思想”的典型体现，其有「划分」和「合并」两个阶段：
|
||||
|
||||
1. **划分阶段：** 通过递归不断 **将数组从中点位置划分开**，将长数组的排序问题转化为短数组的排序问题；
|
||||
2. **合并阶段：** 划分到子数组长度为 1 时，开始向上合并，不断将 **左、右两个短排序数组** 合并为 **一个长排序数组**，直至合并至原数组时完成排序；
|
||||
@@ -78,13 +78,13 @@ comments: true
|
||||
int i = leftStart, j = rightStart;
|
||||
// 通过覆盖原数组 nums 来合并左子数组和右子数组
|
||||
for (int k = left; k <= right; k++) {
|
||||
// 若 “左子数组已全部合并完”，则选取右子数组元素，并且 j++
|
||||
// 若“左子数组已全部合并完”，则选取右子数组元素，并且 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++];
|
||||
}
|
||||
@@ -122,13 +122,13 @@ comments: true
|
||||
int i = leftStart, j = rightStart;
|
||||
// 通过覆盖原数组 nums 来合并左子数组和右子数组
|
||||
for (int k = left; k <= right; k++) {
|
||||
// 若 “左子数组已全部合并完”，则选取右子数组元素，并且 j++
|
||||
// 若“左子数组已全部合并完”，则选取右子数组元素，并且 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++];
|
||||
}
|
||||
@@ -166,15 +166,15 @@ comments: true
|
||||
i, j = left_start, right_start
|
||||
# 通过覆盖原数组 nums 来合并左子数组和右子数组
|
||||
for k in range(left, right + 1):
|
||||
# 若 “左子数组已全部合并完”，则选取右子数组元素，并且 j++
|
||||
# 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
|
||||
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
|
||||
@@ -214,15 +214,15 @@ comments: true
|
||||
i, j := left_start, right_start
|
||||
// 通过覆盖原数组 nums 来合并左子数组和右子数组
|
||||
for k := left; k <= right; k++ {
|
||||
// 若 “左子数组已全部合并完”，则选取右子数组元素，并且 j++
|
||||
// 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
|
||||
if i > left_end {
|
||||
nums[k] = tmp[j]
|
||||
j++
|
||||
// 否则，若 “右子数组已全部合并完” 或 “左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
|
||||
// 否则，若“右子数组已全部合并完”或“左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
|
||||
} else if j > right_end || tmp[i] <= tmp[j] {
|
||||
nums[k] = tmp[i]
|
||||
i++
|
||||
// 否则，若 “左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
|
||||
// 否则，若“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
|
||||
} else {
|
||||
nums[k] = tmp[j]
|
||||
j++
|
||||
@@ -264,13 +264,13 @@ comments: true
|
||||
let i = leftStart, j = rightStart;
|
||||
// 通过覆盖原数组 nums 来合并左子数组和右子数组
|
||||
for (let k = left; k <= right; k++) {
|
||||
// 若 “左子数组已全部合并完”，则选取右子数组元素，并且 j++
|
||||
// 若“左子数组已全部合并完”，则选取右子数组元素，并且 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++];
|
||||
}
|
||||
@@ -309,13 +309,13 @@ comments: true
|
||||
let i = leftStart, j = rightStart;
|
||||
// 通过覆盖原数组 nums 来合并左子数组和右子数组
|
||||
for (let k = left; k <= right; k++) {
|
||||
// 若 “左子数组已全部合并完”，则选取右子数组元素，并且 j++
|
||||
// 若“左子数组已全部合并完”，则选取右子数组元素，并且 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++];
|
||||
}
|
||||
@@ -344,7 +344,48 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```csharp title="merge_sort.cs"
|
||||
/**
|
||||
* 合并左子数组和右子数组
|
||||
* 左子数组区间 [left, mid]
|
||||
* 右子数组区间 [mid + 1, right]
|
||||
*/
|
||||
void merge(int[] nums, int left, int mid, int right)
|
||||
{
|
||||
// 初始化辅助数组
|
||||
int[] tmp = nums[left..(right + 1)];
|
||||
// 左子数组的起始索引和结束索引
|
||||
int leftStart = left - left, leftEnd = mid - left;
|
||||
// 右子数组的起始索引和结束索引
|
||||
int rightStart = mid + 1 - left, rightEnd = right - left;
|
||||
// i, j 分别指向左子数组、右子数组的首元素
|
||||
int i = leftStart, j = rightStart;
|
||||
// 通过覆盖原数组 nums 来合并左子数组和右子数组
|
||||
for (int k = left; k <= right; k++)
|
||||
{
|
||||
// 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
|
||||
if (i > leftEnd)
|
||||
nums[k] = tmp[j++];
|
||||
// 否则，若“右子数组已全部合并完”或“左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
|
||||
else if (j > rightEnd || tmp[i] <= tmp[j])
|
||||
nums[k] = tmp[i++];
|
||||
// 否则，若“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
|
||||
else
|
||||
nums[k] = tmp[j++];
|
||||
}
|
||||
}
|
||||
|
||||
/* 归并排序 */
|
||||
void mergeSort(int[] nums, int left, int right)
|
||||
{
|
||||
// 终止条件
|
||||
if (left >= right) return; // 当子数组长度为 1 时终止递归
|
||||
// 划分阶段
|
||||
int mid = (left + right) / 2; // 计算中点
|
||||
mergeSort(nums, left, mid); // 递归左子数组
|
||||
mergeSort(nums, mid + 1, right); // 递归右子数组
|
||||
// 合并阶段
|
||||
merge(nums, left, mid, right);
|
||||
}
|
||||
```
|
||||
|
||||
下面重点解释一下合并方法 `merge()` 的流程：
|
||||
@@ -370,7 +411,7 @@ comments: true
|
||||
|
||||
归并排序有一个很特别的优势，用于排序链表时有很好的性能表现，**空间复杂度可被优化至 $O(1)$** ，这是因为：
|
||||
|
||||
- 由于链表可仅通过改变指针来实现结点增删，因此 “将两个短有序链表合并为一个长有序链表” 无需使用额外空间，即回溯合并阶段不用像排序数组一样建立辅助数组 `tmp` ；
|
||||
- 由于链表可仅通过改变指针来实现结点增删，因此“将两个短有序链表合并为一个长有序链表”无需使用额外空间，即回溯合并阶段不用像排序数组一样建立辅助数组 `tmp` ；
|
||||
- 通过使用「迭代」代替「递归划分」，可省去递归使用的栈帧空间；
|
||||
|
||||
> 详情参考：[148. 排序链表](https://leetcode-cn.com/problems/sort-list/solution/sort-list-gui-bing-pai-xu-lian-biao-by-jyd/)
|
||||
|
||||
@@ -4,7 +4,7 @@ comments: true
|
||||
|
||||
# 快速排序
|
||||
|
||||
「快速排序 Quick Sort」是一种基于 “分治思想” 的排序算法，速度很快、应用很广。
|
||||
「快速排序 Quick Sort」是一种基于“分治思想”的排序算法，速度很快、应用很广。
|
||||
|
||||
快速排序的核心操作为「哨兵划分」，其目标为：选取数组某个元素为 **基准数** ，将所有小于基准数的元素移动至其左边，大于基准数的元素移动至其右边。「哨兵划分」的实现流程为：
|
||||
|
||||
@@ -196,6 +196,30 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```csharp title="quick_sort.cs"
|
||||
/* 元素交换 */
|
||||
void swap(int[] nums, int i, int j)
|
||||
{
|
||||
int tmp = nums[i];
|
||||
nums[i] = nums[j];
|
||||
nums[j] = tmp;
|
||||
}
|
||||
|
||||
/* 哨兵划分 */
|
||||
int partition(int[] nums, int left, int right)
|
||||
{
|
||||
// 以 nums[left] 作为基准数
|
||||
int i = left, j = right;
|
||||
while (i < j)
|
||||
{
|
||||
while (i < j && nums[j] >= nums[left])
|
||||
j--; // 从右向左找首个小于基准数的元素
|
||||
while (i < j && nums[i] <= nums[left])
|
||||
i++; // 从左向右找首个大于基准数的元素
|
||||
swap(nums, i, j); // 交换这两个元素
|
||||
}
|
||||
swap(nums, i, left); // 将基准数交换至两子数组的分界线
|
||||
return i; // 返回基准数的索引
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
@@ -235,7 +259,7 @@ comments: true
|
||||
|
||||
```cpp title="quick_sort.cpp"
|
||||
/* 快速排序 */
|
||||
static void quickSort(vector<int>& nums, int left, int right) {
|
||||
void quickSort(vector<int>& nums, int left, int right) {
|
||||
// 子数组长度为 1 时终止递归
|
||||
if (left >= right)
|
||||
return;
|
||||
@@ -320,6 +344,18 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```csharp title="quick_sort.cs"
|
||||
/* 快速排序 */
|
||||
void quickSort(int[] nums, int left, int right)
|
||||
{
|
||||
// 子数组长度为 1 时终止递归
|
||||
if (left >= right)
|
||||
return;
|
||||
// 哨兵划分
|
||||
int pivot = partition(nums, left, right);
|
||||
// 递归左子数组、右子数组
|
||||
quickSort(nums, left, pivot - 1);
|
||||
quickSort(nums, pivot + 1, right);
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
@@ -339,7 +375,7 @@ comments: true
|
||||
|
||||
## 快排为什么快？
|
||||
|
||||
从命名能够看出，快速排序在效率方面一定 “有两把刷子” 。快速排序的平均时间复杂度虽然与「归并排序」和「堆排序」一致，但实际 **效率更高** ，这是因为：
|
||||
从命名能够看出，快速排序在效率方面一定“有两把刷子”。快速排序的平均时间复杂度虽然与「归并排序」和「堆排序」一致，但实际 **效率更高** ，这是因为：
|
||||
|
||||
- **出现最差情况的概率很低：** 虽然快速排序的最差时间复杂度为 $O(n^2)$ ，不如归并排序，但绝大部分情况下，快速排序可以达到 $O(n \log n)$ 的复杂度。
|
||||
- **缓存使用效率高：** 哨兵划分操作时，将整个子数组加载入缓存中，访问元素效率很高。而诸如「堆排序」需要跳跃式访问元素，因此不具有此特性。
|
||||
@@ -351,7 +387,7 @@ comments: true
|
||||
|
||||
为了尽量避免这种情况发生，我们可以优化一下基准数的选取策略。首先，在哨兵划分中，我们可以 **随机选取一个元素作为基准数** 。但如果运气很差，每次都选择到比较差的基准数，那么效率依然不好。
|
||||
|
||||
进一步地，我们可以在数组中选取 3 个候选元素（一般为数组的首、尾、中点元素），**并将三个候选元素的中位数作为基准数**，这样基准数 “既不大也不小” 的概率就大大提升了。当然，如果数组很长的话，我们也可以选取更多候选元素，来进一步提升算法的稳健性。采取该方法后，时间复杂度劣化至 $O(n^2)$ 的概率极低。
|
||||
进一步地，我们可以在数组中选取 3 个候选元素（一般为数组的首、尾、中点元素），**并将三个候选元素的中位数作为基准数**，这样基准数“既不大也不小”的概率就大大提升了。当然，如果数组很长的话，我们也可以选取更多候选元素，来进一步提升算法的稳健性。采取该方法后，时间复杂度劣化至 $O(n^2)$ 的概率极低。
|
||||
|
||||
=== "Java"
|
||||
|
||||
@@ -513,7 +549,29 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```csharp title="quick_sort.cs"
|
||||
/* 选取三个元素的中位数 */
|
||||
int medianThree(int[] nums, int left, int mid, int right)
|
||||
{
|
||||
// 使用了异或操作来简化代码
|
||||
// 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1
|
||||
if ((nums[left] > nums[mid]) ^ (nums[left] > nums[right]))
|
||||
return left;
|
||||
else if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right]))
|
||||
return mid;
|
||||
else
|
||||
return right;
|
||||
}
|
||||
|
||||
/* 哨兵划分（三数取中值） */
|
||||
int partition(int[] nums, int left, int right)
|
||||
{
|
||||
// 选取三个候选元素的中位数
|
||||
int med = medianThree(nums, left, (left + right) / 2, right);
|
||||
// 将中位数交换至数组最左端
|
||||
swap(nums, left, med);
|
||||
// 以 nums[left] 作为基准数
|
||||
// 下同省略...
|
||||
}
|
||||
```
|
||||
|
||||
## 尾递归优化
|
||||
@@ -547,7 +605,7 @@ comments: true
|
||||
|
||||
```cpp title="quick_sort.cpp"
|
||||
/* 快速排序（尾递归优化） */
|
||||
static void quickSort(vector<int>& nums, int left, int right) {
|
||||
void quickSort(vector<int>& nums, int left, int right) {
|
||||
// 子数组长度为 1 时终止
|
||||
while (left < right) {
|
||||
// 哨兵划分操作
|
||||
@@ -654,5 +712,25 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```csharp title="quick_sort.cs"
|
||||
|
||||
/* 快速排序（尾递归优化） */
|
||||
void quickSort(int[] nums, int left, int right)
|
||||
{
|
||||
// 子数组长度为 1 时终止
|
||||
while (left < right)
|
||||
{
|
||||
// 哨兵划分操作
|
||||
int pivot = partition(nums, left, right);
|
||||
// 对两个子数组中较短的那个执行快排
|
||||
if (pivot - left < right - pivot)
|
||||
{
|
||||
quickSort(nums, left, pivot - 1); // 递归排序左子数组
|
||||
left = pivot + 1; // 剩余待排序区间为 [pivot + 1, right]
|
||||
}
|
||||
else
|
||||
{
|
||||
quickSort(nums, pivot + 1, right); // 递归排序右子数组
|
||||
right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1]
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
@@ -144,8 +144,7 @@ comments: true
|
||||
|
||||
```js title="queue.js"
|
||||
/* 初始化队列 */
|
||||
// JavaScript 没有内置的队列，可以把 Array 当作队列来使用
|
||||
// 注意：由于是数组，所以 shift() 的时间复杂度是 O(n)
|
||||
// JavaScript 没有内置的队列，可以把 Array 当作队列来使用
|
||||
const queue = [];
|
||||
|
||||
/* 元素入队 */
|
||||
@@ -159,7 +158,7 @@ comments: true
|
||||
const peek = queue[0];
|
||||
|
||||
/* 元素出队 */
|
||||
// O(n)
|
||||
// 底层是数组，因此 shift() 方法的时间复杂度为 O(n)
|
||||
const poll = queue.shift();
|
||||
|
||||
/* 获取队列的长度 */
|
||||
@@ -174,7 +173,6 @@ comments: true
|
||||
```typescript title="queue.ts"
|
||||
/* 初始化队列 */
|
||||
// TypeScript 没有内置的队列，可以把 Array 当作队列来使用
|
||||
// 注意：由于是数组，所以 shift() 的时间复杂度是 O(n)
|
||||
const queue: number[] = [];
|
||||
|
||||
/* 元素入队 */
|
||||
@@ -188,7 +186,7 @@ comments: true
|
||||
const peek = queue[0];
|
||||
|
||||
/* 元素出队 */
|
||||
// O(n)
|
||||
// 底层是数组，因此 shift() 方法的时间复杂度为 O(n)
|
||||
const poll = queue.shift();
|
||||
|
||||
/* 获取队列的长度 */
|
||||
@@ -207,7 +205,27 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```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;
|
||||
```
|
||||
|
||||
## 队列实现
|
||||
@@ -264,7 +282,7 @@ comments: true
|
||||
/* 访问队首元素 */
|
||||
public int peek() {
|
||||
if (size() == 0)
|
||||
throw new IndexOutOfBoundsException();
|
||||
throw new EmptyStackException();
|
||||
return front.val;
|
||||
}
|
||||
}
|
||||
@@ -382,19 +400,16 @@ comments: true
|
||||
// 使用内置包 list 来实现队列
|
||||
data *list.List
|
||||
}
|
||||
|
||||
// NewLinkedListQueue 初始化链表
|
||||
func NewLinkedListQueue() *LinkedListQueue {
|
||||
return &LinkedListQueue{
|
||||
data: list.New(),
|
||||
}
|
||||
}
|
||||
|
||||
// Offer 入队
|
||||
func (s *LinkedListQueue) Offer(value any) {
|
||||
s.data.PushBack(value)
|
||||
}
|
||||
|
||||
// Poll 出队
|
||||
func (s *LinkedListQueue) Poll() any {
|
||||
if s.IsEmpty() {
|
||||
@@ -404,7 +419,6 @@ comments: true
|
||||
s.data.Remove(e)
|
||||
return e.Value
|
||||
}
|
||||
|
||||
// Peek 访问队首元素
|
||||
func (s *LinkedListQueue) Peek() any {
|
||||
if s.IsEmpty() {
|
||||
@@ -413,12 +427,10 @@ comments: true
|
||||
e := s.data.Front()
|
||||
return e.Value
|
||||
}
|
||||
|
||||
// Size 获取队列的长度
|
||||
func (s *LinkedListQueue) Size() int {
|
||||
return s.data.Len()
|
||||
}
|
||||
|
||||
// IsEmpty 判断队列是否为空
|
||||
func (s *LinkedListQueue) IsEmpty() bool {
|
||||
return s.data.Len() == 0
|
||||
@@ -428,13 +440,107 @@ comments: true
|
||||
=== "JavaScript"
|
||||
|
||||
```js title="linkedlist_queue.js"
|
||||
|
||||
/* 基于链表实现的队列 */
|
||||
class LinkedListQueue {
|
||||
#front; // 头结点 #front
|
||||
#rear; // 尾结点 #rear
|
||||
#queSize = 0;
|
||||
constructor() {
|
||||
this.#front = null;
|
||||
this.#rear = null;
|
||||
}
|
||||
/* 获取队列的长度 */
|
||||
get size() {
|
||||
return this.#queSize;
|
||||
}
|
||||
/* 判断队列是否为空 */
|
||||
isEmpty() {
|
||||
return this.size === 0;
|
||||
}
|
||||
/* 入队 */
|
||||
offer(num) {
|
||||
// 尾结点后添加 num
|
||||
const node = new ListNode(num);
|
||||
// 如果队列为空，则令头、尾结点都指向该结点
|
||||
if (!this.#front) {
|
||||
this.#front = node;
|
||||
this.#rear = node;
|
||||
// 如果队列不为空，则将该结点添加到尾结点后
|
||||
} else {
|
||||
this.#rear.next = node;
|
||||
this.#rear = node;
|
||||
}
|
||||
this.#queSize++;
|
||||
}
|
||||
/* 出队 */
|
||||
poll() {
|
||||
const num = this.peek();
|
||||
// 删除头结点
|
||||
this.#front = this.#front.next;
|
||||
this.#queSize--;
|
||||
return num;
|
||||
}
|
||||
/* 访问队首元素 */
|
||||
peek() {
|
||||
if (this.size === 0)
|
||||
throw new Error("队列为空");
|
||||
return this.#front.val;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
=== "TypeScript"
|
||||
|
||||
```typescript title="linkedlist_queue.ts"
|
||||
|
||||
/* 基于链表实现的队列 */
|
||||
class LinkedListQueue {
|
||||
private front: ListNode | null; // 头结点 front
|
||||
private rear: ListNode | null; // 尾结点 rear
|
||||
private queSize: number = 0;
|
||||
constructor() {
|
||||
this.front = null;
|
||||
this.rear = null;
|
||||
}
|
||||
/* 获取队列的长度 */
|
||||
get size(): number {
|
||||
return this.queSize;
|
||||
}
|
||||
/* 判断队列是否为空 */
|
||||
isEmpty(): boolean {
|
||||
return this.size === 0;
|
||||
}
|
||||
/* 入队 */
|
||||
offer(num: number): void {
|
||||
// 尾结点后添加 num
|
||||
const node = new ListNode(num);
|
||||
// 如果队列为空，则令头、尾结点都指向该结点
|
||||
if (!this.front) {
|
||||
this.front = node;
|
||||
this.rear = node;
|
||||
// 如果队列不为空，则将该结点添加到尾结点后
|
||||
} else {
|
||||
this.rear!.next = node;
|
||||
this.rear = node;
|
||||
}
|
||||
this.queSize++;
|
||||
}
|
||||
/* 出队 */
|
||||
poll(): number {
|
||||
const num = this.peek();
|
||||
if (!this.front)
|
||||
throw new Error("队列为空")
|
||||
// 删除头结点
|
||||
this.front = this.front.next;
|
||||
this.queSize--;
|
||||
return num;
|
||||
}
|
||||
/* 访问队首元素 */
|
||||
peek(): number {
|
||||
if (this.size === 0)
|
||||
throw new Error("队列为空");
|
||||
return this.front!.val;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
=== "C"
|
||||
@@ -446,14 +552,69 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```csharp title="linkedlist_queue.cs"
|
||||
|
||||
/* 基于链表实现的队列 */
|
||||
class LinkedListQueue
|
||||
{
|
||||
private ListNode? front, rear; // 头结点 front ，尾结点 rear
|
||||
private int queSize = 0;
|
||||
public LinkedListQueue()
|
||||
{
|
||||
front = null;
|
||||
rear = null;
|
||||
}
|
||||
/* 获取队列的长度 */
|
||||
public int size()
|
||||
{
|
||||
return queSize;
|
||||
}
|
||||
/* 判断队列是否为空 */
|
||||
public bool isEmpty()
|
||||
{
|
||||
return size() == 0;
|
||||
}
|
||||
/* 入队 */
|
||||
public void offer(int num)
|
||||
{
|
||||
// 尾结点后添加 num
|
||||
ListNode node = new ListNode(num);
|
||||
// 如果队列为空，则令头、尾结点都指向该结点
|
||||
if (front == null)
|
||||
{
|
||||
front = node;
|
||||
rear = node;
|
||||
// 如果队列不为空，则将该结点添加到尾结点后
|
||||
}
|
||||
else if (rear != null)
|
||||
{
|
||||
rear.next = node;
|
||||
rear = node;
|
||||
}
|
||||
queSize++;
|
||||
}
|
||||
/* 出队 */
|
||||
public int poll()
|
||||
{
|
||||
int num = peek();
|
||||
// 删除头结点
|
||||
front = front?.next;
|
||||
queSize--;
|
||||
return num;
|
||||
}
|
||||
/* 访问队首元素 */
|
||||
public int peek()
|
||||
{
|
||||
if (size() == 0 || front == null)
|
||||
throw new Exception();
|
||||
return front.val;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### 基于数组的实现
|
||||
|
||||
数组的删除首元素的时间复杂度为 $O(n)$ ，因此不适合直接用来实现队列。然而，我们可以借助两个指针 `front` , `rear` 来分别记录队首和队尾的索引位置，在入队 / 出队时分别将 `front` / `rear` 向后移动一位即可，这样每次仅需操作一个元素，时间复杂度降至 $O(1)$ 。
|
||||
|
||||
还有一个问题，在入队与出队的过程中，两个指针都在向后移动，而到达尾部后则无法继续移动了。为了解决此问题，我们可以采取一个取巧方案，即将数组看作是 “环形” 的。具体做法是规定指针越过数组尾部后，再次回到头部接续遍历，这样相当于使数组 “首尾相连” 了。
|
||||
还有一个问题，在入队与出队的过程中，两个指针都在向后移动，而到达尾部后则无法继续移动了。为了解决此问题，我们可以采取一个取巧方案，即将数组看作是“环形”的。具体做法是规定指针越过数组尾部后，再次回到头部接续遍历，这样相当于使数组“首尾相连”了。
|
||||
|
||||
为了适应环形数组的设定，获取长度 `size()` 、入队 `offer()` 、出队 `poll()` 方法都需要做相应的取余操作处理，使得当尾指针绕回数组头部时，仍然可以正确处理操作。
|
||||
|
||||
@@ -506,17 +667,10 @@ comments: true
|
||||
}
|
||||
/* 访问队首元素 */
|
||||
public int peek() {
|
||||
// 删除头结点
|
||||
if (isEmpty())
|
||||
throw new EmptyStackException();
|
||||
return nums[front];
|
||||
}
|
||||
/* 访问指定索引元素 */
|
||||
int get(int index) {
|
||||
if (index >= size())
|
||||
throw new IndexOutOfBoundsException();
|
||||
return nums[(front + index) % capacity()];
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
@@ -570,17 +724,10 @@ comments: true
|
||||
}
|
||||
/* 访问队首元素 */
|
||||
int peek() {
|
||||
// 删除头结点
|
||||
if (empty())
|
||||
throw out_of_range("队列为空");
|
||||
return nums[front];
|
||||
}
|
||||
/* 访问指定位置元素 */
|
||||
int get(int index) {
|
||||
if (index >= size())
|
||||
throw out_of_range("索引越界");
|
||||
return nums[(front + index) % capacity()]
|
||||
}
|
||||
};
|
||||
```
|
||||
|
||||
@@ -619,7 +766,6 @@ comments: true
|
||||
|
||||
""" 出队 """
|
||||
def poll(self):
|
||||
# 删除头结点
|
||||
num = self.peek()
|
||||
# 队头指针向后移动一位，若越过尾部则返回到数组头部
|
||||
self.__front = (self.__front + 1) % self.capacity()
|
||||
@@ -627,19 +773,11 @@ comments: true
|
||||
|
||||
""" 访问队首元素 """
|
||||
def peek(self):
|
||||
# 删除头结点
|
||||
if self.is_empty():
|
||||
print("队列为空")
|
||||
return False
|
||||
return self.__nums[self.__front]
|
||||
|
||||
""" 访问指定位置元素 """
|
||||
def get(self, index):
|
||||
if index >= self.size():
|
||||
print("索引越界")
|
||||
return False
|
||||
return self.__nums[(self.__front + index) % self.capacity()]
|
||||
|
||||
""" 返回列表用于打印 """
|
||||
def to_list(self):
|
||||
res = [0] * self.size()
|
||||
@@ -660,7 +798,6 @@ comments: true
|
||||
front int // 头指针，指向队首
|
||||
rear int // 尾指针，指向队尾 + 1
|
||||
}
|
||||
|
||||
// NewArrayQueue 基于环形数组实现的队列
|
||||
func NewArrayQueue(capacity int) *ArrayQueue {
|
||||
return &ArrayQueue{
|
||||
@@ -670,18 +807,15 @@ comments: true
|
||||
rear: 0,
|
||||
}
|
||||
}
|
||||
|
||||
// Size 获取队列的长度
|
||||
func (q *ArrayQueue) Size() int {
|
||||
size := (q.capacity + q.rear - q.front) % q.capacity
|
||||
return size
|
||||
}
|
||||
|
||||
// IsEmpty 判断队列是否为空
|
||||
func (q *ArrayQueue) IsEmpty() bool {
|
||||
return q.rear-q.front == 0
|
||||
}
|
||||
|
||||
// Offer 入队
|
||||
func (q *ArrayQueue) Offer(v int) {
|
||||
// 当 rear == capacity 表示队列已满
|
||||
@@ -693,7 +827,6 @@ comments: true
|
||||
// 尾指针向后移动一位，越过尾部后返回到数组头部
|
||||
q.rear = (q.rear + 1) % q.capacity
|
||||
}
|
||||
|
||||
// Poll 出队
|
||||
func (q *ArrayQueue) Poll() any {
|
||||
if q.IsEmpty() {
|
||||
@@ -704,7 +837,6 @@ comments: true
|
||||
q.front = (q.front + 1) % q.capacity
|
||||
return v
|
||||
}
|
||||
|
||||
// Peek 访问队首元素
|
||||
func (q *ArrayQueue) Peek() any {
|
||||
if q.IsEmpty() {
|
||||
@@ -718,13 +850,100 @@ comments: true
|
||||
=== "JavaScript"
|
||||
|
||||
```js title="array_queue.js"
|
||||
|
||||
/* 基于环形数组实现的队列 */
|
||||
class ArrayQueue {
|
||||
#queue; // 用于存储队列元素的数组
|
||||
#front = 0; // 头指针，指向队首
|
||||
#rear = 0; // 尾指针，指向队尾 + 1
|
||||
constructor(capacity) {
|
||||
this.#queue = new Array(capacity);
|
||||
}
|
||||
/* 获取队列的容量 */
|
||||
get capacity() {
|
||||
return this.#queue.length;
|
||||
}
|
||||
/* 获取队列的长度 */
|
||||
get size() {
|
||||
// 由于将数组看作为环形，可能 rear < front ，因此需要取余数
|
||||
return (this.capacity + this.#rear - this.#front) % this.capacity;
|
||||
}
|
||||
/* 判断队列是否为空 */
|
||||
empty() {
|
||||
return this.#rear - this.#front == 0;
|
||||
}
|
||||
/* 入队 */
|
||||
offer(num) {
|
||||
if (this.size == this.capacity)
|
||||
throw new Error("队列已满");
|
||||
// 尾结点后添加 num
|
||||
this.#queue[this.#rear] = num;
|
||||
// 尾指针向后移动一位，越过尾部后返回到数组头部
|
||||
this.#rear = (this.#rear + 1) % this.capacity;
|
||||
}
|
||||
/* 出队 */
|
||||
poll() {
|
||||
const num = this.peek();
|
||||
// 队头指针向后移动一位，若越过尾部则返回到数组头部
|
||||
this.#front = (this.#front + 1) % this.capacity;
|
||||
return num;
|
||||
}
|
||||
/* 访问队首元素 */
|
||||
peek() {
|
||||
if (this.empty())
|
||||
throw new Error("队列为空");
|
||||
return this.#queue[this.#front];
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
=== "TypeScript"
|
||||
|
||||
```typescript title="array_queue.ts"
|
||||
|
||||
/* 基于环形数组实现的队列 */
|
||||
class ArrayQueue {
|
||||
private queue: number[]; // 用于存储队列元素的数组
|
||||
private front: number = 0; // 头指针，指向队首
|
||||
private rear: number = 0; // 尾指针，指向队尾 + 1
|
||||
private CAPACITY: number = 1e5;
|
||||
constructor(capacity?: number) {
|
||||
this.queue = new Array<number>(capacity ?? this.CAPACITY);
|
||||
}
|
||||
/* 获取队列的容量 */
|
||||
get capacity(): number {
|
||||
return this.queue.length;
|
||||
}
|
||||
/* 获取队列的长度 */
|
||||
get size(): number {
|
||||
// 由于将数组看作为环形，可能 rear < front ，因此需要取余数
|
||||
return (this.capacity + this.rear - this.front) % this.capacity;
|
||||
}
|
||||
/* 判断队列是否为空 */
|
||||
empty(): boolean {
|
||||
return this.rear - this.front == 0;
|
||||
}
|
||||
/* 入队 */
|
||||
offer(num: number): void {
|
||||
if (this.size == this.capacity)
|
||||
throw new Error("队列已满");
|
||||
// 尾结点后添加 num
|
||||
this.queue[this.rear] = num;
|
||||
// 尾指针向后移动一位，越过尾部后返回到数组头部
|
||||
this.rear = (this.rear + 1) % this.capacity;
|
||||
}
|
||||
/* 出队 */
|
||||
poll(): number {
|
||||
const num = this.peek();
|
||||
// 队头指针向后移动一位，若越过尾部则返回到数组头部
|
||||
this.front = (this.front + 1) % this.capacity;
|
||||
return num;
|
||||
}
|
||||
/* 访问队首元素 */
|
||||
peek(): number {
|
||||
if (this.empty())
|
||||
throw new Error("队列为空");
|
||||
return this.queue[this.front];
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
=== "C"
|
||||
@@ -736,7 +955,63 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```csharp title="array_queue.cs"
|
||||
|
||||
/* 基于环形数组实现的队列 */
|
||||
class ArrayQueue
|
||||
{
|
||||
private int[] nums; // 用于存储队列元素的数组
|
||||
private int front = 0; // 头指针，指向队首
|
||||
private int rear = 0; // 尾指针，指向队尾 + 1
|
||||
public ArrayQueue(int capacity)
|
||||
{
|
||||
// 初始化数组
|
||||
nums = new int[capacity];
|
||||
}
|
||||
/* 获取队列的容量 */
|
||||
public int capacity()
|
||||
{
|
||||
return nums.Length;
|
||||
}
|
||||
/* 获取队列的长度 */
|
||||
public int size()
|
||||
{
|
||||
int capacity = this.capacity();
|
||||
// 由于将数组看作为环形，可能 rear < front ，因此需要取余数
|
||||
return (capacity + rear - front) % capacity;
|
||||
}
|
||||
/* 判断队列是否为空 */
|
||||
public bool isEmpty()
|
||||
{
|
||||
return rear - front == 0;
|
||||
}
|
||||
/* 入队 */
|
||||
public void offer(int num)
|
||||
{
|
||||
if (size() == capacity())
|
||||
{
|
||||
Console.WriteLine("队列已满");
|
||||
return;
|
||||
}
|
||||
// 尾结点后添加 num
|
||||
nums[rear] = num;
|
||||
// 尾指针向后移动一位，越过尾部后返回到数组头部
|
||||
rear = (rear + 1) % capacity();
|
||||
}
|
||||
/* 出队 */
|
||||
public int poll()
|
||||
{
|
||||
int num = peek();
|
||||
// 队头指针向后移动一位，若越过尾部则返回到数组头部
|
||||
front = (front + 1) % capacity();
|
||||
return num;
|
||||
}
|
||||
/* 访问队首元素 */
|
||||
public int peek()
|
||||
{
|
||||
if (isEmpty())
|
||||
throw new Exception();
|
||||
return nums[front];
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## 队列典型应用
|
||||
|
||||
@@ -203,14 +203,34 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```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;
|
||||
```
|
||||
|
||||
## 栈的实现
|
||||
|
||||
为了更加清晰地了解栈的运行机制，接下来我们来自己动手实现一个栈类。
|
||||
|
||||
栈规定元素是先入后出的，因此我们只能在栈顶添加或删除元素。然而，数组或链表都可以在任意位置添加删除元素，因此 **栈可被看作是一种受约束的数组或链表**。换言之，我们可以 “屏蔽” 数组或链表的部分无关操作，使之对外的表现逻辑符合栈的规定即可。
|
||||
栈规定元素是先入后出的，因此我们只能在栈顶添加或删除元素。然而，数组或链表都可以在任意位置添加删除元素，因此 **栈可被看作是一种受约束的数组或链表**。换言之，我们可以“屏蔽”数组或链表的部分无关操作，使之对外的表现逻辑符合栈的规定即可。
|
||||
|
||||
### 基于链表的实现
|
||||
|
||||
@@ -225,7 +245,6 @@ comments: true
|
||||
class LinkedListStack {
|
||||
private ListNode stackPeek; // 将头结点作为栈顶
|
||||
private int stkSize = 0; // 栈的长度
|
||||
|
||||
public LinkedListStack() {
|
||||
stackPeek = null;
|
||||
}
|
||||
@@ -254,7 +273,7 @@ comments: true
|
||||
/* 访问栈顶元素 */
|
||||
public int peek() {
|
||||
if (size() == 0)
|
||||
throw new IndexOutOfBoundsException();
|
||||
throw new EmptyStackException();
|
||||
return stackPeek.val;
|
||||
}
|
||||
}
|
||||
@@ -351,19 +370,16 @@ comments: true
|
||||
// 使用内置包 list 来实现栈
|
||||
data *list.List
|
||||
}
|
||||
|
||||
// NewLinkedListStack 初始化链表
|
||||
func NewLinkedListStack() *LinkedListStack {
|
||||
return &LinkedListStack{
|
||||
data: list.New(),
|
||||
}
|
||||
}
|
||||
|
||||
// Push 入栈
|
||||
func (s *LinkedListStack) Push(value int) {
|
||||
s.data.PushBack(value)
|
||||
}
|
||||
|
||||
// Pop 出栈
|
||||
func (s *LinkedListStack) Pop() any {
|
||||
if s.IsEmpty() {
|
||||
@@ -373,7 +389,6 @@ comments: true
|
||||
s.data.Remove(e)
|
||||
return e.Value
|
||||
}
|
||||
|
||||
// Peek 访问栈顶元素
|
||||
func (s *LinkedListStack) Peek() any {
|
||||
if s.IsEmpty() {
|
||||
@@ -382,12 +397,10 @@ comments: true
|
||||
e := s.data.Back()
|
||||
return e.Value
|
||||
}
|
||||
|
||||
// Size 获取栈的长度
|
||||
func (s *LinkedListStack) Size() int {
|
||||
return s.data.Len()
|
||||
}
|
||||
|
||||
// IsEmpty 判断栈是否为空
|
||||
func (s *LinkedListStack) IsEmpty() bool {
|
||||
return s.data.Len() == 0
|
||||
@@ -397,13 +410,125 @@ comments: true
|
||||
=== "JavaScript"
|
||||
|
||||
```js title="linkedlist_stack.js"
|
||||
|
||||
/* 基于链表实现的栈 */
|
||||
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);
|
||||
node.next = this.#stackPeek;
|
||||
this.#stackPeek = node;
|
||||
this.#stkSize++;
|
||||
}
|
||||
|
||||
/* 出栈 */
|
||||
pop() {
|
||||
const num = this.peek();
|
||||
if (!this.#stackPeek) {
|
||||
throw new Error("栈为空！");
|
||||
}
|
||||
this.#stackPeek = this.#stackPeek.next;
|
||||
this.#stkSize--;
|
||||
return num;
|
||||
}
|
||||
|
||||
/* 访问栈顶元素 */
|
||||
peek() {
|
||||
if (!this.#stackPeek) {
|
||||
throw new Error("栈为空！");
|
||||
}
|
||||
return this.#stackPeek.val;
|
||||
}
|
||||
|
||||
/* 将链表转化为 Array 并返回 */
|
||||
toArray() {
|
||||
let node = this.#stackPeek;
|
||||
const res = new Array(this.size);
|
||||
for (let i = res.length - 1; i >= 0; i--) {
|
||||
res[i] = node.val;
|
||||
node = node.next;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
=== "TypeScript"
|
||||
|
||||
```typescript title="linkedlist_stack.ts"
|
||||
|
||||
/* 基于链表实现的栈 */
|
||||
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);
|
||||
node.next = this.stackPeek;
|
||||
this.stackPeek = node;
|
||||
this.stkSize++;
|
||||
}
|
||||
|
||||
/* 出栈 */
|
||||
pop(): number {
|
||||
const num = this.peek();
|
||||
if (!this.stackPeek) {
|
||||
throw new Error("栈为空！");
|
||||
}
|
||||
this.stackPeek = this.stackPeek.next;
|
||||
this.stkSize--;
|
||||
return num;
|
||||
}
|
||||
|
||||
/* 访问栈顶元素 */
|
||||
peek(): number {
|
||||
if (!this.stackPeek) {
|
||||
throw new Error("栈为空！");
|
||||
}
|
||||
return this.stackPeek.val;
|
||||
}
|
||||
|
||||
/* 将链表转化为 Array 并返回 */
|
||||
toArray(): number[] {
|
||||
let node = this.stackPeek;
|
||||
const res = new Array<number>(this.size);
|
||||
for (let i = res.length - 1; i >= 0; i--) {
|
||||
res[i] = node!.val;
|
||||
node = node!.next;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
=== "C"
|
||||
@@ -415,7 +540,49 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```csharp title="linkedlist_stack.cs"
|
||||
|
||||
/* 基于链表实现的栈 */
|
||||
class LinkedListStack
|
||||
{
|
||||
private ListNode stackPeek; // 将头结点作为栈顶
|
||||
private int stkSize = 0; // 栈的长度
|
||||
public LinkedListStack()
|
||||
{
|
||||
stackPeek = null;
|
||||
}
|
||||
/* 获取栈的长度 */
|
||||
public int size()
|
||||
{
|
||||
return stkSize;
|
||||
}
|
||||
/* 判断栈是否为空 */
|
||||
public bool isEmpty()
|
||||
{
|
||||
return size() == 0;
|
||||
}
|
||||
/* 入栈 */
|
||||
public void push(int num)
|
||||
{
|
||||
ListNode node = new ListNode(num);
|
||||
node.next = stackPeek;
|
||||
stackPeek = node;
|
||||
stkSize++;
|
||||
}
|
||||
/* 出栈 */
|
||||
public int pop()
|
||||
{
|
||||
int num = peek();
|
||||
stackPeek = stackPeek?.next;
|
||||
stkSize--;
|
||||
return num;
|
||||
}
|
||||
/* 访问栈顶元素 */
|
||||
public int peek()
|
||||
{
|
||||
if (size() == 0)
|
||||
throw new Exception();
|
||||
return stackPeek.val;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### 基于数组的实现
|
||||
@@ -448,16 +615,16 @@ comments: true
|
||||
}
|
||||
/* 出栈 */
|
||||
public int pop() {
|
||||
if (isEmpty())
|
||||
throw new EmptyStackException();
|
||||
return stack.remove(size() - 1);
|
||||
}
|
||||
/* 访问栈顶元素 */
|
||||
public int peek() {
|
||||
if (isEmpty())
|
||||
throw new EmptyStackException();
|
||||
return stack.get(size() - 1);
|
||||
}
|
||||
/* 访问索引 index 处元素 */
|
||||
public int get(int index) {
|
||||
return stack.get(index);
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
@@ -484,18 +651,16 @@ comments: true
|
||||
}
|
||||
/* 出栈 */
|
||||
int pop() {
|
||||
int oldTop = stack.back();
|
||||
int oldTop = top();
|
||||
stack.pop_back();
|
||||
return oldTop;
|
||||
}
|
||||
/* 访问栈顶元素 */
|
||||
int top() {
|
||||
if(empty())
|
||||
throw out_of_range("栈为空");
|
||||
return stack.back();
|
||||
}
|
||||
/* 访问索引 index 处元素 */
|
||||
int get(int index) {
|
||||
return stack[index];
|
||||
}
|
||||
};
|
||||
```
|
||||
|
||||
@@ -521,15 +686,13 @@ comments: true
|
||||
|
||||
""" 出栈 """
|
||||
def pop(self):
|
||||
assert not self.is_empty(), "栈为空"
|
||||
return self.__stack.pop()
|
||||
|
||||
""" 访问栈顶元素 """
|
||||
def peek(self):
|
||||
assert not self.is_empty(), "栈为空"
|
||||
return self.__stack[-1]
|
||||
|
||||
""" 访问索引 index 处元素 """
|
||||
def get(self, index):
|
||||
return self.__stack[index]
|
||||
```
|
||||
|
||||
=== "Go"
|
||||
@@ -539,30 +702,25 @@ comments: true
|
||||
type ArrayStack struct {
|
||||
data []int // 数据
|
||||
}
|
||||
|
||||
func NewArrayStack() *ArrayStack {
|
||||
return &ArrayStack{
|
||||
// 设置栈的长度为 0，容量为 16
|
||||
data: make([]int, 0, 16),
|
||||
}
|
||||
}
|
||||
|
||||
// Size 栈的长度
|
||||
func (s *ArrayStack) Size() int {
|
||||
return len(s.data)
|
||||
}
|
||||
|
||||
// IsEmpty 栈是否为空
|
||||
func (s *ArrayStack) IsEmpty() bool {
|
||||
return s.Size() == 0
|
||||
}
|
||||
|
||||
// Push 入栈
|
||||
func (s *ArrayStack) Push(v int) {
|
||||
// 切片会自动扩容
|
||||
s.data = append(s.data, v)
|
||||
}
|
||||
|
||||
// Pop 出栈
|
||||
func (s *ArrayStack) Pop() any {
|
||||
// 弹出栈前，先判断是否为空
|
||||
@@ -573,7 +731,6 @@ comments: true
|
||||
s.data = s.data[:len(s.data)-1]
|
||||
return val
|
||||
}
|
||||
|
||||
// Peek 获取栈顶元素
|
||||
func (s *ArrayStack) Peek() any {
|
||||
if s.IsEmpty() {
|
||||
@@ -597,36 +754,26 @@ comments: true
|
||||
get size() {
|
||||
return this.stack.length;
|
||||
}
|
||||
|
||||
/* 判断栈是否为空 */
|
||||
empty() {
|
||||
return this.stack.length === 0;
|
||||
}
|
||||
|
||||
/* 入栈 */
|
||||
push(num) {
|
||||
this.stack.push(num);
|
||||
}
|
||||
|
||||
/* 出栈 */
|
||||
pop() {
|
||||
if (this.empty())
|
||||
throw new Error("栈为空");
|
||||
return this.stack.pop();
|
||||
}
|
||||
|
||||
/* 访问栈顶元素 */
|
||||
top() {
|
||||
if (this.empty())
|
||||
throw new Error("栈为空");
|
||||
return this.stack[this.stack.length - 1];
|
||||
}
|
||||
|
||||
/* 访问索引 index 处元素 */
|
||||
get(index) {
|
||||
return this.stack[index];
|
||||
}
|
||||
|
||||
/* 返回 Array */
|
||||
toArray() {
|
||||
return this.stack;
|
||||
}
|
||||
};
|
||||
```
|
||||
|
||||
@@ -643,36 +790,26 @@ comments: true
|
||||
get size(): number {
|
||||
return this.stack.length;
|
||||
}
|
||||
|
||||
/* 判断栈是否为空 */
|
||||
empty(): boolean {
|
||||
return this.stack.length === 0;
|
||||
}
|
||||
|
||||
/* 入栈 */
|
||||
push(num: number): void {
|
||||
this.stack.push(num);
|
||||
}
|
||||
|
||||
/* 出栈 */
|
||||
pop(): number | undefined {
|
||||
if (this.empty())
|
||||
throw new Error('栈为空');
|
||||
return this.stack.pop();
|
||||
}
|
||||
|
||||
/* 访问栈顶元素 */
|
||||
top(): number | undefined {
|
||||
if (this.empty())
|
||||
throw new Error('栈为空');
|
||||
return this.stack[this.stack.length - 1];
|
||||
}
|
||||
|
||||
/* 访问索引 index 处元素 */
|
||||
get(index: number): number | undefined {
|
||||
return this.stack[index];
|
||||
}
|
||||
|
||||
/* 返回 Array */
|
||||
toArray() {
|
||||
return this.stack;
|
||||
}
|
||||
};
|
||||
```
|
||||
|
||||
@@ -685,7 +822,47 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```csharp title="array_stack.cs"
|
||||
|
||||
/* 基于数组实现的栈 */
|
||||
class ArrayStack
|
||||
{
|
||||
private List<int> stack;
|
||||
public ArrayStack()
|
||||
{
|
||||
// 初始化列表（动态数组）
|
||||
stack = new();
|
||||
}
|
||||
/* 获取栈的长度 */
|
||||
public int size()
|
||||
{
|
||||
return stack.Count();
|
||||
}
|
||||
/* 判断栈是否为空 */
|
||||
public bool isEmpty()
|
||||
{
|
||||
return size() == 0;
|
||||
}
|
||||
/* 入栈 */
|
||||
public void push(int num)
|
||||
{
|
||||
stack.Add(num);
|
||||
}
|
||||
/* 出栈 */
|
||||
public int pop()
|
||||
{
|
||||
if (isEmpty())
|
||||
throw new Exception();
|
||||
var val = peek();
|
||||
stack.RemoveAt(size() - 1);
|
||||
return val;
|
||||
}
|
||||
/* 访问栈顶元素 */
|
||||
public int peek()
|
||||
{
|
||||
if (isEmpty())
|
||||
throw new Exception();
|
||||
return stack[size() - 1];
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
!!! tip
|
||||
|
||||
@@ -92,7 +92,14 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
|
||||
=== "C#"
|
||||
|
||||
```csharp title="avl_tree.cs"
|
||||
|
||||
/* AVL 树结点类 */
|
||||
class TreeNode {
|
||||
public int val; // 结点值
|
||||
public int height; // 结点高度
|
||||
public TreeNode? left; // 左子结点
|
||||
public TreeNode? right; // 右子结点
|
||||
public TreeNode(int x) { val = x; }
|
||||
}
|
||||
```
|
||||
|
||||
「结点高度」是最远叶结点到该结点的距离，即走过的「边」的数量。需要特别注意，**叶结点的高度为 0 ，空结点的高度为 -1** 。我们封装两个工具函数，分别用于获取与更新结点的高度。
|
||||
@@ -162,7 +169,19 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
|
||||
=== "C#"
|
||||
|
||||
```csharp title="avl_tree.cs"
|
||||
|
||||
/* 获取结点高度 */
|
||||
public int height(TreeNode? node)
|
||||
{
|
||||
// 空结点高度为 -1 ，叶结点高度为 0
|
||||
return node == null ? -1 : node.height;
|
||||
}
|
||||
|
||||
/* 更新结点高度 */
|
||||
private void updateHeight(TreeNode node)
|
||||
{
|
||||
// 结点高度等于最高子树高度 + 1
|
||||
node.height = Math.Max(height(node.left), height(node.right)) + 1;
|
||||
}
|
||||
```
|
||||
|
||||
### 结点平衡因子
|
||||
@@ -226,7 +245,14 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
|
||||
=== "C#"
|
||||
|
||||
```csharp title="avl_tree.cs"
|
||||
|
||||
/* 获取平衡因子 */
|
||||
public int balanceFactor(TreeNode? node)
|
||||
{
|
||||
// 空结点平衡因子为 0
|
||||
if (node == null) return 0;
|
||||
// 结点平衡因子 = 左子树高度 - 右子树高度
|
||||
return height(node.left) - height(node.right);
|
||||
}
|
||||
```
|
||||
|
||||
!!! note
|
||||
@@ -256,7 +282,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
|
||||
|
||||
|
||||
|
||||
“向右旋转” 是一种形象化的说法，实际需要通过修改结点指针实现，代码如下所示。
|
||||
“向右旋转”是一种形象化的说法，实际需要通过修改结点指针实现，代码如下所示。
|
||||
|
||||
=== "Java"
|
||||
|
||||
@@ -326,12 +352,26 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
|
||||
=== "C#"
|
||||
|
||||
```csharp title="avl_tree.cs"
|
||||
/* 右旋操作 */
|
||||
TreeNode? rightRotate(TreeNode? node)
|
||||
{
|
||||
TreeNode? child = node.left;
|
||||
TreeNode? grandChild = child?.right;
|
||||
// 以 child 为原点，将 node 向右旋转
|
||||
child.right = node;
|
||||
node.left = grandChild;
|
||||
// 更新结点高度
|
||||
updateHeight(node);
|
||||
updateHeight(child);
|
||||
// 返回旋转后子树的根节点
|
||||
return child;
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
### Case 2 - 左旋
|
||||
|
||||
类似地，如果将取上述失衡二叉树的 “镜像” ，那么则需要「左旋」操作。观察发现，**「左旋」和「右旋」操作是镜像对称的，两者对应解决的两种失衡情况也是对称的**。
|
||||
类似地，如果将取上述失衡二叉树的“镜像”，那么则需要「左旋」操作。观察发现，**「左旋」和「右旋」操作是镜像对称的，两者对应解决的两种失衡情况也是对称的**。
|
||||
|
||||
|
||||
|
||||
@@ -405,7 +445,20 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
|
||||
=== "C#"
|
||||
|
||||
```csharp title="avl_tree.cs"
|
||||
|
||||
/* 左旋操作 */
|
||||
TreeNode? leftRotate(TreeNode? node)
|
||||
{
|
||||
TreeNode? child = node.right;
|
||||
TreeNode? grandChild = child?.left;
|
||||
// 以 child 为原点，将 node 向左旋转
|
||||
child.left = node;
|
||||
node.right = grandChild;
|
||||
// 更新结点高度
|
||||
updateHeight(node);
|
||||
updateHeight(child);
|
||||
// 返回旋转后子树的根节点
|
||||
return child;
|
||||
}
|
||||
```
|
||||
|
||||
### Case 3 - 先左后右
|
||||
@@ -537,7 +590,44 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
|
||||
=== "C#"
|
||||
|
||||
```csharp title="avl_tree.cs"
|
||||
|
||||
/* 执行旋转操作，使该子树重新恢复平衡 */
|
||||
TreeNode? rotate(TreeNode? node)
|
||||
{
|
||||
// 获取结点 node 的平衡因子
|
||||
int balanceFactorInt = balanceFactor(node);
|
||||
// 左偏树
|
||||
if (balanceFactorInt > 1)
|
||||
{
|
||||
if (balanceFactor(node.left) >= 0)
|
||||
{
|
||||
// 右旋
|
||||
return rightRotate(node);
|
||||
}
|
||||
else
|
||||
{
|
||||
// 先左旋后右旋
|
||||
node.left = leftRotate(node?.left);
|
||||
return rightRotate(node);
|
||||
}
|
||||
}
|
||||
// 右偏树
|
||||
if (balanceFactorInt < -1)
|
||||
{
|
||||
if (balanceFactor(node.right) <= 0)
|
||||
{
|
||||
// 左旋
|
||||
return leftRotate(node);
|
||||
}
|
||||
else
|
||||
{
|
||||
// 先右旋后左旋
|
||||
node.right = rightRotate(node?.right);
|
||||
return leftRotate(node);
|
||||
}
|
||||
}
|
||||
// 平衡树，无需旋转，直接返回
|
||||
return node;
|
||||
}
|
||||
```
|
||||
|
||||
## AVL 树常用操作
|
||||
@@ -632,7 +722,30 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
|
||||
=== "C#"
|
||||
|
||||
```csharp title="avl_tree.cs"
|
||||
|
||||
/* 插入结点 */
|
||||
public TreeNode? insert(int val)
|
||||
{
|
||||
root = insertHelper(root, val);
|
||||
return root;
|
||||
}
|
||||
|
||||
/* 递归插入结点（辅助函数） */
|
||||
private TreeNode? insertHelper(TreeNode? node, int val)
|
||||
{
|
||||
if (node == null) return new TreeNode(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;
|
||||
}
|
||||
```
|
||||
|
||||
### 删除结点
|
||||
@@ -768,7 +881,60 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
|
||||
=== "C#"
|
||||
|
||||
```csharp title="avl_tree.cs"
|
||||
|
||||
/* 删除结点 */
|
||||
public TreeNode? remove(int val)
|
||||
{
|
||||
root = removeHelper(root, val);
|
||||
return root;
|
||||
}
|
||||
|
||||
/* 递归删除结点（辅助函数） */
|
||||
private TreeNode? removeHelper(TreeNode? node, int val)
|
||||
{
|
||||
if (node == null) return null;
|
||||
/* 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 == null || node.right == null)
|
||||
{
|
||||
TreeNode? child = node.left != null ? node.left : node.right;
|
||||
// 子结点数量 = 0 ，直接删除 node 并返回
|
||||
if (child == null)
|
||||
return null;
|
||||
// 子结点数量 = 1 ，直接删除 node
|
||||
else
|
||||
node = child;
|
||||
}
|
||||
else
|
||||
{
|
||||
// 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
|
||||
TreeNode? temp = minNode(node.right);
|
||||
node.right = removeHelper(node.right, temp.val);
|
||||
node.val = temp.val;
|
||||
}
|
||||
}
|
||||
updateHeight(node); // 更新结点高度
|
||||
/* 2. 执行旋转操作，使该子树重新恢复平衡 */
|
||||
node = rotate(node);
|
||||
// 返回子树的根节点
|
||||
return node;
|
||||
}
|
||||
|
||||
/* 获取最小结点 */
|
||||
private TreeNode? minNode(TreeNode? node)
|
||||
{
|
||||
if (node == null) return node;
|
||||
// 循环访问左子结点，直到叶结点时为最小结点，跳出
|
||||
while (node.left != null)
|
||||
{
|
||||
node = node.left;
|
||||
}
|
||||
return node;
|
||||
}
|
||||
```
|
||||
|
||||
### 查找结点
|
||||
|
||||
@@ -173,12 +173,28 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```csharp title="binary_search_tree.cs"
|
||||
|
||||
/* 查找结点 */
|
||||
TreeNode? search(int num)
|
||||
{
|
||||
TreeNode? cur = root;
|
||||
// 循环查找，越过叶结点后跳出
|
||||
while (cur != null)
|
||||
{
|
||||
// 目标结点在 root 的右子树中
|
||||
if (cur.val < num) cur = cur.right;
|
||||
// 目标结点在 root 的左子树中
|
||||
else if (cur.val > num) cur = cur.left;
|
||||
// 找到目标结点，跳出循环
|
||||
else break;
|
||||
}
|
||||
// 返回目标结点
|
||||
return cur;
|
||||
}
|
||||
```
|
||||
|
||||
### 插入结点
|
||||
|
||||
给定一个待插入元素 `num` ，为了保持二叉搜索树 “左子树 < 根结点 < 右子树” 的性质，插入操作分为两步：
|
||||
给定一个待插入元素 `num` ，为了保持二叉搜索树“左子树 < 根结点 < 右子树”的性质，插入操作分为两步：
|
||||
|
||||
1. **查找插入位置：** 与查找操作类似，我们从根结点出发，根据当前结点值和 `num` 的大小关系循环向下搜索，直到越过叶结点（遍历到 $\text{null}$ ）时跳出循环；
|
||||
2. **在该位置插入结点：** 初始化结点 `num` ，将该结点放到 $\text{null}$ 的位置 ；
|
||||
@@ -377,7 +393,33 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```csharp title="binary_search_tree.cs"
|
||||
/* 插入结点 */
|
||||
TreeNode? insert(int num)
|
||||
{
|
||||
// 若树为空，直接提前返回
|
||||
if (root == null) return null;
|
||||
TreeNode? cur = root, pre = null;
|
||||
// 循环查找，越过叶结点后跳出
|
||||
while (cur != null)
|
||||
{
|
||||
// 找到重复结点，直接返回
|
||||
if (cur.val == num) return null;
|
||||
pre = cur;
|
||||
// 插入位置在 root 的右子树中
|
||||
if (cur.val < num) cur = cur.right;
|
||||
// 插入位置在 root 的左子树中
|
||||
else cur = cur.left;
|
||||
}
|
||||
|
||||
// 插入结点 val
|
||||
TreeNode node = new TreeNode(num);
|
||||
if (pre != null)
|
||||
{
|
||||
if (pre.val < num) pre.right = node;
|
||||
else pre.left = node;
|
||||
}
|
||||
return node;
|
||||
}
|
||||
```
|
||||
|
||||
为了插入结点，需要借助 **辅助结点 `prev`** 保存上一轮循环的结点，这样在遍历到 $\text{null}$ 时，我们也可以获取到其父结点，从而完成结点插入操作。
|
||||
@@ -386,7 +428,7 @@ comments: true
|
||||
|
||||
### 删除结点
|
||||
|
||||
与插入结点一样，我们需要在删除操作后维持二叉搜索树的 “左子树 < 根结点 < 右子树” 的性质。首先，我们需要在二叉树中执行查找操作，获取待删除结点。接下来，根据待删除结点的子结点数量，删除操作需要分为三种情况：
|
||||
与插入结点一样，我们需要在删除操作后维持二叉搜索树的“左子树 < 根结点 < 右子树”的性质。首先，我们需要在二叉树中执行查找操作，获取待删除结点。接下来，根据待删除结点的子结点数量，删除操作需要分为三种情况：
|
||||
|
||||
**待删除结点的子结点数量 $= 0$ 。** 表明待删除结点是叶结点，直接删除即可。
|
||||
|
||||
@@ -744,7 +786,68 @@ comments: true
|
||||
=== "C#"
|
||||
|
||||
```csharp title="binary_search_tree.cs"
|
||||
|
||||
/* 删除结点 */
|
||||
TreeNode? remove(int num)
|
||||
{
|
||||
// 若树为空，直接提前返回
|
||||
if (root == null) return null;
|
||||
TreeNode? cur = root, pre = null;
|
||||
// 循环查找，越过叶结点后跳出
|
||||
while (cur != null)
|
||||
{
|
||||
// 找到待删除结点，跳出循环
|
||||
if (cur.val == num) break;
|
||||
pre = cur;
|
||||
// 待删除结点在 root 的右子树中
|
||||
if (cur.val < num) cur = cur.right;
|
||||
// 待删除结点在 root 的左子树中
|
||||
else cur = cur.left;
|
||||
}
|
||||
// 若无待删除结点，则直接返回
|
||||
if (cur == null || pre == null) return null;
|
||||
// 子结点数量 = 0 or 1
|
||||
if (cur.left == null || cur.right == null)
|
||||
{
|
||||
// 当子结点数量 = 0 / 1 时， child = null / 该子结点
|
||||
TreeNode? child = cur.left != null ? cur.left : cur.right;
|
||||
// 删除结点 cur
|
||||
if (pre.left == cur)
|
||||
{
|
||||
pre.left = child;
|
||||
}
|
||||
else
|
||||
{
|
||||
pre.right = child;
|
||||
}
|
||||
}
|
||||
// 子结点数量 = 2
|
||||
else
|
||||
{
|
||||
// 获取中序遍历中 cur 的下一个结点
|
||||
TreeNode? nex = min(cur.right);
|
||||
if (nex != null)
|
||||
{
|
||||
int tmp = nex.val;
|
||||
// 递归删除结点 nex
|
||||
remove(nex.val);
|
||||
// 将 nex 的值复制给 cur
|
||||
cur.val = tmp;
|
||||
}
|
||||
}
|
||||
return cur;
|
||||
}
|
||||
|
||||
/* 获取最小结点 */
|
||||
TreeNode? min(TreeNode? root)
|
||||
{
|
||||
if (root == null) return root;
|
||||
// 循环访问左子结点，直到叶结点时为最小结点，跳出
|
||||
while (root.left != null)
|
||||
{
|
||||
root = root.left;
|
||||
}
|
||||
return root;
|
||||
}
|
||||
```
|
||||
|
||||
## 二叉搜索树的优势
|
||||
@@ -763,7 +866,7 @@ comments: true
|
||||
- **删除元素：** 与无序数组中的情况相同，使用 $O(n)$ 时间；
|
||||
- **获取最小 / 最大元素：** 数组头部和尾部元素即是最小和最大元素，使用 $O(1)$ 时间；
|
||||
|
||||
观察发现，无序数组和有序数组中的各类操作的时间复杂度是 “偏科” 的，即有的快有的慢；**而二叉搜索树的各项操作的时间复杂度都是对数阶，在数据量 $n$ 很大时有巨大优势**。
|
||||
观察发现，无序数组和有序数组中的各项操作的时间复杂度是“偏科”的，即有的快有的慢；**而二叉搜索树的各项操作的时间复杂度都是对数阶，在数据量 $n$ 很大时有巨大优势**。
|
||||
|
||||
<div class="center-table" markdown>
|
||||
|
||||
@@ -778,7 +881,7 @@ comments: true
|
||||
|
||||
## 二叉搜索树的退化
|
||||
|
||||
理想情况下，我们希望二叉搜索树的是 “左右平衡” 的（详见「平衡二叉树」章节），此时可以在 $\log n$ 轮循环内查找任意结点。
|
||||
理想情况下，我们希望二叉搜索树的是“左右平衡”的（详见「平衡二叉树」章节），此时可以在 $\log n$ 轮循环内查找任意结点。
|
||||
|
||||
如果我们动态地在二叉搜索树中插入与删除结点，**则可能导致二叉树退化为链表**，此时各种操作的时间复杂度也退化之 $O(n)$ 。
|
||||
|
||||
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 72 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 94 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 77 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 68 KiB |
|
Before Width: | Height: | Size: 62 KiB After Width: | Height: | Size: 62 KiB |
|
Before Width: | Height: | Size: 55 KiB After Width: | Height: | Size: 55 KiB |
|
Before Width: | Height: | Size: 49 KiB After Width: | Height: | Size: 49 KiB |
|
Before Width: | Height: | Size: 64 KiB After Width: | Height: | Size: 64 KiB |
@@ -4,7 +4,7 @@ comments: true
|
||||
|
||||
# 二叉树
|
||||
|
||||
「二叉树 Binary Tree」是一种非线性数据结构，代表着祖先与后代之间的派生关系，体现着 “一分为二” 的分治逻辑。类似于链表，二叉树也是以结点为单位存储的，结点包含「值」和两个「指针」。
|
||||
「二叉树 Binary Tree」是一种非线性数据结构，代表着祖先与后代之间的派生关系，体现着“一分为二”的分治逻辑。类似于链表，二叉树也是以结点为单位存储的，结点包含「值」和两个「指针」。
|
||||
|
||||
=== "Java"
|
||||
|
||||
@@ -86,7 +86,7 @@ comments: true
|
||||
val: number;
|
||||
left: TreeNode | null;
|
||||
right: TreeNode | null;
|
||||
|
||||
|
||||
constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
|
||||
this.val = val === undefined ? 0 : val; // 结点值
|
||||
this.left = left === undefined ? null : left; // 左子结点指针
|
||||
@@ -98,23 +98,29 @@ comments: true
|
||||
=== "C"
|
||||
|
||||
```c title=""
|
||||
|
||||
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
|
||||
```csharp title=""
|
||||
|
||||
/* 链表结点类 */
|
||||
class TreeNode {
|
||||
int val; // 结点值
|
||||
TreeNode? left; // 左子结点指针
|
||||
TreeNode? right; // 右子结点指针
|
||||
TreeNode(int x) { val = x; }
|
||||
}
|
||||
```
|
||||
|
||||
结点的两个指针分别指向「左子结点 Left Child Node」和「右子结点 Right Child Node」，并且称该结点为两个子结点的「父结点 Parent Node」。给定二叉树某结点，将左子结点以下的树称为该结点的「左子树 Left Subtree」，右子树同理。
|
||||
|
||||
除了叶结点外，每个结点都有子结点和子树。例如，若将上图的「结点 2」看作父结点，那么其左子结点和右子结点分别为「结点 4」和「结点 5」，左子树和右子树分别为「结点 4 以下的树」和「结点 5 以下的树」。
|
||||
|
||||
|
||||
|
||||
<p align="center"> Fig. 子结点与子树 </p>
|
||||
|
||||
需要注意，父结点、子结点、子树是可以向下递推的。例如，如果将上图的「结点 2」看作父结点，那么其左子结点和右子结点分别为「结点 4」和「结点 5」，左子树和右子树分别为「结点 4 以下的树」和「结点 5 以下的树」。
|
||||
|
||||
## 二叉树常见术语
|
||||
|
||||
二叉树的术语较多，建议尽量理解并记住。后续可能遗忘，可以在需要使用时回来查看确认。
|
||||
@@ -136,27 +142,6 @@ comments: true
|
||||
|
||||
值得注意，我们通常将「高度」和「深度」定义为“走过边的数量”，而有些题目或教材会将其定义为“走过结点的数量”，此时高度或深度都需要 + 1 。
|
||||
|
||||
## 二叉树最佳和最差结构
|
||||
|
||||
当二叉树的每层的结点都被填满时，达到「完美二叉树」；而当所有结点都偏向一边时，二叉树退化为「链表」。
|
||||
|
||||
|
||||
|
||||
<p align="center"> Fig. 二叉树的最佳和最差结构 </p>
|
||||
|
||||
如下表所示，在最佳和最差结构下，二叉树的叶结点数量、结点总数、高度等达到极大或极小值。
|
||||
|
||||
<div class="center-table" markdown>
|
||||
|
||||
| | 完美二叉树 | 链表 |
|
||||
| ----------------------------- | ---------- | ---------- |
|
||||
| 第 $i$ 层的结点数量 | $2^{i-1}$ | $1$ |
|
||||
| 树的高度为 $h$ 时的叶结点数量 | $2^h$ | $1$ |
|
||||
| 树的高度为 $h$ 时的结点总数 | $2^{h+1} - 1$ | $h + 1$ |
|
||||
| 树的结点总数为 $n$ 时的高度 | $\log_2 (n+1) - 1$ | $n - 1$ |
|
||||
|
||||
</div>
|
||||
|
||||
## 二叉树基本操作
|
||||
|
||||
**初始化二叉树。** 与链表类似，先初始化结点，再构建引用指向（即指针）。
|
||||
@@ -265,13 +250,24 @@ comments: true
|
||||
=== "C"
|
||||
|
||||
```c title="binary_tree.c"
|
||||
|
||||
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
|
||||
```csharp title="binary_tree.cs"
|
||||
|
||||
/* 初始化二叉树 */
|
||||
// 初始化结点
|
||||
TreeNode n1 = new TreeNode(1);
|
||||
TreeNode n2 = new TreeNode(2);
|
||||
TreeNode n3 = new TreeNode(3);
|
||||
TreeNode n4 = new TreeNode(4);
|
||||
TreeNode n5 = new TreeNode(5);
|
||||
// 构建引用指向（即指针）
|
||||
n1.left = n2;
|
||||
n1.right = n3;
|
||||
n2.left = n4;
|
||||
n2.right = n5;
|
||||
```
|
||||
|
||||
**插入与删除结点。** 与链表类似，插入与删除结点都可以通过修改指针实现。
|
||||
@@ -354,422 +350,162 @@ comments: true
|
||||
=== "C"
|
||||
|
||||
```c title="binary_tree.c"
|
||||
|
||||
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
|
||||
```csharp title="binary_tree.cs"
|
||||
|
||||
/* 插入与删除结点 */
|
||||
TreeNode P = new TreeNode(0);
|
||||
// 在 n1 -> n2 中间插入结点 P
|
||||
n1.left = P;
|
||||
P.left = n2;
|
||||
// 删除结点 P
|
||||
n1.left = n2;
|
||||
```
|
||||
|
||||
!!! note
|
||||
|
||||
插入结点会改变二叉树的原有逻辑结构，删除结点往往意味着删除了该结点的所有子树。因此，二叉树中的插入与删除一般都是由一套操作配合完成的，这样才能实现有意义的操作。
|
||||
|
||||
## 二叉树遍历
|
||||
## 常见二叉树类型
|
||||
|
||||
非线性数据结构的遍历操作比线性数据结构更加复杂，往往需要使用搜索算法来实现。常见的二叉树遍历方式有层序遍历、前序遍历、中序遍历、后序遍历。
|
||||
### 完美二叉树
|
||||
|
||||
### 层序遍历
|
||||
「完美二叉树 Perfect Binary Tree」的所有层的结点都被完全填满。在完美二叉树中，所有结点的度 = 2 ；若树高度 $= h$ ，则结点总数 $= 2^{h+1} - 1$ ，呈标准的指数级关系，反映着自然界中常见的细胞分裂。
|
||||
|
||||
「层序遍历 Hierarchical-Order Traversal」从顶至底、一层一层地遍历二叉树，并在每层中按照从左到右的顺序访问结点。
|
||||
!!! tip
|
||||
|
||||
层序遍历本质上是「广度优先搜索 Breadth-First Traversal」，其体现着一种 “一圈一圈向外” 的层进遍历方式。
|
||||
在中文社区中，完美二叉树常被称为「满二叉树」，请注意与完满二叉树区分。
|
||||
|
||||
|
||||
|
||||
|
||||
<p align="center"> Fig. 二叉树的层序遍历 </p>
|
||||
### 完全二叉树
|
||||
|
||||
广度优先遍历一般借助「队列」来实现。队列的规则是 “先进先出” ，广度优先遍历的规则是 ”一层层平推“ ，两者背后的思想是一致的。
|
||||
「完全二叉树 Complete Binary Tree」只有最底层的结点未被填满，且最底层结点尽量靠左填充。
|
||||
|
||||
=== "Java"
|
||||
**完全二叉树非常适合用数组来表示**。如果按照层序遍历序列的顺序来存储，那么空结点 `null` 一定全部出现在序列的尾部，因此我们就可以不用存储这些 null 了。
|
||||
|
||||
```java title="binary_tree_bfs.java"
|
||||
/* 层序遍历 */
|
||||
List<Integer> hierOrder(TreeNode root) {
|
||||
// 初始化队列，加入根结点
|
||||
Queue<TreeNode> queue = new LinkedList<>() {{ add(root); }};
|
||||
// 初始化一个列表，用于保存遍历序列
|
||||
List<Integer> list = new ArrayList<>();
|
||||
while (!queue.isEmpty()) {
|
||||
TreeNode node = queue.poll(); // 队列出队
|
||||
list.add(node.val); // 保存结点值
|
||||
if (node.left != null)
|
||||
queue.offer(node.left); // 左子结点入队
|
||||
if (node.right != null)
|
||||
queue.offer(node.right); // 右子结点入队
|
||||
}
|
||||
return list;
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
=== "C++"
|
||||
### 完满二叉树
|
||||
|
||||
```cpp title="binary_tree_bfs.cpp"
|
||||
/* 层序遍历 */
|
||||
vector<int> hierOrder(TreeNode* root) {
|
||||
// 初始化队列，加入根结点
|
||||
queue<TreeNode*> queue;
|
||||
queue.push(root);
|
||||
// 初始化一个列表，用于保存遍历序列
|
||||
vector<int> vec;
|
||||
while (!queue.empty()) {
|
||||
TreeNode* node = queue.front();
|
||||
queue.pop(); // 队列出队
|
||||
vec.push_back(node->val); // 保存结点
|
||||
if (node->left != nullptr)
|
||||
queue.push(node->left); // 左子结点入队
|
||||
if (node->right != nullptr)
|
||||
queue.push(node->right); // 右子结点入队
|
||||
}
|
||||
return vec;
|
||||
}
|
||||
```
|
||||
「完满二叉树 Full Binary Tree」除了叶结点之外，其余所有结点都有两个子结点。
|
||||
|
||||
=== "Python"
|
||||
|
||||
|
||||
```python title="binary_tree_bfs.py"
|
||||
""" 层序遍历 """
|
||||
def hier_order(root):
|
||||
# 初始化队列，加入根结点
|
||||
queue = collections.deque()
|
||||
queue.append(root)
|
||||
# 初始化一个列表，用于保存遍历序列
|
||||
result = []
|
||||
while queue:
|
||||
# 队列出队
|
||||
node = queue.popleft()
|
||||
# 保存节点值
|
||||
result.append(node.val)
|
||||
if node.left is not None:
|
||||
# 左子结点入队
|
||||
queue.append(node.left)
|
||||
if node.right is not None:
|
||||
# 右子结点入队
|
||||
queue.append(node.right)
|
||||
return result
|
||||
```
|
||||
### 平衡二叉树
|
||||
|
||||
=== "Go"
|
||||
「平衡二叉树 Balanced Binary Tree」中任意结点的左子树和右子树的高度之差的绝对值 $\leq 1$ 。
|
||||
|
||||
```go title="binary_tree_bfs.go"
|
||||
/* 层序遍历 */
|
||||
func levelOrder(root *TreeNode) []int {
|
||||
// 初始化队列，加入根结点
|
||||
queue := list.New()
|
||||
queue.PushBack(root)
|
||||
// 初始化一个切片，用于保存遍历序列
|
||||
nums := make([]int, 0)
|
||||
for queue.Len() > 0 {
|
||||
// poll
|
||||
node := queue.Remove(queue.Front()).(*TreeNode)
|
||||
// 保存结点
|
||||
nums = append(nums, node.Val)
|
||||
if node.Left != nil {
|
||||
// 左子结点入队
|
||||
queue.PushBack(node.Left)
|
||||
}
|
||||
if node.Right != nil {
|
||||
// 右子结点入队
|
||||
queue.PushBack(node.Right)
|
||||
}
|
||||
}
|
||||
return nums
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
=== "JavaScript"
|
||||
## 二叉树的退化
|
||||
|
||||
```js title="binary_tree_bfs.js"
|
||||
/* 层序遍历 */
|
||||
function hierOrder(root) {
|
||||
// 初始化队列，加入根结点
|
||||
let queue = [root];
|
||||
// 初始化一个列表，用于保存遍历序列
|
||||
let list = [];
|
||||
while (queue.length) {
|
||||
let node = queue.shift(); // 队列出队
|
||||
list.push(node.val); // 保存结点
|
||||
if (node.left)
|
||||
queue.push(node.left); // 左子结点入队
|
||||
if (node.right)
|
||||
queue.push(node.right); // 右子结点入队
|
||||
}
|
||||
return list;
|
||||
}
|
||||
```
|
||||
当二叉树的每层的结点都被填满时，达到「完美二叉树」；而当所有结点都偏向一边时，二叉树退化为「链表」。
|
||||
|
||||
=== "TypeScript"
|
||||
- 完美二叉树是一个二叉树的“最佳状态”，可以完全发挥出二叉树“分治”的优势；
|
||||
- 链表则是另一个极端，各项操作都变为线性操作，时间复杂度退化至 $O(n)$ ；
|
||||
|
||||
```typescript title="binary_tree_bfs.ts"
|
||||
/* 层序遍历 */
|
||||
function hierOrder(root: TreeNode | null): number[] {
|
||||
// 初始化队列，加入根结点
|
||||
const queue = [root];
|
||||
// 初始化一个列表，用于保存遍历序列
|
||||
const list: number[] = [];
|
||||
while (queue.length) {
|
||||
let node = queue.shift() as TreeNode; // 队列出队
|
||||
list.push(node.val); // 保存结点
|
||||
if (node.left) {
|
||||
queue.push(node.left); // 左子结点入队
|
||||
}
|
||||
if (node.right) {
|
||||
queue.push(node.right); // 右子结点入队
|
||||
}
|
||||
}
|
||||
return list;
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
=== "C"
|
||||
<p align="center"> Fig. 二叉树的最佳和最差结构 </p>
|
||||
|
||||
```c title="binary_tree_bfs.c"
|
||||
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
|
||||
```csharp title="binary_tree_bfs.cs"
|
||||
|
||||
```
|
||||
|
||||
### 前序、中序、后序遍历
|
||||
|
||||
相对地，前、中、后序遍历皆属于「深度优先遍历 Depth-First Traversal」，其体现着一种 “先走到尽头，再回头继续” 的回溯遍历方式。
|
||||
|
||||
如下图所示，左侧是深度优先遍历的的示意图，右上方是对应的递归实现代码。深度优先遍历就像是绕着整个二叉树的外围 “走” 一圈，走的过程中，在每个结点都会遇到三个位置，分别对应前序遍历、中序遍历、后序遍历。
|
||||
|
||||
|
||||
|
||||
<p align="center"> Fig. 二叉树的前 / 中 / 后序遍历 </p>
|
||||
如下表所示，在最佳和最差结构下，二叉树的叶结点数量、结点总数、高度等达到极大或极小值。
|
||||
|
||||
<div class="center-table" markdown>
|
||||
|
||||
| 位置 | 含义 | 此处访问结点时对应 |
|
||||
| ---------- | ------------------------------------ | ----------------------------- |
|
||||
| 橙色圆圈处 | 刚进入此结点，即将访问该结点的左子树 | 前序遍历 Pre-Order Traversal |
|
||||
| 蓝色圆圈处 | 已访问完左子树，即将访问右子树 | 中序遍历 In-Order Traversal |
|
||||
| 紫色圆圈处 | 已访问完左子树和右子树，即将返回 | 后序遍历 Post-Order Traversal |
|
||||
| | 完美二叉树 | 链表 |
|
||||
| ----------------------------- | ---------- | ---------- |
|
||||
| 第 $i$ 层的结点数量 | $2^{i-1}$ | $1$ |
|
||||
| 树的高度为 $h$ 时的叶结点数量 | $2^h$ | $1$ |
|
||||
| 树的高度为 $h$ 时的结点总数 | $2^{h+1} - 1$ | $h + 1$ |
|
||||
| 树的结点总数为 $n$ 时的高度 | $\log_2 (n+1) - 1$ | $n - 1$ |
|
||||
|
||||
</div>
|
||||
|
||||
## 二叉树表示方式 *
|
||||
|
||||
我们一般使用二叉树的「链表表示」，即存储单位为结点 `TreeNode` ，结点之间通过指针（引用）相连接。本文前述示例代码展示了二叉树在链表表示下的各项基本操作。
|
||||
|
||||
那能否可以用「数组表示」二叉树呢？答案是肯定的。先来分析一个简单案例，给定一个「完美二叉树」，将结点按照层序遍历的顺序编号（从 0 开始），那么可以推导得出父结点索引与子结点索引之间的「映射公式」：**设结点的索引为 $i$ ，则该结点的左子结点索引为 $2i + 1$ 、右子结点索引为 $2i + 2$** 。
|
||||
|
||||
**本质上，映射公式的作用就是链表中的指针**。对于层序遍历序列中的任意结点，我们都可以使用映射公式来访问子结点。因此，可以直接使用层序遍历序列（即数组）来表示完美二叉树。
|
||||
|
||||
|
||||
|
||||
然而，完美二叉树只是个例，二叉树中间层往往存在许多空结点（即 `null` ），而层序遍历序列并不包含这些空结点，并且我们无法单凭序列来猜测空结点的数量和分布位置，**即理论上存在许多种二叉树都符合该层序遍历序列**。显然，这种情况无法使用数组来存储二叉树。
|
||||
|
||||
|
||||
|
||||
为了解决此问题，考虑按照完美二叉树的形式来表示所有二叉树，**即在序列中使用特殊符号来显式地表示“空位”**。如下图所示，这样处理后，序列（数组）就可以唯一表示二叉树了。
|
||||
|
||||
=== "Java"
|
||||
|
||||
```java title="binary_tree_dfs.java"
|
||||
/* 前序遍历 */
|
||||
void preOrder(TreeNode root) {
|
||||
if (root == null) return;
|
||||
// 访问优先级：根结点 -> 左子树 -> 右子树
|
||||
list.add(root.val);
|
||||
preOrder(root.left);
|
||||
preOrder(root.right);
|
||||
}
|
||||
|
||||
/* 中序遍历 */
|
||||
void inOrder(TreeNode root) {
|
||||
if (root == null) return;
|
||||
// 访问优先级：左子树 -> 根结点 -> 右子树
|
||||
inOrder(root.left);
|
||||
list.add(root.val);
|
||||
inOrder(root.right);
|
||||
}
|
||||
|
||||
/* 后序遍历 */
|
||||
void postOrder(TreeNode root) {
|
||||
if (root == null) return;
|
||||
// 访问优先级：左子树 -> 右子树 -> 根结点
|
||||
postOrder(root.left);
|
||||
postOrder(root.right);
|
||||
list.add(root.val);
|
||||
}
|
||||
```java title=""
|
||||
/* 二叉树的数组表示 */
|
||||
// 使用 int 的包装类 Integer ，就可以使用 null 来标记空位
|
||||
Integer[] tree = { 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 };
|
||||
```
|
||||
|
||||
=== "C++"
|
||||
|
||||
```cpp title="binary_tree_dfs.cpp"
|
||||
/* 前序遍历 */
|
||||
void preOrder(TreeNode* root) {
|
||||
if (root == nullptr) return;
|
||||
// 访问优先级：根结点 -> 左子树 -> 右子树
|
||||
vec.push_back(root->val);
|
||||
preOrder(root->left);
|
||||
preOrder(root->right);
|
||||
}
|
||||
|
||||
/* 中序遍历 */
|
||||
void inOrder(TreeNode* root) {
|
||||
if (root == nullptr) return;
|
||||
// 访问优先级：左子树 -> 根结点 -> 右子树
|
||||
inOrder(root->left);
|
||||
vec.push_back(root->val);
|
||||
inOrder(root->right);
|
||||
}
|
||||
|
||||
/* 后序遍历 */
|
||||
void postOrder(TreeNode* root) {
|
||||
if (root == nullptr) return;
|
||||
// 访问优先级：左子树 -> 右子树 -> 根结点
|
||||
postOrder(root->left);
|
||||
postOrder(root->right);
|
||||
vec.push_back(root->val);
|
||||
}
|
||||
```cpp title=""
|
||||
/* 二叉树的数组表示 */
|
||||
// 为了符合数据类型为 int ，使用 int 最大值标记空位
|
||||
// 该方法的使用前提是没有结点的值 = INT_MAX
|
||||
vector<int> tree = { 1, 2, 3, 4, INT_MAX, 6, 7, 8, 9, INT_MAX, INT_MAX, 12, INT_MAX, INT_MAX, 15 };
|
||||
```
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python title="binary_tree_dfs.py"
|
||||
""" 前序遍历二叉树 """
|
||||
def pre_order(root: typing.Optional[TreeNode]):
|
||||
if root is None:
|
||||
return
|
||||
|
||||
# 访问优先级：根结点 -> 左子树 -> 右子树
|
||||
result.append(root.val)
|
||||
pre_order(root=root.left)
|
||||
pre_order(root=root.right)
|
||||
|
||||
|
||||
""" 中序遍历二叉树 """
|
||||
def in_order(root: typing.Optional[TreeNode]):
|
||||
if root is None:
|
||||
return
|
||||
|
||||
# 访问优先级：左子树 -> 根结点 -> 右子树
|
||||
in_order(root=root.left)
|
||||
result.append(root.val)
|
||||
in_order(root=root.right)
|
||||
|
||||
|
||||
""" 后序遍历二叉树 """
|
||||
def post_order(root: typing.Optional[TreeNode]):
|
||||
if root is None:
|
||||
return
|
||||
|
||||
# 访问优先级：左子树 -> 右子树 -> 根结点
|
||||
post_order(root=root.left)
|
||||
post_order(root=root.right)
|
||||
result.append(root.val)
|
||||
```python title=""
|
||||
“”“ 二叉树的数组表示 ”“”
|
||||
# 直接使用 None 来表示空位
|
||||
tree = [1, 2, 3, 4, None, 6, 7, 8, 9, None, None, 12, None, None, 15]
|
||||
```
|
||||
|
||||
=== "Go"
|
||||
|
||||
```go title="binary_tree_dfs.go"
|
||||
/* 前序遍历 */
|
||||
func preOrder(node *TreeNode) {
|
||||
if node == nil {
|
||||
return
|
||||
}
|
||||
// 访问优先级：根结点 -> 左子树 -> 右子树
|
||||
nums = append(nums, node.Val)
|
||||
preOrder(node.Left)
|
||||
preOrder(node.Right)
|
||||
}
|
||||
|
||||
/* 中序遍历 */
|
||||
func inOrder(node *TreeNode) {
|
||||
if node == nil {
|
||||
return
|
||||
}
|
||||
// 访问优先级：左子树 -> 根结点 -> 右子树
|
||||
inOrder(node.Left)
|
||||
nums = append(nums, node.Val)
|
||||
inOrder(node.Right)
|
||||
}
|
||||
|
||||
/* 后序遍历 */
|
||||
func postOrder(node *TreeNode) {
|
||||
if node == nil {
|
||||
return
|
||||
}
|
||||
// 访问优先级：左子树 -> 右子树 -> 根结点
|
||||
postOrder(node.Left)
|
||||
postOrder(node.Right)
|
||||
nums = append(nums, node.Val)
|
||||
}
|
||||
```go title=""
|
||||
|
||||
```
|
||||
|
||||
=== "JavaScript"
|
||||
|
||||
```js title="binary_tree_dfs.js"
|
||||
/* 前序遍历 */
|
||||
function preOrder(root){
|
||||
if (root === null) return;
|
||||
// 访问优先级：根结点 -> 左子树 -> 右子树
|
||||
list.push(root.val);
|
||||
preOrder(root.left);
|
||||
preOrder(root.right);
|
||||
}
|
||||
|
||||
/* 中序遍历 */
|
||||
function inOrder(root) {
|
||||
if (root === null) return;
|
||||
// 访问优先级：左子树 -> 根结点 -> 右子树
|
||||
inOrder(root.left);
|
||||
list.push(root.val);
|
||||
inOrder(root.right);
|
||||
}
|
||||
|
||||
/* 后序遍历 */
|
||||
function postOrder(root) {
|
||||
if (root === null) return;
|
||||
// 访问优先级：左子树 -> 右子树 -> 根结点
|
||||
postOrder(root.left);
|
||||
postOrder(root.right);
|
||||
list.push(root.val);
|
||||
}
|
||||
```js title=""
|
||||
/* 二叉树的数组表示 */
|
||||
// 直接使用 null 来表示空位
|
||||
let tree = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];
|
||||
```
|
||||
|
||||
=== "TypeScript"
|
||||
|
||||
```typescript title="binary_tree_dfs.ts"
|
||||
/* 前序遍历 */
|
||||
function preOrder(root: TreeNode | null): void {
|
||||
if (root === null) {
|
||||
return;
|
||||
}
|
||||
// 访问优先级：根结点 -> 左子树 -> 右子树
|
||||
list.push(root.val);
|
||||
preOrder(root.left);
|
||||
preOrder(root.right);
|
||||
}
|
||||
|
||||
/* 中序遍历 */
|
||||
function inOrder(root: TreeNode | null): void {
|
||||
if (root === null) {
|
||||
return;
|
||||
}
|
||||
// 访问优先级：左子树 -> 根结点 -> 右子树
|
||||
inOrder(root.left);
|
||||
list.push(root.val);
|
||||
inOrder(root.right);
|
||||
}
|
||||
|
||||
/* 后序遍历 */
|
||||
function postOrder(root: TreeNode | null): void {
|
||||
if (root === null) {
|
||||
return;
|
||||
}
|
||||
// 访问优先级：左子树 -> 右子树 -> 根结点
|
||||
postOrder(root.left);
|
||||
postOrder(root.right);
|
||||
list.push(root.val);
|
||||
}
|
||||
```typescript title=""
|
||||
/* 二叉树的数组表示 */
|
||||
// 直接使用 null 来表示空位
|
||||
let tree: (number | null)[] = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];
|
||||
```
|
||||
|
||||
=== "C"
|
||||
|
||||
```c title="binary_tree_dfs.c"
|
||||
|
||||
```c title=""
|
||||
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
|
||||
```csharp title="binary_tree_dfs.cs"
|
||||
|
||||
```csharp title=""
|
||||
/* 二叉树的数组表示 */
|
||||
// 使用 int? 可空类型 ，就可以使用 null 来标记空位
|
||||
int?[] tree = { 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 };
|
||||
```
|
||||
|
||||
!!! note
|
||||
|
||||
|
||||
使用循环一样可以实现前、中、后序遍历，但代码相对繁琐，有兴趣的同学可以自行实现。
|
||||
回顾「完全二叉树」的满足条件，其只有最底层有空结点，并且最底层的结点尽量靠左，因而所有空结点都一定出现在层序遍历序列的末尾。**因为我们先验地确定了空位的位置，所以在使用数组表示完全二叉树时，可以省略存储“空位”**。“便于使用数组表示”也是完全二叉树受欢迎的原因之一。
|
||||
|
||||
|
||||
|
||||
数组表示有两个优点： 一是不需要存储指针，节省空间；二是可以随机访问结点。然而，当二叉树中的“空位”很多时，数组中只包含很少结点的数据，空间利用率很低。
|
||||
|
||||
|
Before Width: | Height: | Size: 59 KiB After Width: | Height: | Size: 59 KiB |
|
Before Width: | Height: | Size: 171 KiB After Width: | Height: | Size: 171 KiB |
410
docs/chapter_tree/binary_tree_traversal.md
Normal file
410
docs/chapter_tree/binary_tree_traversal.md
Normal file
@@ -0,0 +1,410 @@
|
||||
---
|
||||
comments: true
|
||||
---
|
||||
|
||||
# 二叉树遍历
|
||||
|
||||
非线性数据结构的遍历操作比线性数据结构更加复杂，往往需要使用搜索算法来实现。常见的二叉树遍历方式有层序遍历、前序遍历、中序遍历、后序遍历。
|
||||
|
||||
## 层序遍历
|
||||
|
||||
「层序遍历 Hierarchical-Order Traversal」从顶至底、一层一层地遍历二叉树，并在每层中按照从左到右的顺序访问结点。
|
||||
|
||||
层序遍历本质上是「广度优先搜索 Breadth-First Traversal」，其体现着一种“一圈一圈向外”的层进遍历方式。
|
||||
|
||||
|
||||
|
||||
<p align="center"> Fig. 二叉树的层序遍历 </p>
|
||||
|
||||
广度优先遍历一般借助「队列」来实现。队列的规则是“先进先出”，广度优先遍历的规则是 ”一层层平推“ ，两者背后的思想是一致的。
|
||||
|
||||
=== "Java"
|
||||
|
||||
```java title="binary_tree_bfs.java"
|
||||
/* 层序遍历 */
|
||||
List<Integer> hierOrder(TreeNode root) {
|
||||
// 初始化队列，加入根结点
|
||||
Queue<TreeNode> queue = new LinkedList<>() {{ add(root); }};
|
||||
// 初始化一个列表，用于保存遍历序列
|
||||
List<Integer> list = new ArrayList<>();
|
||||
while (!queue.isEmpty()) {
|
||||
TreeNode node = queue.poll(); // 队列出队
|
||||
list.add(node.val); // 保存结点值
|
||||
if (node.left != null)
|
||||
queue.offer(node.left); // 左子结点入队
|
||||
if (node.right != null)
|
||||
queue.offer(node.right); // 右子结点入队
|
||||
}
|
||||
return list;
|
||||
}
|
||||
```
|
||||
|
||||
=== "C++"
|
||||
|
||||
```cpp title="binary_tree_bfs.cpp"
|
||||
/* 层序遍历 */
|
||||
vector<int> hierOrder(TreeNode* root) {
|
||||
// 初始化队列，加入根结点
|
||||
queue<TreeNode*> queue;
|
||||
queue.push(root);
|
||||
// 初始化一个列表，用于保存遍历序列
|
||||
vector<int> vec;
|
||||
while (!queue.empty()) {
|
||||
TreeNode* node = queue.front();
|
||||
queue.pop(); // 队列出队
|
||||
vec.push_back(node->val); // 保存结点
|
||||
if (node->left != nullptr)
|
||||
queue.push(node->left); // 左子结点入队
|
||||
if (node->right != nullptr)
|
||||
queue.push(node->right); // 右子结点入队
|
||||
}
|
||||
return vec;
|
||||
}
|
||||
```
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python title="binary_tree_bfs.py"
|
||||
|
||||
```
|
||||
|
||||
=== "Go"
|
||||
|
||||
```go title="binary_tree_bfs.go"
|
||||
/* 层序遍历 */
|
||||
func levelOrder(root *TreeNode) []int {
|
||||
// 初始化队列，加入根结点
|
||||
queue := list.New()
|
||||
queue.PushBack(root)
|
||||
// 初始化一个切片，用于保存遍历序列
|
||||
nums := make([]int, 0)
|
||||
for queue.Len() > 0 {
|
||||
// poll
|
||||
node := queue.Remove(queue.Front()).(*TreeNode)
|
||||
// 保存结点
|
||||
nums = append(nums, node.Val)
|
||||
if node.Left != nil {
|
||||
// 左子结点入队
|
||||
queue.PushBack(node.Left)
|
||||
}
|
||||
if node.Right != nil {
|
||||
// 右子结点入队
|
||||
queue.PushBack(node.Right)
|
||||
}
|
||||
}
|
||||
return nums
|
||||
}
|
||||
```
|
||||
|
||||
=== "JavaScript"
|
||||
|
||||
```js title="binary_tree_bfs.js"
|
||||
/* 层序遍历 */
|
||||
function hierOrder(root) {
|
||||
// 初始化队列，加入根结点
|
||||
let queue = [root];
|
||||
// 初始化一个列表，用于保存遍历序列
|
||||
let list = [];
|
||||
while (queue.length) {
|
||||
let node = queue.shift(); // 队列出队
|
||||
list.push(node.val); // 保存结点
|
||||
if (node.left)
|
||||
queue.push(node.left); // 左子结点入队
|
||||
if (node.right)
|
||||
queue.push(node.right); // 右子结点入队
|
||||
}
|
||||
return list;
|
||||
}
|
||||
```
|
||||
|
||||
=== "TypeScript"
|
||||
|
||||
```typescript title="binary_tree_bfs.ts"
|
||||
/* 层序遍历 */
|
||||
function hierOrder(root: TreeNode | null): number[] {
|
||||
// 初始化队列，加入根结点
|
||||
const queue = [root];
|
||||
// 初始化一个列表，用于保存遍历序列
|
||||
const list: number[] = [];
|
||||
while (queue.length) {
|
||||
let node = queue.shift() as TreeNode; // 队列出队
|
||||
list.push(node.val); // 保存结点
|
||||
if (node.left) {
|
||||
queue.push(node.left); // 左子结点入队
|
||||
}
|
||||
if (node.right) {
|
||||
queue.push(node.right); // 右子结点入队
|
||||
}
|
||||
}
|
||||
return list;
|
||||
}
|
||||
```
|
||||
|
||||
=== "C"
|
||||
|
||||
```c title="binary_tree_bfs.c"
|
||||
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
|
||||
```csharp title="binary_tree_bfs.cs"
|
||||
/* 层序遍历 */
|
||||
public List<int?> hierOrder(TreeNode root)
|
||||
{
|
||||
// 初始化队列，加入根结点
|
||||
Queue<TreeNode> queue = new();
|
||||
queue.Enqueue(root);
|
||||
// 初始化一个列表，用于保存遍历序列
|
||||
List<int> list = new();
|
||||
while (queue.Count != 0)
|
||||
{
|
||||
TreeNode node = queue.Dequeue(); // 队列出队
|
||||
list.Add(node.val); // 保存结点值
|
||||
if (node.left != null)
|
||||
queue.Enqueue(node.left); // 左子结点入队
|
||||
if (node.right != null)
|
||||
queue.Enqueue(node.right); // 右子结点入队
|
||||
}
|
||||
return list;
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
## 前序、中序、后序遍历
|
||||
|
||||
相对地，前、中、后序遍历皆属于「深度优先遍历 Depth-First Traversal」，其体现着一种“先走到尽头，再回头继续”的回溯遍历方式。
|
||||
|
||||
如下图所示，左侧是深度优先遍历的的示意图，右上方是对应的递归实现代码。深度优先遍历就像是绕着整个二叉树的外围“走”一圈，走的过程中，在每个结点都会遇到三个位置，分别对应前序遍历、中序遍历、后序遍历。
|
||||
|
||||
|
||||
|
||||
<p align="center"> Fig. 二叉树的前 / 中 / 后序遍历 </p>
|
||||
|
||||
<div class="center-table" markdown>
|
||||
|
||||
| 位置 | 含义 | 此处访问结点时对应 |
|
||||
| ---------- | ------------------------------------ | ----------------------------- |
|
||||
| 橙色圆圈处 | 刚进入此结点，即将访问该结点的左子树 | 前序遍历 Pre-Order Traversal |
|
||||
| 蓝色圆圈处 | 已访问完左子树，即将访问右子树 | 中序遍历 In-Order Traversal |
|
||||
| 紫色圆圈处 | 已访问完左子树和右子树，即将返回 | 后序遍历 Post-Order Traversal |
|
||||
|
||||
</div>
|
||||
|
||||
=== "Java"
|
||||
|
||||
```java title="binary_tree_dfs.java"
|
||||
/* 前序遍历 */
|
||||
void preOrder(TreeNode root) {
|
||||
if (root == null) return;
|
||||
// 访问优先级：根结点 -> 左子树 -> 右子树
|
||||
list.add(root.val);
|
||||
preOrder(root.left);
|
||||
preOrder(root.right);
|
||||
}
|
||||
|
||||
/* 中序遍历 */
|
||||
void inOrder(TreeNode root) {
|
||||
if (root == null) return;
|
||||
// 访问优先级：左子树 -> 根结点 -> 右子树
|
||||
inOrder(root.left);
|
||||
list.add(root.val);
|
||||
inOrder(root.right);
|
||||
}
|
||||
|
||||
/* 后序遍历 */
|
||||
void postOrder(TreeNode root) {
|
||||
if (root == null) return;
|
||||
// 访问优先级：左子树 -> 右子树 -> 根结点
|
||||
postOrder(root.left);
|
||||
postOrder(root.right);
|
||||
list.add(root.val);
|
||||
}
|
||||
```
|
||||
|
||||
=== "C++"
|
||||
|
||||
```cpp title="binary_tree_dfs.cpp"
|
||||
/* 前序遍历 */
|
||||
void preOrder(TreeNode* root) {
|
||||
if (root == nullptr) return;
|
||||
// 访问优先级：根结点 -> 左子树 -> 右子树
|
||||
vec.push_back(root->val);
|
||||
preOrder(root->left);
|
||||
preOrder(root->right);
|
||||
}
|
||||
|
||||
/* 中序遍历 */
|
||||
void inOrder(TreeNode* root) {
|
||||
if (root == nullptr) return;
|
||||
// 访问优先级：左子树 -> 根结点 -> 右子树
|
||||
inOrder(root->left);
|
||||
vec.push_back(root->val);
|
||||
inOrder(root->right);
|
||||
}
|
||||
|
||||
/* 后序遍历 */
|
||||
void postOrder(TreeNode* root) {
|
||||
if (root == nullptr) return;
|
||||
// 访问优先级：左子树 -> 右子树 -> 根结点
|
||||
postOrder(root->left);
|
||||
postOrder(root->right);
|
||||
vec.push_back(root->val);
|
||||
}
|
||||
```
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python title="binary_tree_dfs.py"
|
||||
|
||||
```
|
||||
|
||||
=== "Go"
|
||||
|
||||
```go title="binary_tree_dfs.go"
|
||||
/* 前序遍历 */
|
||||
func preOrder(node *TreeNode) {
|
||||
if node == nil {
|
||||
return
|
||||
}
|
||||
// 访问优先级：根结点 -> 左子树 -> 右子树
|
||||
nums = append(nums, node.Val)
|
||||
preOrder(node.Left)
|
||||
preOrder(node.Right)
|
||||
}
|
||||
|
||||
/* 中序遍历 */
|
||||
func inOrder(node *TreeNode) {
|
||||
if node == nil {
|
||||
return
|
||||
}
|
||||
// 访问优先级：左子树 -> 根结点 -> 右子树
|
||||
inOrder(node.Left)
|
||||
nums = append(nums, node.Val)
|
||||
inOrder(node.Right)
|
||||
}
|
||||
|
||||
/* 后序遍历 */
|
||||
func postOrder(node *TreeNode) {
|
||||
if node == nil {
|
||||
return
|
||||
}
|
||||
// 访问优先级：左子树 -> 右子树 -> 根结点
|
||||
postOrder(node.Left)
|
||||
postOrder(node.Right)
|
||||
nums = append(nums, node.Val)
|
||||
}
|
||||
```
|
||||
|
||||
=== "JavaScript"
|
||||
|
||||
```js title="binary_tree_dfs.js"
|
||||
/* 前序遍历 */
|
||||
function preOrder(root){
|
||||
if (root === null) return;
|
||||
// 访问优先级：根结点 -> 左子树 -> 右子树
|
||||
list.push(root.val);
|
||||
preOrder(root.left);
|
||||
preOrder(root.right);
|
||||
}
|
||||
|
||||
/* 中序遍历 */
|
||||
function inOrder(root) {
|
||||
if (root === null) return;
|
||||
// 访问优先级：左子树 -> 根结点 -> 右子树
|
||||
inOrder(root.left);
|
||||
list.push(root.val);
|
||||
inOrder(root.right);
|
||||
}
|
||||
|
||||
/* 后序遍历 */
|
||||
function postOrder(root) {
|
||||
if (root === null) return;
|
||||
// 访问优先级：左子树 -> 右子树 -> 根结点
|
||||
postOrder(root.left);
|
||||
postOrder(root.right);
|
||||
list.push(root.val);
|
||||
}
|
||||
```
|
||||
|
||||
=== "TypeScript"
|
||||
|
||||
```typescript title="binary_tree_dfs.ts"
|
||||
/* 前序遍历 */
|
||||
function preOrder(root: TreeNode | null): void {
|
||||
if (root === null) {
|
||||
return;
|
||||
}
|
||||
// 访问优先级：根结点 -> 左子树 -> 右子树
|
||||
list.push(root.val);
|
||||
preOrder(root.left);
|
||||
preOrder(root.right);
|
||||
}
|
||||
|
||||
/* 中序遍历 */
|
||||
function inOrder(root: TreeNode | null): void {
|
||||
if (root === null) {
|
||||
return;
|
||||
}
|
||||
// 访问优先级：左子树 -> 根结点 -> 右子树
|
||||
inOrder(root.left);
|
||||
list.push(root.val);
|
||||
inOrder(root.right);
|
||||
}
|
||||
|
||||
/* 后序遍历 */
|
||||
function postOrder(root: TreeNode | null): void {
|
||||
if (root === null) {
|
||||
return;
|
||||
}
|
||||
// 访问优先级：左子树 -> 右子树 -> 根结点
|
||||
postOrder(root.left);
|
||||
postOrder(root.right);
|
||||
list.push(root.val);
|
||||
}
|
||||
```
|
||||
|
||||
=== "C"
|
||||
|
||||
```c title="binary_tree_dfs.c"
|
||||
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
|
||||
```csharp title="binary_tree_dfs.cs"
|
||||
/* 前序遍历 */
|
||||
void preOrder(TreeNode? root)
|
||||
{
|
||||
if (root == null) return;
|
||||
// 访问优先级：根结点 -> 左子树 -> 右子树
|
||||
list.Add(root.val);
|
||||
preOrder(root.left);
|
||||
preOrder(root.right);
|
||||
}
|
||||
|
||||
/* 中序遍历 */
|
||||
void inOrder(TreeNode? root)
|
||||
{
|
||||
if (root == null) return;
|
||||
// 访问优先级：左子树 -> 根结点 -> 右子树
|
||||
inOrder(root.left);
|
||||
list.Add(root.val);
|
||||
inOrder(root.right);
|
||||
}
|
||||
|
||||
/* 后序遍历 */
|
||||
void postOrder(TreeNode? root)
|
||||
{
|
||||
if (root == null) return;
|
||||
// 访问优先级：左子树 -> 右子树 -> 根结点
|
||||
postOrder(root.left);
|
||||
postOrder(root.right);
|
||||
list.Add(root.val);
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
!!! note
|
||||
|
||||
使用循环一样可以实现前、中、后序遍历，但代码相对繁琐，有兴趣的同学可以自行实现。
|
||||
@@ -1,44 +0,0 @@
|
||||
---
|
||||
comments: true
|
||||
---
|
||||
|
||||
# 常见二叉树类型
|
||||
|
||||
## 完美二叉树
|
||||
|
||||
「完美二叉树 Perfect Binary Tree」，其所有层的结点都被完全填满。
|
||||
|
||||
!!! tip
|
||||
|
||||
在中文社区中，完美二叉树常被称为「满二叉树」，请注意与完满二叉树区分。
|
||||
|
||||
|
||||
|
||||
完美二叉树的性质有：
|
||||
|
||||
- 若树高度 $= h$ ，则结点总数 $= 2^h - 1$；
|
||||
- （TODO）
|
||||
|
||||
## 完全二叉树
|
||||
|
||||
「完全二叉树 Complete Binary Tree」只有最底层的结点未被填满，且最底层结点都尽量靠左填充。
|
||||
|
||||
|
||||
|
||||
完全二叉树有一个很好的性质，可以用「数组」来表示。
|
||||
|
||||
- （TODO）
|
||||
|
||||
## 完满二叉树
|
||||
|
||||
「完满二叉树 Full Binary Tree」除了叶结点之外，其余所有结点都有两个子结点。
|
||||
|
||||
|
||||
|
||||
## 平衡二叉树
|
||||
|
||||
**「平衡二叉树 Balanced Binary Tree」** ，其任意结点的左子树和右子树的高度之差的绝对值 $\leq 1$ 。
|
||||
|
||||
|
||||
|
||||
- （TODO）
|
||||
@@ -3,3 +3,16 @@ comments: true
|
||||
---
|
||||
|
||||
# 小结
|
||||
|
||||
- 二叉树是一种非线性数据结构，代表着“一分为二”的分治逻辑。二叉树的结点包含「值」和两个「指针」，分别指向左子结点和右子结点。
|
||||
- 选定二叉树中某结点，将其左（右）子结点以下形成的树称为左（右）子树。
|
||||
- 二叉树的术语较多，包括根结点、叶结点、层、度、边、高度、深度等。
|
||||
- 二叉树的初始化、结点插入、结点删除操作与链表的操作方法类似。
|
||||
- 常见的二叉树类型包括完美二叉树、完全二叉树、完满二叉树、平衡二叉树。完美二叉树是理想状态，链表则是退化后的最差状态。
|
||||
- 二叉树可以使用数组表示，具体做法是将结点值和空位按照层序遍历的顺序排列，并基于父结点和子结点之间的索引映射公式实现指针。
|
||||
|
||||
- 二叉树层序遍历是一种广度优先搜索，体现着“一圈一圈向外”的层进式遍历方式，通常借助队列来实现。
|
||||
- 前序、中序、后序遍历是深度优先搜索，体现着“走到头、再回头继续”的回溯遍历方式，通常使用递归实现。
|
||||
- 二叉搜索树是一种高效的元素查找数据结构，查找、插入、删除操作的时间复杂度皆为 $O(\log n)$ 。二叉搜索树退化为链表后，各项时间复杂度劣化至 $O(n)$ ，因此如何避免退化是非常重要的课题。
|
||||
- AVL 树又称平衡二叉搜索树，其通过旋转操作，使得在不断插入与删除结点后，仍然可以保持二叉树的平衡（不退化）。
|
||||
- AVL 树的旋转操作分为右旋、左旋、先右旋后左旋、先左旋后右旋。在插入或删除结点后，AVL 树会从底置顶地执行旋转操作，使树恢复平衡。
|
||||
|
||||
@@ -51,12 +51,12 @@ hide:
|
||||
|
||||
!!! quote ""
|
||||
|
||||
<p align="center"> “追风赶月莫停留，平芜尽处是春山“ </p>
|
||||
<p align="center"> “追风赶月莫停留，平芜尽处是春山” </p>
|
||||
<p align="center"> 一起加油！ </p>
|
||||
|
||||
---
|
||||
|
||||
## 推荐语
|
||||
<h2 align="center"> 推荐语 </h2>
|
||||
|
||||
!!! quote
|
||||
|
||||
@@ -64,7 +64,7 @@ hide:
|
||||
|
||||
**—— 邓俊辉，清华大学计算机系教授**
|
||||
|
||||
## 致谢
|
||||
<h2 align="center"> 致谢 </h2>
|
||||
|
||||
感谢本开源书的每一位撰稿人，是他们的无私奉献让这本书变得更好，他们是：
|
||||
|
||||
|
||||
Reference in New Issue
Block a user