Merge pull request #1543 from CyC2018/notes-heading

Update 算法 - 排序.md
This commit is contained in:
CyC2018
2026-11-06 06:29:42 +08:00
committed by GitHub
6 changed files with 28 additions and 28 deletions
+5 -5
View File
@@ -12,7 +12,7 @@
<!-- GFM-TOC -->
#### 正常实现
## 正常实现
```text
Input : [1,2,3,4,5]
@@ -37,11 +37,11 @@ public int binarySearch(int[] nums, int key) {
}
```
#### 时间复杂度
## 时间复杂度
二分查找也称为折半查找,每次都能将查找区间减半,这种折半特性的算法时间复杂度为 O(logN)。
#### m 计算
## m 计算
有两种计算中值 m 的方式:
@@ -50,14 +50,14 @@ public int binarySearch(int[] nums, int key) {
l + h 可能出现加法溢出,也就是说加法的结果大于整型能够表示的范围。但是 l 和 h 都不小于 0,因此 h - l 不会出现溢出问题。所以,最好使用第二种计算方法。
#### 未成功查找的返回值
## 未成功查找的返回值
循环退出时如果仍然没有查找到 key,那么表示查找失败。可以有两种返回值:
- -1:以一个错误码表示没有查找到 key;
- l:将 key 插入到 nums 中的正确位置。
#### 变种
## 变种
二分查找可以有很多变种,实现变种要注意边界值的判断。例如在一个有重复元素的数组中查找 key 的最左位置的实现如下:
+5 -5
View File
@@ -21,7 +21,7 @@
## 0. 原理
#### 基本原理
### 基本原理
0s 表示一串 0,1s 表示一串 1。
@@ -55,7 +55,7 @@ x ^ x = 0 x & x = x x | x = x
01111111
```
#### 位与运算技巧
### 位与运算技巧
n&(n-1) 去除 n 的位级表示中最低的那一位 1。n-1 把这一位 1 变成 0、它右边的 0 都变成 1,更高的位不变,因此相与后只去掉了这一位。例如对于二进制表示 10110100,减去 1 得到 10110011,这两个数相与得到 10110000。
@@ -77,7 +77,7 @@ n&(-n) 得到 n 的位级表示中最低的那一位 1。在补码中 -n=\~n+1
n-(n&(-n)) 则可以去除 n 的位级表示中最低的那一位 1,和 n&(n-1) 效果一样。
#### 移位运算
### 移位运算
\>\> n 为算术右移,相当于除以 2<sup>n</sup> 并向下取整,例如 -7 \>\> 2 = -2。
@@ -103,7 +103,7 @@ n-(n&(-n)) 则可以去除 n 的位级表示中最低的那一位 1,和 n&(n-1
11111111111111111111111111100100
```
#### mask 计算
### mask 计算
要获取 32 位全为 1 的 int,将 0 取反即可,\~0。
@@ -113,7 +113,7 @@ n-(n&(-n)) 则可以去除 n 的位级表示中最低的那一位 1,和 n&(n-1
要得到 1 到 i 位为 0 的 mask,只需将 1 到 i 位为 1 的 mask 取反,即 \~((1\<\<i)-1)。
#### Java 中的位操作
### Java 中的位操作
```java
static int Integer.bitCount(int i); // 统计 1 的数量
+3 -3
View File
@@ -847,7 +847,7 @@ public int knapsack(int W, int N, int[] weights, int[] values) {
}
```
#### 空间优化
### 空间优化
在程序实现时可以对 0-1 背包做优化。观察状态转移方程可以知道,前 i 件物品的状态仅与前 i-1 件物品的状态有关,因此可以将 dp 定义为一维数组,其中 dp[j] 既可以表示 dp[i-1][j] 也可以表示 dp[i][j]。此时,
@@ -870,7 +870,7 @@ public int knapsack(int W, int N, int[] weights, int[] values) {
}
```
#### 无法使用贪心算法的解释
### 无法使用贪心算法的解释
0-1 背包问题无法使用贪心算法来求解,也就是说不能按照先添加性价比最高的物品来达到最优,这是因为这种方式可能造成背包空间的浪费,从而无法达到最优。考虑下面的物品和一个容量为 5 的背包,如果先添加物品 0 再添加物品 1,那么只能存放的价值为 16,浪费了大小为 2 的空间。最优的方式是存放物品 1 和物品 2,价值为 22。
@@ -880,7 +880,7 @@ public int knapsack(int W, int N, int[] weights, int[] values) {
| 1 | 2 | 10 | 5 |
| 2 | 3 | 12 | 4 |
#### 变种
### 变种
- 完全背包:每种物品的数量无限,例如[找零钱的最少硬币数](#4-找零钱的最少硬币数);
- 多重背包:每种物品的数量有限制;
+5 -5
View File
@@ -307,15 +307,15 @@ private int partition(T[] nums, int l, int h) {
### 4. 算法改进
##### 4.1 切换到插入排序
#### 4.1 切换到插入排序
因为快速排序在小数组中也会递归调用自己,对于小数组,插入排序比快速排序的性能更好,因此在小数组中可以切换到插入排序。
##### 4.2 三数取中
#### 4.2 三数取中
最好的情况下是每次都能取数组的中位数作为切分元素,但是计算中位数的代价很高。一种折中方法是取 3 个元素,并将大小居中的元素作为切分元素。
##### 4.3 三向切分
#### 4.3 三向切分
对于有大量重复元素的数组,可以将数组切分为三部分,分别对应小于、等于和大于切分元素。
@@ -487,13 +487,13 @@ public T delMax() {
把最大元素和当前堆中数组的最后一个元素交换位置,并且不删除它,那么就可以得到一个从尾到头的递减序列,从正向来看就是一个递增序列,这就是堆排序。
##### 5.1 构建堆
#### 5.1 构建堆
无序数组建立堆最直接的方法是从左到右遍历数组进行上浮操作。一个更高效的方法是从右至左进行下沉操作,如果一个节点的两个子节点都已经是堆有序,那么进行下沉操作可以使得这个节点为根节点的堆有序。叶子节点不需要进行下沉操作,可以忽略叶子节点的元素,因此只需要遍历一半的元素即可。这种方法建堆是线性的:约 1/4 的节点最多下沉 1 层,1/8 的节点最多下沉 2 层……总层数不超过 N,每层比较 2 次,共少于 2N 次比较(10 万个随机元素约 18.8 万次,JDK 21 实测,见附录 A2)。
<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/c2ca8dd2-8d00-4a3e-bece-db7849ac9cfd.gif" width="210px"> </div><br>
##### 5.2 交换堆顶元素与最后一个元素
#### 5.2 交换堆顶元素与最后一个元素
交换之后需要进行下沉操作维持堆的有序状态。
+4 -4
View File
@@ -834,7 +834,7 @@ public class LinearProbingHashST<Key, Value> implements UnorderedST<Key, Value>
}
```
##### 3.1 查找
#### 3.1 查找
```java
public Value get(Key key) {
@@ -846,7 +846,7 @@ public Value get(Key key) {
}
```
##### 3.2 插入
#### 3.2 插入
```java
public void put(Key key, Value value) {
@@ -868,7 +868,7 @@ private void putInternal(Key key, Value value) {
}
```
##### 3.3 删除
#### 3.3 删除
删除操作应当将右侧所有相邻的键值对重新插入哈希表中。这是因为查找遇到空位就停止,直接把被删除的位置置空,会把一个聚簇切成两段,后半段中的键就再也找不到了。
@@ -903,7 +903,7 @@ public void delete(Key key) {
}
```
##### 3.4 调整数组大小
#### 3.4 调整数组大小
线性探测法的成本取决于连续条目的长度,连续条目也叫聚簇。当聚簇很长时,在查找和插入时也需要进行很多次探测。例如下图中 2\~4 位置就是一个聚簇。
@@ -164,13 +164,13 @@ Linux 的进程状态和僵尸进程、孤儿进程见 [Linux](Linux.md#进程
批处理系统没有太多的用户操作,在该系统中,调度算法目标是保证吞吐量和周转时间(从提交到终止的时间)。
##### 1.1 先来先服务(First-Come First-Served, FCFS)
#### 1.1 先来先服务(First-Come First-Served, FCFS)
非抢占式的调度算法,按照请求的顺序进行调度。
有利于长作业,但不利于短作业,因为短作业必须一直等待前面的长作业执行完毕才能执行,而长作业又需要执行很长时间,造成了短作业等待时间过长。
##### 1.2 短作业优先(Shortest Job First, SJF)
#### 1.2 短作业优先(Shortest Job First, SJF)
非抢占式的调度算法,按估计运行时间最短的顺序进行调度。
@@ -178,7 +178,7 @@ Linux 的进程状态和僵尸进程、孤儿进程见 [Linux](Linux.md#进程
例如 A、B、C 同时到达,分别需要运行 8、4、1 个单位时间:FCFS 按 A、B、C 执行,平均等待 (0 + 8 + 12) / 3 ≈ 6.7;SJF 按 C、B、A 执行,平均等待 (0 + 1 + 5) / 3 = 2。所有作业同时到达时,SJF 的平均等待时间最短。
##### 1.3 最短剩余时间优先(Shortest Remaining Time Next, SRTN)
#### 1.3 最短剩余时间优先(Shortest Remaining Time Next, SRTN)
最短作业优先的抢占式版本,按剩余运行时间的顺序进行调度。当一个新的作业到达时,其整个运行时间与当前进程的剩余时间作比较。如果新的进程需要的时间更少,则挂起当前进程,运行新的进程。否则新的进程等待。
@@ -186,7 +186,7 @@ Linux 的进程状态和僵尸进程、孤儿进程见 [Linux](Linux.md#进程
交互式系统有大量的用户交互操作,在该系统中调度算法的目标是快速地进行响应。
##### 2.1 时间片轮转
#### 2.1 时间片轮转
将所有就绪进程按 FCFS 的原则排成一个队列,每次调度时,把 CPU 时间分配给队首进程,该进程可以执行一个时间片。当时间片用完时,由计时器发出时钟中断,调度程序便停止该进程的执行,并将它送往就绪队列的末尾,同时继续把 CPU 时间分配给队首的进程。
@@ -197,13 +197,13 @@ Linux 的进程状态和僵尸进程、孤儿进程见 [Linux](Linux.md#进程
<div align="center"> <img src="pics/process-rr.png" width="740px"/> </div><br>
##### 2.2 优先级调度
#### 2.2 优先级调度
为每个进程分配一个优先级,按优先级进行调度。
为了防止低优先级的进程永远等不到调度,可以随着时间的推移增加等待进程的优先级。
##### 2.3 多级反馈队列
#### 2.3 多级反馈队列
一个进程需要执行 100 个时间片,如果采用时间片轮转调度算法,那么需要被调度 100 次。