xmengnet/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2024-12-27 14:46:28 +08:00
Code Issues Projects Releases Packages Wiki Activity Actions

build

Browse source
This commit is contained in:
krahets 2023-04-17 21:57:42 +08:00
parent b472215f0e
commit cf4a59e3d6
20 changed files with 247 additions and 198 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
chapter_array_and_linkedlist/linked_list.md
View file

@ -522,8 +522,7 @@ comments: true
```javascript title="linked_list.js" ```javascript title="linked_list.js"
/* 删除链表的节点 n0 之后的首个节点 */ /* 删除链表的节点 n0 之后的首个节点 */
function remove(n0) { function remove(n0) {
if (!n0.next) if (!n0.next) return;
return;
// n0 -> P -> n1 // n0 -> P -> n1
const P = n0.next; const P = n0.next;
const n1 = P.next; const n1 = P.next;

27
chapter_array_and_linkedlist/list.md
View file

@ -1143,15 +1143,13 @@ comments: true
/* 访问元素 */ /* 访问元素 */
get(index) { get(index) {
// 索引如果越界则抛出异常，下同 // 索引如果越界则抛出异常，下同
if (index < 0 || index >= this.#size) if (index < 0 || index >= this.#size) throw new Error('索引越界');
throw new Error('索引越界');
return this.#nums[index]; return this.#nums[index];
} }
/* 更新元素 */ /* 更新元素 */
set(index, num) { set(index, num) {
if (index < 0 || index >= this.#size) if (index < 0 || index >= this.#size) throw new Error('索引越界');
throw new Error('索引越界');
this.#nums[index] = num; this.#nums[index] = num;
} }
@ -1168,8 +1166,7 @@ comments: true
/* 中间插入元素 */ /* 中间插入元素 */
insert(index, num) { insert(index, num) {
if (index < 0 || index >= this.#size) if (index < 0 || index >= this.#size) throw new Error('索引越界');
throw new Error('索引越界');
// 元素数量超出容量时，触发扩容机制 // 元素数量超出容量时，触发扩容机制
if (this.#size === this.#capacity) { if (this.#size === this.#capacity) {
this.extendCapacity(); this.extendCapacity();
@ -1185,8 +1182,7 @@ comments: true
/* 删除元素 */ /* 删除元素 */
remove(index) { remove(index) {
if (index < 0 || index >= this.#size) if (index < 0 || index >= this.#size) throw new Error('索引越界');
throw new Error('索引越界');
let num = this.#nums[index]; let num = this.#nums[index];
// 将索引 index 之后的元素都向前移动一位 // 将索引 index 之后的元素都向前移动一位
for (let j = index; j < this.#size - 1; j++) { for (let j = index; j < this.#size - 1; j++) {
@ -1249,23 +1245,20 @@ comments: true
/* 访问元素 */ /* 访问元素 */
public get(index: number): number { public get(index: number): number {
// 索引如果越界则抛出异常，下同 // 索引如果越界则抛出异常，下同
if (index < 0 || index >= this._size) if (index < 0 || index >= this._size) throw new Error('索引越界');
throw new Error('索引越界');
return this.nums[index]; return this.nums[index];
} }
/* 更新元素 */ /* 更新元素 */
public set(index: number, num: number): void { public set(index: number, num: number): void {
if (index < 0 || index >= this._size) if (index < 0 || index >= this._size) throw new Error('索引越界');
throw new Error('索引越界');
this.nums[index] = num; this.nums[index] = num;
} }
/* 尾部添加元素 */ /* 尾部添加元素 */
public add(num: number): void { public add(num: number): void {
// 如果长度等于容量，则需要扩容 // 如果长度等于容量，则需要扩容
if (this._size === this._capacity) if (this._size === this._capacity) this.extendCapacity();
this.extendCapacity();
// 将新元素添加到列表尾部 // 将新元素添加到列表尾部
this.nums[this._size] = num; this.nums[this._size] = num;
this._size++; this._size++;
@ -1273,8 +1266,7 @@ comments: true
/* 中间插入元素 */ /* 中间插入元素 */
public insert(index: number, num: number): void { public insert(index: number, num: number): void {
if (index < 0 || index >= this._size) if (index < 0 || index >= this._size) throw new Error('索引越界');
throw new Error('索引越界');
// 元素数量超出容量时，触发扩容机制 // 元素数量超出容量时，触发扩容机制
if (this._size === this._capacity) { if (this._size === this._capacity) {
this.extendCapacity(); this.extendCapacity();
@ -1290,8 +1282,7 @@ comments: true
/* 删除元素 */ /* 删除元素 */
public remove(index: number): number { public remove(index: number): number {
if (index < 0 || index >= this._size) if (index < 0 || index >= this._size) throw new Error('索引越界');
throw new Error('索引越界');
let num = this.nums[index]; let num = this.nums[index];
// 将索引 index 之后的元素都向前移动一位 // 将索引 index 之后的元素都向前移动一位
for (let j = index; j < this._size - 1; j++) { for (let j = index; j < this._size - 1; j++) {

61
chapter_binary_search/binary_search.md
View file

@ -135,16 +135,19 @@ $$
/* 二分查找（双闭区间） */ /* 二分查找（双闭区间） */
function binarySearch(nums, target) { function binarySearch(nums, target) {
// 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素 // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
let i = 0, j = nums.length - 1; let i = 0,
j = nums.length - 1;
// 循环，当搜索区间为空时跳出（当 i > j 时为空） // 循环，当搜索区间为空时跳出（当 i > j 时为空）
while (i <= j) { while (i <= j) {
const m = parseInt((i + j) / 2); // 计算中点索引 m ，在 JS 中需使用 parseInt 函数取整 // 计算中点索引 m ，使用 parseInt() 向下取整
if (nums[m] < target) // 此情况说明 target 在区间 [m+1, j] 中 const m = parseInt((i + j) / 2);
if (nums[m] < target)
// 此情况说明 target 在区间 [m+1, j] 中
i = m + 1; i = m + 1;
else if (nums[m] > target) // 此情况说明 target 在区间 [i, m-1] 中 else if (nums[m] > target)
// 此情况说明 target 在区间 [i, m-1] 中
j = m - 1; j = m - 1;
else else return m; // 找到目标元素，返回其索引
return m; // 找到目标元素，返回其索引
} }
// 未找到目标元素，返回 -1 // 未找到目标元素，返回 -1
return -1; return -1;
@ -157,15 +160,20 @@ $$
/* 二分查找（双闭区间） */ /* 二分查找（双闭区间） */
function binarySearch(nums: number[], target: number): number { function binarySearch(nums: number[], target: number): number {
// 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素 // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
let i = 0, j = nums.length - 1; let i = 0,
j = nums.length - 1;
// 循环，当搜索区间为空时跳出（当 i > j 时为空） // 循环，当搜索区间为空时跳出（当 i > j 时为空）
while (i <= j) { while (i <= j) {
const m = Math.floor((i + j) / 2); // 计算中点索引 m // 计算中点索引 m
if (nums[m] < target) { // 此情况说明 target 在区间 [m+1, j] 中 const m = Math.floor((i + j) / 2);
if (nums[m] < target) {
// 此情况说明 target 在区间 [m+1, j] 中
i = m + 1; i = m + 1;
} else if (nums[m] > target) { // 此情况说明 target 在区间 [i, m-1] 中 } else if (nums[m] > target) {
// 此情况说明 target 在区间 [i, m-1] 中
j = m - 1; j = m - 1;
} else { // 找到目标元素，返回其索引 } else {
// 找到目标元素，返回其索引
return m; return m;
} }
} }
@ -431,16 +439,20 @@ $$
/* 二分查找（左闭右开） */ /* 二分查找（左闭右开） */
function binarySearch1(nums, target) { function binarySearch1(nums, target) {
// 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1 // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
let i = 0, j = nums.length; let i = 0,
j = nums.length;
// 循环，当搜索区间为空时跳出（当 i = j 时为空） // 循环，当搜索区间为空时跳出（当 i = j 时为空）
while (i < j) { while (i < j) {
const m = parseInt((i + j) / 2); // 计算中点索引 m ，在 JS 中需使用 parseInt 函数取整 // 计算中点索引 m ，使用 parseInt() 向下取整
if (nums[m] < target) // 此情况说明 target 在区间 [m+1, j) 中 const m = parseInt((i + j) / 2);
if (nums[m] < target)
// 此情况说明 target 在区间 [m+1, j) 中
i = m + 1; i = m + 1;
else if (nums[m] > target) // 此情况说明 target 在区间 [i, m) 中 else if (nums[m] > target)
// 此情况说明 target 在区间 [i, m) 中
j = m; j = m;
else // 找到目标元素，返回其索引 // 找到目标元素，返回其索引
return m; else return m;
} }
// 未找到目标元素，返回 -1 // 未找到目标元素，返回 -1
return -1; return -1;
@ -453,15 +465,20 @@ $$
/* 二分查找（左闭右开） */ /* 二分查找（左闭右开） */
function binarySearch1(nums: number[], target: number): number { function binarySearch1(nums: number[], target: number): number {
// 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1 // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
let i = 0, j = nums.length; let i = 0,
j = nums.length;
// 循环，当搜索区间为空时跳出（当 i = j 时为空） // 循环，当搜索区间为空时跳出（当 i = j 时为空）
while (i < j) { while (i < j) {
const m = Math.floor((i + j) / 2); // 计算中点索引 m // 计算中点索引 m
if (nums[m] < target) { // 此情况说明 target 在区间 [m+1, j) 中 const m = Math.floor((i + j) / 2);
if (nums[m] < target) {
// 此情况说明 target 在区间 [m+1, j) 中
i = m + 1; i = m + 1;
} else if (nums[m] > target) { // 此情况说明 target 在区间 [i, m) 中 } else if (nums[m] > target) {
// 此情况说明 target 在区间 [i, m) 中
j = m; j = m;
} else { // 找到目标元素，返回其索引 } else {
// 找到目标元素，返回其索引
return m; return m;
} }
} }

4
chapter_computational_complexity/space_complexity.md
View file

@ -1156,7 +1156,9 @@ $$
/* 平方阶 */ /* 平方阶 */
function quadratic(n) { function quadratic(n) {
// 矩阵占用 O(n^2) 空间 // 矩阵占用 O(n^2) 空间
const numMatrix = Array(n).fill(null).map(() => Array(n).fill(null)); const numMatrix = Array(n)
.fill(null)
.map(() => Array(n).fill(null));
// 二维列表占用 O(n^2) 空间 // 二维列表占用 O(n^2) 空间
const numList = []; const numList = [];
for (let i = 0; i < n; i++) { for (let i = 0; i < n; i++) {

62
chapter_graph/graph_operations.md
View file

@ -391,8 +391,8 @@ comments: true
```javascript title="graph_adjacency_matrix.js" ```javascript title="graph_adjacency_matrix.js"
/* 基于邻接矩阵实现的无向图类 */ /* 基于邻接矩阵实现的无向图类 */
class GraphAdjMat { class GraphAdjMat {
vertices; // 顶点列表，元素代表“顶点值”，索引代表“顶点索引” vertices; // 顶点列表，元素代表“顶点值”，索引代表“顶点索引”
adjMat; // 邻接矩阵，行列索引对应“顶点索引” adjMat; // 邻接矩阵，行列索引对应“顶点索引”
/* 构造函数 */ /* 构造函数 */
constructor(vertices, edges) { constructor(vertices, edges) {
@ -434,7 +434,7 @@ comments: true
/* 删除顶点 */ /* 删除顶点 */
removeVertex(index) { removeVertex(index) {
if (index >= this.size()) { if (index >= this.size()) {
throw new RangeError("Index Out Of Bounds Exception"); throw new RangeError('Index Out Of Bounds Exception');
} }
// 在顶点列表中移除索引 index 的顶点 // 在顶点列表中移除索引 index 的顶点
this.vertices.splice(index, 1); this.vertices.splice(index, 1);
@ -452,7 +452,7 @@ comments: true
addEdge(i, j) { addEdge(i, j) {
// 索引越界与相等处理 // 索引越界与相等处理
if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) { if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {
throw new RangeError("Index Out Of Bounds Exception"); throw new RangeError('Index Out Of Bounds Exception');
} }
// 在无向图中，邻接矩阵沿主对角线对称，即满足 (i, j) == (j, i) // 在无向图中，邻接矩阵沿主对角线对称，即满足 (i, j) == (j, i)
this.adjMat[i][j] = 1; this.adjMat[i][j] = 1;
@ -464,7 +464,7 @@ comments: true
removeEdge(i, j) { removeEdge(i, j) {
// 索引越界与相等处理 // 索引越界与相等处理
if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) { if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {
throw new RangeError("Index Out Of Bounds Exception"); throw new RangeError('Index Out Of Bounds Exception');
} }
this.adjMat[i][j] = 0; this.adjMat[i][j] = 0;
this.adjMat[j][i] = 0; this.adjMat[j][i] = 0;
@ -472,8 +472,8 @@ comments: true
/* 打印邻接矩阵 */ /* 打印邻接矩阵 */
print() { print() {
console.log("顶点列表 = ", this.vertices); console.log('顶点列表 = ', this.vertices);
console.log("邻接矩阵 =", this.adjMat); console.log('邻接矩阵 =', this.adjMat);
} }
} }
``` ```
@ -483,8 +483,8 @@ comments: true
```typescript title="graph_adjacency_matrix.ts" ```typescript title="graph_adjacency_matrix.ts"
/* 基于邻接矩阵实现的无向图类 */ /* 基于邻接矩阵实现的无向图类 */
class GraphAdjMat { class GraphAdjMat {
vertices: number[]; // 顶点列表，元素代表“顶点值”，索引代表“顶点索引” vertices: number[]; // 顶点列表，元素代表“顶点值”，索引代表“顶点索引”
adjMat: number[][]; // 邻接矩阵，行列索引对应“顶点索引” adjMat: number[][]; // 邻接矩阵，行列索引对应“顶点索引”
/* 构造函数 */ /* 构造函数 */
constructor(vertices: number[], edges: number[][]) { constructor(vertices: number[], edges: number[][]) {
@ -526,7 +526,7 @@ comments: true
/* 删除顶点 */ /* 删除顶点 */
removeVertex(index: number): void { removeVertex(index: number): void {
if (index >= this.size()) { if (index >= this.size()) {
throw new RangeError("Index Out Of Bounds Exception"); throw new RangeError('Index Out Of Bounds Exception');
} }
// 在顶点列表中移除索引 index 的顶点 // 在顶点列表中移除索引 index 的顶点
this.vertices.splice(index, 1); this.vertices.splice(index, 1);
@ -544,7 +544,7 @@ comments: true
addEdge(i: number, j: number): void { addEdge(i: number, j: number): void {
// 索引越界与相等处理 // 索引越界与相等处理
if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) { if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {
throw new RangeError("Index Out Of Bounds Exception"); throw new RangeError('Index Out Of Bounds Exception');
} }
// 在无向图中，邻接矩阵沿主对角线对称，即满足 (i, j) == (j, i) // 在无向图中，邻接矩阵沿主对角线对称，即满足 (i, j) == (j, i)
this.adjMat[i][j] = 1; this.adjMat[i][j] = 1;
@ -556,7 +556,7 @@ comments: true
removeEdge(i: number, j: number): void { removeEdge(i: number, j: number): void {
// 索引越界与相等处理 // 索引越界与相等处理
if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) { if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {
throw new RangeError("Index Out Of Bounds Exception"); throw new RangeError('Index Out Of Bounds Exception');
} }
this.adjMat[i][j] = 0; this.adjMat[i][j] = 0;
this.adjMat[j][i] = 0; this.adjMat[j][i] = 0;
@ -564,8 +564,8 @@ comments: true
/* 打印邻接矩阵 */ /* 打印邻接矩阵 */
print(): void { print(): void {
console.log("顶点列表 = ", this.vertices); console.log('顶点列表 = ', this.vertices);
console.log("邻接矩阵 =", this.adjMat); console.log('邻接矩阵 =', this.adjMat);
} }
} }
``` ```
@ -1145,8 +1145,12 @@ comments: true
/* 添加边 */ /* 添加边 */
addEdge(vet1, vet2) { addEdge(vet1, vet2) {
if (!this.adjList.has(vet1) || !this.adjList.has(vet2) || vet1 === vet2) { if (
throw new Error("Illegal Argument Exception"); !this.adjList.has(vet1) ||
!this.adjList.has(vet2) ||
vet1 === vet2
) {
throw new Error('Illegal Argument Exception');
} }
// 添加边 vet1 - vet2 // 添加边 vet1 - vet2
this.adjList.get(vet1).push(vet2); this.adjList.get(vet1).push(vet2);
@ -1155,8 +1159,12 @@ comments: true
/* 删除边 */ /* 删除边 */
removeEdge(vet1, vet2) { removeEdge(vet1, vet2) {
if (!this.adjList.has(vet1) || !this.adjList.has(vet2) || vet1 === vet2) { if (
throw new Error("Illegal Argument Exception"); !this.adjList.has(vet1) ||
!this.adjList.has(vet2) ||
vet1 === vet2
) {
throw new Error('Illegal Argument Exception');
} }
// 删除边 vet1 - vet2 // 删除边 vet1 - vet2
this.adjList.get(vet1).splice(this.adjList.get(vet1).indexOf(vet2), 1); this.adjList.get(vet1).splice(this.adjList.get(vet1).indexOf(vet2), 1);
@ -1173,7 +1181,7 @@ comments: true
/* 删除顶点 */ /* 删除顶点 */
removeVertex(vet) { removeVertex(vet) {
if (!this.adjList.has(vet)) { if (!this.adjList.has(vet)) {
throw new Error("Illegal Argument Exception"); throw new Error('Illegal Argument Exception');
} }
// 在邻接表中删除顶点 vet 对应的链表 // 在邻接表中删除顶点 vet 对应的链表
this.adjList.delete(vet); this.adjList.delete(vet);
@ -1188,13 +1196,13 @@ comments: true
/* 打印邻接表 */ /* 打印邻接表 */
print() { print() {
console.log("邻接表 ="); console.log('邻接表 =');
for (const [key, value] of this.adjList) { for (const [key, value] of this.adjList) {
const tmp = []; const tmp = [];
for (const vertex of value) { for (const vertex of value) {
tmp.push(vertex.val); tmp.push(vertex.val);
} }
console.log(key.val + ": " + tmp.join()); console.log(key.val + ': ' + tmp.join());
} }
} }
} }
@ -1226,7 +1234,11 @@ comments: true
/* 添加边 */ /* 添加边 */
addEdge(vet1: Vertex, vet2: Vertex): void { addEdge(vet1: Vertex, vet2: Vertex): void {
if (!this.adjList.has(vet1) || !this.adjList.has(vet2) || vet1 === vet2) { if (
!this.adjList.has(vet1) ||
!this.adjList.has(vet2) ||
vet1 === vet2
) {
throw new Error('Illegal Argument Exception'); throw new Error('Illegal Argument Exception');
} }
// 添加边 vet1 - vet2 // 添加边 vet1 - vet2
@ -1236,7 +1248,11 @@ comments: true
/* 删除边 */ /* 删除边 */
removeEdge(vet1: Vertex, vet2: Vertex): void { removeEdge(vet1: Vertex, vet2: Vertex): void {
if (!this.adjList.has(vet1) || !this.adjList.has(vet2) || vet1 === vet2) { if (
!this.adjList.has(vet1) ||
!this.adjList.has(vet2) ||
vet1 === vet2
) {
throw new Error('Illegal Argument Exception'); throw new Error('Illegal Argument Exception');
} }
// 删除边 vet1 - vet2 // 删除边 vet1 - vet2

21
chapter_graph/graph_traversal.md
View file

@ -167,15 +167,15 @@ BFS 通常借助「队列」来实现。队列具有“先入先出”的性质
const que = [startVet]; const que = [startVet];
// 以顶点 vet 为起点，循环直至访问完所有顶点 // 以顶点 vet 为起点，循环直至访问完所有顶点
while (que.length) { while (que.length) {
const vet = que.shift(); // 队首顶点出队 const vet = que.shift(); // 队首顶点出队
res.push(vet); // 记录访问顶点 res.push(vet); // 记录访问顶点
// 遍历该顶点的所有邻接顶点 // 遍历该顶点的所有邻接顶点
for (const adjVet of graph.adjList.get(vet) ?? []) { for (const adjVet of graph.adjList.get(vet) ?? []) {
if (visited.has(adjVet)) { if (visited.has(adjVet)) {
continue; // 跳过已被访问过的顶点 continue; // 跳过已被访问过的顶点
} }
que.push(adjVet); // 只入队未访问的顶点 que.push(adjVet); // 只入队未访问的顶点
visited.add(adjVet); // 标记该顶点已被访问 visited.add(adjVet); // 标记该顶点已被访问
} }
} }
// 返回顶点遍历序列 // 返回顶点遍历序列
@ -465,8 +465,8 @@ BFS 通常借助「队列」来实现。队列具有“先入先出”的性质
/* 深度优先遍历 DFS */ /* 深度优先遍历 DFS */
// 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点 // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
function dfs(graph, visited, res, vet) { function dfs(graph, visited, res, vet) {
res.push(vet); // 记录访问顶点 res.push(vet); // 记录访问顶点
visited.add(vet); // 标记该顶点已被访问 visited.add(vet); // 标记该顶点已被访问
// 遍历该顶点的所有邻接顶点 // 遍历该顶点的所有邻接顶点
for (const adjVet of graph.adjList.get(vet)) { for (const adjVet of graph.adjList.get(vet)) {
if (visited.has(adjVet)) { if (visited.has(adjVet)) {
@ -493,7 +493,12 @@ BFS 通常借助「队列」来实现。队列具有“先入先出”的性质
```typescript title="graph_dfs.ts" ```typescript title="graph_dfs.ts"
/* 深度优先遍历 DFS 辅助函数 */ /* 深度优先遍历 DFS 辅助函数 */
function dfs(graph: GraphAdjList, visited: Set<Vertex>, res: Vertex[], vet: Vertex): void { function dfs(
graph: GraphAdjList,
visited: Set<Vertex>,
res: Vertex[],
vet: Vertex
): void {
res.push(vet); // 记录访问顶点 res.push(vet); // 记录访问顶点
visited.add(vet); // 标记该顶点已被访问 visited.add(vet); // 标记该顶点已被访问
// 遍历该顶点的所有邻接顶点 // 遍历该顶点的所有邻接顶点

3
chapter_hashing/hash_map.md
View file

@ -882,12 +882,11 @@ $$
/* 基于数组简易实现的哈希表 */ /* 基于数组简易实现的哈希表 */
class ArrayHashMap { class ArrayHashMap {
private readonly buckets: (Entry | null)[]; private readonly buckets: (Entry | null)[];
constructor() { constructor() {
// 初始化数组，包含 100 个桶 // 初始化数组，包含 100 个桶
this.buckets = (new Array(100)).fill(null); this.buckets = new Array(100).fill(null);
} }
/* 哈希函数 */ /* 哈希函数 */

2
chapter_heap/heap.md
View file

@ -1079,7 +1079,7 @@ comments: true
/* 元素出堆 */ /* 元素出堆 */
pop() { pop() {
// 判空处理 // 判空处理
if (this.isEmpty()) throw new Error("堆为空"); if (this.isEmpty()) throw new Error('堆为空');
// 交换根节点与最右叶节点（即交换首元素与尾元素） // 交换根节点与最右叶节点（即交换首元素与尾元素）
this.#swap(0, this.size() - 1); this.#swap(0, this.size() - 1);
// 删除节点 // 删除节点

4
chapter_searching/replace_linear_by_hashing.md
View file

@ -118,7 +118,7 @@ comments: true
} }
} }
return []; return [];
}; }
``` ```
=== "C" === "C"
@ -302,7 +302,7 @@ comments: true
} }
} }
return []; return [];
}; }
``` ```
=== "C" === "C"

4
chapter_sorting/bubble_sort.md
View file

@ -345,10 +345,10 @@ comments: true
let tmp = nums[j]; let tmp = nums[j];
nums[j] = nums[j + 1]; nums[j] = nums[j + 1];
nums[j + 1] = tmp; nums[j + 1] = tmp;
flag = true; // 记录交换元素 flag = true; // 记录交换元素
} }
} }
if (!flag) break; // 此轮冒泡未交换任何元素，直接跳出 if (!flag) break; // 此轮冒泡未交换任何元素，直接跳出
} }
} }
``` ```

7
chapter_sorting/insertion_sort.md
View file

@ -102,13 +102,14 @@ comments: true
function insertionSort(nums) { function insertionSort(nums) {
// 外循环：base = nums[1], nums[2], ..., nums[n-1] // 外循环：base = nums[1], nums[2], ..., nums[n-1]
for (let i = 1; i < nums.length; i++) { for (let i = 1; i < nums.length; i++) {
let base = nums[i], j = i - 1; let base = nums[i],
j = i - 1;
// 内循环：将 base 插入到左边的正确位置 // 内循环：将 base 插入到左边的正确位置
while (j >= 0 && nums[j] > base) { while (j >= 0 && nums[j] > base) {
nums[j + 1] = nums[j]; // 1. 将 nums[j] 向右移动一位 nums[j + 1] = nums[j]; // 1. 将 nums[j] 向右移动一位
j--; j--;
} }
nums[j + 1] = base; // 2. 将 base 赋值到正确位置 nums[j + 1] = base; // 2. 将 base 赋值到正确位置
} }
} }
``` ```

36
chapter_sorting/merge_sort.md
View file

@ -250,21 +250,24 @@ comments: true
// 初始化辅助数组 // 初始化辅助数组
let tmp = nums.slice(left, right + 1); let tmp = nums.slice(left, right + 1);
// 左子数组的起始索引和结束索引 // 左子数组的起始索引和结束索引
let leftStart = left - left, leftEnd = mid - left; let leftStart = left - left,
leftEnd = mid - left;
// 右子数组的起始索引和结束索引 // 右子数组的起始索引和结束索引
let rightStart = mid + 1 - left, rightEnd = right - left; let rightStart = mid + 1 - left,
rightEnd = right - left;
// i, j 分别指向左子数组、右子数组的首元素 // i, j 分别指向左子数组、右子数组的首元素
let i = leftStart, j = rightStart; let i = leftStart,
j = rightStart;
// 通过覆盖原数组 nums 来合并左子数组和右子数组 // 通过覆盖原数组 nums 来合并左子数组和右子数组
for (let k = left; k <= right; k++) { for (let k = left; k <= right; k++) {
// 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
if (i > leftEnd) { if (i > leftEnd) {
// 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
nums[k] = tmp[j++]; nums[k] = tmp[j++];
// 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
} else if (j > rightEnd || tmp[i] <= tmp[j]) { } else if (j > rightEnd || tmp[i] <= tmp[j]) {
// 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
nums[k] = tmp[i++]; nums[k] = tmp[i++];
// 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
} else { } else {
// 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
nums[k] = tmp[j++]; nums[k] = tmp[j++];
} }
} }
@ -273,10 +276,10 @@ comments: true
/* 归并排序 */ /* 归并排序 */
function mergeSort(nums, left, right) { function mergeSort(nums, left, right) {
// 终止条件 // 终止条件
if (left >= right) return; // 当子数组长度为 1 时终止递归 if (left >= right) return; // 当子数组长度为 1 时终止递归
// 划分阶段 // 划分阶段
let mid = Math.floor((left + right) / 2); // 计算中点 let mid = Math.floor((left + right) / 2); // 计算中点
mergeSort(nums, left, mid); // 递归左子数组 mergeSort(nums, left, mid); // 递归左子数组
mergeSort(nums, mid + 1, right); // 递归右子数组 mergeSort(nums, mid + 1, right); // 递归右子数组
// 合并阶段 // 合并阶段
merge(nums, left, mid, right); merge(nums, left, mid, right);
@ -293,20 +296,23 @@ comments: true
// 初始化辅助数组 // 初始化辅助数组
let tmp = nums.slice(left, right + 1); let tmp = nums.slice(left, right + 1);
// 左子数组的起始索引和结束索引 // 左子数组的起始索引和结束索引
let leftStart = left - left, leftEnd = mid - left; let leftStart = left - left,
leftEnd = mid - left;
// 右子数组的起始索引和结束索引 // 右子数组的起始索引和结束索引
let rightStart = mid + 1 - left, rightEnd = right - left; let rightStart = mid + 1 - left,
rightEnd = right - left;
// i, j 分别指向左子数组、右子数组的首元素 // i, j 分别指向左子数组、右子数组的首元素
let i = leftStart, j = rightStart; let i = leftStart,
j = rightStart;
// 通过覆盖原数组 nums 来合并左子数组和右子数组 // 通过覆盖原数组 nums 来合并左子数组和右子数组
for (let k = left; k <= right; k++) { for (let k = left; k <= right; k++) {
// 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
if (i > leftEnd) { if (i > leftEnd) {
// 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
nums[k] = tmp[j++]; nums[k] = tmp[j++];
// 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++ // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
} else if (j > rightEnd || tmp[i] <= tmp[j]) { } else if (j > rightEnd || tmp[i] <= tmp[j]) {
nums[k] = tmp[i++]; nums[k] = tmp[i++];
// 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++ // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
} else { } else {
nums[k] = tmp[j++]; nums[k] = tmp[j++];
} }

40
chapter_sorting/quick_sort.md
View file

@ -152,7 +152,8 @@ comments: true
/* 哨兵划分 */ /* 哨兵划分 */
partition(nums, left, right) { partition(nums, left, right) {
// 以 nums[left] 作为基准数 // 以 nums[left] 作为基准数
let i = left, j = right; let i = left,
j = right;
while (i < j) { while (i < j) {
while (i < j && nums[j] >= nums[left]) { while (i < j && nums[j] >= nums[left]) {
j -= 1; // 从右向左找首个小于基准数的元素 j -= 1; // 从右向左找首个小于基准数的元素
@ -181,7 +182,8 @@ comments: true
/* 哨兵划分 */ /* 哨兵划分 */
partition(nums: number[], left: number, right: number): number { partition(nums: number[], left: number, right: number): number {
// 以 nums[left] 作为基准数 // 以 nums[left] 作为基准数
let i = left, j = right; let i = left,
j = right;
while (i < j) { while (i < j) {
while (i < j && nums[j] >= nums[left]) { while (i < j && nums[j] >= nums[left]) {
j -= 1; // 从右向左找首个小于基准数的元素 j -= 1; // 从右向左找首个小于基准数的元素
@ -625,18 +627,25 @@ comments: true
// 此处使用异或运算来简化代码 // 此处使用异或运算来简化代码
// 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1 // 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1
if ((nums[left] < nums[mid]) ^ (nums[left] < nums[right])) return left; if ((nums[left] < nums[mid]) ^ (nums[left] < nums[right])) return left;
else if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right])) return mid; else if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right]))
return mid;
else return right; else return right;
} }
/* 哨兵划分（三数取中值） */ /* 哨兵划分（三数取中值） */
partition(nums, left, right) { partition(nums, left, right) {
// 选取三个候选元素的中位数 // 选取三个候选元素的中位数
let med = this.medianThree(nums, left, Math.floor((left + right) / 2), right); let med = this.medianThree(
nums,
left,
Math.floor((left + right) / 2),
right
);
// 将中位数交换至数组最左端 // 将中位数交换至数组最左端
this.swap(nums, left, med); this.swap(nums, left, med);
// 以 nums[left] 作为基准数 // 以 nums[left] 作为基准数
let i = left, j = right; let i = left,
j = right;
while (i < j) { while (i < j) {
while (i < j && nums[j] >= nums[left]) j--; // 从右向左找首个小于基准数的元素 while (i < j && nums[j] >= nums[left]) j--; // 从右向左找首个小于基准数的元素
while (i < j && nums[i] <= nums[left]) i++; // 从左向右找首个大于基准数的元素 while (i < j && nums[i] <= nums[left]) i++; // 从左向右找首个大于基准数的元素
@ -651,12 +660,19 @@ comments: true
```typescript title="quick_sort.ts" ```typescript title="quick_sort.ts"
/* 选取三个元素的中位数 */ /* 选取三个元素的中位数 */
medianThree(nums: number[], left: number, mid: number, right: number): number { medianThree(
nums: number[],
left: number,
mid: number,
right: number
): number {
// 此处使用异或运算来简化代码 // 此处使用异或运算来简化代码
// 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1 // 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1
if (Number(nums[left] < nums[mid]) ^ Number(nums[left] < nums[right])) { if (Number(nums[left] < nums[mid]) ^ Number(nums[left] < nums[right])) {
return left; return left;
} else if (Number(nums[mid] < nums[left]) ^ Number(nums[mid] < nums[right])) { } else if (
Number(nums[mid] < nums[left]) ^ Number(nums[mid] < nums[right])
) {
return mid; return mid;
} else { } else {
return right; return right;
@ -666,11 +682,17 @@ comments: true
/* 哨兵划分（三数取中值） */ /* 哨兵划分（三数取中值） */
partition(nums: number[], left: number, right: number): number { partition(nums: number[], left: number, right: number): number {
// 选取三个候选元素的中位数 // 选取三个候选元素的中位数
let med = this.medianThree(nums, left, Math.floor((left + right) / 2), right); let med = this.medianThree(
nums,
left,
Math.floor((left + right) / 2),
right
);
// 将中位数交换至数组最左端 // 将中位数交换至数组最左端
this.swap(nums, left, med); this.swap(nums, left, med);
// 以 nums[left] 作为基准数 // 以 nums[left] 作为基准数
let i = left, j = right; let i = left,
j = right;
while (i < j) { while (i < j) {
while (i < j && nums[j] >= nums[left]) { while (i < j && nums[j] >= nums[left]) {
j--; // 从右向左找首个小于基准数的元素 j--; // 从右向左找首个小于基准数的元素

12
chapter_sorting/radix_sort.md
View file

@ -253,7 +253,7 @@ $$
// 统计 0~9 各数字的出现次数 // 统计 0~9 各数字的出现次数
for (let i = 0; i < n; i++) { for (let i = 0; i < n; i++) {
const d = digit(nums[i], exp); // 获取 nums[i] 第 k 位，记为 d const d = digit(nums[i], exp); // 获取 nums[i] 第 k 位，记为 d
counter[d]++; // 统计数字 d 的出现次数 counter[d]++; // 统计数字 d 的出现次数
} }
// 求前缀和，将“出现个数”转换为“数组索引” // 求前缀和，将“出现个数”转换为“数组索引”
for (let i = 1; i < 10; i++) { for (let i = 1; i < 10; i++) {
@ -264,8 +264,8 @@ $$
for (let i = n - 1; i >= 0; i--) { for (let i = n - 1; i >= 0; i--) {
const d = digit(nums[i], exp); const d = digit(nums[i], exp);
const j = counter[d] - 1; // 获取 d 在数组中的索引 j const j = counter[d] - 1; // 获取 d 在数组中的索引 j
res[j] = nums[i]; // 将当前元素填入索引 j res[j] = nums[i]; // 将当前元素填入索引 j
counter[d]--; // 将 d 的数量减 1 counter[d]--; // 将 d 的数量减 1
} }
// 使用结果覆盖原数组 nums // 使用结果覆盖原数组 nums
for (let i = 0; i < n; i++) { for (let i = 0; i < n; i++) {
@ -310,7 +310,7 @@ $$
// 统计 0~9 各数字的出现次数 // 统计 0~9 各数字的出现次数
for (let i = 0; i < n; i++) { for (let i = 0; i < n; i++) {
const d = digit(nums[i], exp); // 获取 nums[i] 第 k 位，记为 d const d = digit(nums[i], exp); // 获取 nums[i] 第 k 位，记为 d
counter[d]++; // 统计数字 d 的出现次数 counter[d]++; // 统计数字 d 的出现次数
} }
// 求前缀和，将“出现个数”转换为“数组索引” // 求前缀和，将“出现个数”转换为“数组索引”
for (let i = 1; i < 10; i++) { for (let i = 1; i < 10; i++) {
@ -321,8 +321,8 @@ $$
for (let i = n - 1; i >= 0; i--) { for (let i = n - 1; i >= 0; i--) {
const d = digit(nums[i], exp); const d = digit(nums[i], exp);
const j = counter[d] - 1; // 获取 d 在数组中的索引 j const j = counter[d] - 1; // 获取 d 在数组中的索引 j
res[j] = nums[i]; // 将当前元素填入索引 j res[j] = nums[i]; // 将当前元素填入索引 j
counter[d]--; // 将 d 的数量减 1 counter[d]--; // 将 d 的数量减 1
} }
// 使用结果覆盖原数组 nums // 使用结果覆盖原数组 nums
for (let i = 0; i < n; i++) { for (let i = 0; i < n; i++) {

68
chapter_stack_and_queue/deque.md
View file

@ -784,9 +784,9 @@ comments: true
```javascript title="linkedlist_deque.js" ```javascript title="linkedlist_deque.js"
/* 双向链表节点 */ /* 双向链表节点 */
class ListNode { class ListNode {
prev; // 前驱节点引用 (指针) prev; // 前驱节点引用 (指针)
next; // 后继节点引用 (指针) next; // 后继节点引用 (指针)
val; // 节点值 val; // 节点值
constructor(val) { constructor(val) {
this.val = val; this.val = val;
@ -797,9 +797,9 @@ comments: true
/* 基于双向链表实现的双向队列 */ /* 基于双向链表实现的双向队列 */
class LinkedListDeque { class LinkedListDeque {
#front; // 头节点 front #front; // 头节点 front
#rear; // 尾节点 rear #rear; // 尾节点 rear
#queSize; // 双向队列的长度 #queSize; // 双向队列的长度
constructor() { constructor() {
this.#front = null; this.#front = null;
@ -851,7 +851,7 @@ comments: true
temp.next = null; temp.next = null;
this.#rear.prev = null; this.#rear.prev = null;
} }
this.#rear = temp; // 更新尾节点 this.#rear = temp; // 更新尾节点
this.#queSize--; this.#queSize--;
return value; return value;
} }
@ -868,7 +868,7 @@ comments: true
temp.prev = null; temp.prev = null;
this.#front.next = null; this.#front.next = null;
} }
this.#front = temp; // 更新头节点 this.#front = temp; // 更新头节点
this.#queSize--; this.#queSize--;
return value; return value;
} }
@ -901,7 +901,7 @@ comments: true
arr.push(temp.val); arr.push(temp.val);
temp = temp.next; temp = temp.next;
} }
console.log("[" + arr.join(", ") + "]"); console.log('[' + arr.join(', ') + ']');
} }
} }
``` ```
@ -911,9 +911,9 @@ comments: true
```typescript title="linkedlist_deque.ts" ```typescript title="linkedlist_deque.ts"
/* 双向链表节点 */ /* 双向链表节点 */
class ListNode { class ListNode {
prev: ListNode; // 前驱节点引用 (指针) prev: ListNode; // 前驱节点引用 (指针)
next: ListNode; // 后继节点引用 (指针) next: ListNode; // 后继节点引用 (指针)
val: number; // 节点值 val: number; // 节点值
constructor(val: number) { constructor(val: number) {
this.val = val; this.val = val;
@ -924,9 +924,9 @@ comments: true
/* 基于双向链表实现的双向队列 */ /* 基于双向链表实现的双向队列 */
class LinkedListDeque { class LinkedListDeque {
private front: ListNode; // 头节点 front private front: ListNode; // 头节点 front
private rear: ListNode; // 尾节点 rear private rear: ListNode; // 尾节点 rear
private queSize: number; // 双向队列的长度 private queSize: number; // 双向队列的长度
constructor() { constructor() {
this.front = null; this.front = null;
@ -978,7 +978,7 @@ comments: true
temp.next = null; temp.next = null;
this.rear.prev = null; this.rear.prev = null;
} }
this.rear = temp; // 更新尾节点 this.rear = temp; // 更新尾节点
this.queSize--; this.queSize--;
return value; return value;
} }
@ -995,7 +995,7 @@ comments: true
temp.prev = null; temp.prev = null;
this.front.next = null; this.front.next = null;
} }
this.front = temp; // 更新头节点 this.front = temp; // 更新头节点
this.queSize--; this.queSize--;
return value; return value;
} }
@ -1028,7 +1028,7 @@ comments: true
arr.push(temp.val); arr.push(temp.val);
temp = temp.next; temp = temp.next;
} }
console.log("[" + arr.join(", ") + "]"); console.log('[' + arr.join(', ') + ']');
} }
} }
``` ```
@ -1790,9 +1790,9 @@ comments: true
```javascript title="array_deque.js" ```javascript title="array_deque.js"
/* 基于环形数组实现的双向队列 */ /* 基于环形数组实现的双向队列 */
class ArrayDeque { class ArrayDeque {
#nums; // 用于存储双向队列元素的数组 #nums; // 用于存储双向队列元素的数组
#front; // 队首指针，指向队首元素 #front; // 队首指针，指向队首元素
#queSize; // 双向队列长度 #queSize; // 双向队列长度
/* 构造方法 */ /* 构造方法 */
constructor(capacity) { constructor(capacity) {
@ -1827,7 +1827,7 @@ comments: true
/* 队首入队 */ /* 队首入队 */
pushFirst(num) { pushFirst(num) {
if (this.#queSize === this.capacity()) { if (this.#queSize === this.capacity()) {
console.log("双向队列已满"); console.log('双向队列已满');
return; return;
} }
// 队首指针向左移动一位 // 队首指针向左移动一位
@ -1841,7 +1841,7 @@ comments: true
/* 队尾入队 */ /* 队尾入队 */
pushLast(num) { pushLast(num) {
if (this.#queSize === this.capacity()) { if (this.#queSize === this.capacity()) {
console.log("双向队列已满"); console.log('双向队列已满');
return; return;
} }
// 计算尾指针，指向队尾索引 + 1 // 计算尾指针，指向队尾索引 + 1
@ -1869,15 +1869,13 @@ comments: true
/* 访问队首元素 */ /* 访问队首元素 */
peekFirst() { peekFirst() {
if (this.isEmpty()) if (this.isEmpty()) throw new Error('The Deque Is Empty.');
throw new Error("The Deque Is Empty.");
return this.#nums[this.#front]; return this.#nums[this.#front];
} }
/* 访问队尾元素 */ /* 访问队尾元素 */
peekLast() { peekLast() {
if (this.isEmpty()) if (this.isEmpty()) throw new Error('The Deque Is Empty.');
throw new Error("The Deque Is Empty.");
// 计算尾元素索引 // 计算尾元素索引
const last = this.index(this.#front + this.#queSize - 1); const last = this.index(this.#front + this.#queSize - 1);
return this.#nums[last]; return this.#nums[last];
@ -1900,9 +1898,9 @@ comments: true
```typescript title="array_deque.ts" ```typescript title="array_deque.ts"
/* 基于环形数组实现的双向队列 */ /* 基于环形数组实现的双向队列 */
class ArrayDeque { class ArrayDeque {
private nums: number[]; // 用于存储双向队列元素的数组 private nums: number[]; // 用于存储双向队列元素的数组
private front: number; // 队首指针，指向队首元素 private front: number; // 队首指针，指向队首元素
private queSize: number; // 双向队列长度 private queSize: number; // 双向队列长度
/* 构造方法 */ /* 构造方法 */
constructor(capacity: number) { constructor(capacity: number) {
@ -1937,7 +1935,7 @@ comments: true
/* 队首入队 */ /* 队首入队 */
pushFirst(num: number): void { pushFirst(num: number): void {
if (this.queSize === this.capacity()) { if (this.queSize === this.capacity()) {
console.log("双向队列已满"); console.log('双向队列已满');
return; return;
} }
// 队首指针向左移动一位 // 队首指针向左移动一位
@ -1951,7 +1949,7 @@ comments: true
/* 队尾入队 */ /* 队尾入队 */
pushLast(num: number): void { pushLast(num: number): void {
if (this.queSize === this.capacity()) { if (this.queSize === this.capacity()) {
console.log("双向队列已满"); console.log('双向队列已满');
return; return;
} }
// 计算尾指针，指向队尾索引 + 1 // 计算尾指针，指向队尾索引 + 1
@ -1979,15 +1977,13 @@ comments: true
/* 访问队首元素 */ /* 访问队首元素 */
peekFirst(): number { peekFirst(): number {
if (this.isEmpty()) if (this.isEmpty()) throw new Error('The Deque Is Empty.');
throw new Error("The Deque Is Empty.");
return this.nums[this.front]; return this.nums[this.front];
} }
/* 访问队尾元素 */ /* 访问队尾元素 */
peekLast(): number { peekLast(): number {
if (this.isEmpty()) if (this.isEmpty()) throw new Error('The Deque Is Empty.');
throw new Error("The Deque Is Empty.");
// 计算尾元素索引 // 计算尾元素索引
const last = this.index(this.front + this.queSize - 1); const last = this.index(this.front + this.queSize - 1);
return this.nums[last]; return this.nums[last];

27
chapter_stack_and_queue/queue.md
View file

@ -544,8 +544,8 @@ comments: true
```javascript title="linkedlist_queue.js" ```javascript title="linkedlist_queue.js"
/* 基于链表实现的队列 */ /* 基于链表实现的队列 */
class LinkedListQueue { class LinkedListQueue {
#front; // 头节点 #front #front; // 头节点 #front
#rear; // 尾节点 #rear #rear; // 尾节点 #rear
#queSize = 0; #queSize = 0;
constructor() { constructor() {
@ -590,8 +590,7 @@ comments: true
/* 访问队首元素 */ /* 访问队首元素 */
peek() { peek() {
if (this.size === 0) if (this.size === 0) throw new Error('队列为空');
throw new Error("队列为空");
return this.#front.val; return this.#front.val;
} }
@ -1235,9 +1234,9 @@ comments: true
```javascript title="array_queue.js" ```javascript title="array_queue.js"
/* 基于环形数组实现的队列 */ /* 基于环形数组实现的队列 */
class ArrayQueue { class ArrayQueue {
#nums; // 用于存储队列元素的数组 #nums; // 用于存储队列元素的数组
#front = 0; // 队首指针，指向队首元素 #front = 0; // 队首指针，指向队首元素
#queSize = 0; // 队列长度 #queSize = 0; // 队列长度
constructor(capacity) { constructor(capacity) {
this.#nums = new Array(capacity); this.#nums = new Array(capacity);
@ -1261,7 +1260,7 @@ comments: true
/* 入队 */ /* 入队 */
push(num) { push(num) {
if (this.size == this.capacity) { if (this.size == this.capacity) {
console.log("队列已满"); console.log('队列已满');
return; return;
} }
// 计算尾指针，指向队尾索引 + 1 // 计算尾指针，指向队尾索引 + 1
@ -1283,8 +1282,7 @@ comments: true
/* 访问队首元素 */ /* 访问队首元素 */
peek() { peek() {
if (this.empty()) if (this.empty()) throw new Error('队列为空');
throw new Error("队列为空");
return this.#nums[this.#front]; return this.#nums[this.#front];
} }
@ -1305,8 +1303,8 @@ comments: true
```typescript title="array_queue.ts" ```typescript title="array_queue.ts"
/* 基于环形数组实现的队列 */ /* 基于环形数组实现的队列 */
class ArrayQueue { class ArrayQueue {
private nums: number[]; // 用于存储队列元素的数组 private nums: number[]; // 用于存储队列元素的数组
private front: number; // 队首指针，指向队首元素 private front: number; // 队首指针，指向队首元素
private queSize: number; // 队列长度 private queSize: number; // 队列长度
constructor(capacity: number) { constructor(capacity: number) {
@ -1332,7 +1330,7 @@ comments: true
/* 入队 */ /* 入队 */
push(num: number): void { push(num: number): void {
if (this.size == this.capacity) { if (this.size == this.capacity) {
console.log("队列已满"); console.log('队列已满');
return; return;
} }
// 计算尾指针，指向队尾索引 + 1 // 计算尾指针，指向队尾索引 + 1
@ -1354,8 +1352,7 @@ comments: true
/* 访问队首元素 */ /* 访问队首元素 */
peek(): number { peek(): number {
if (this.empty()) if (this.empty()) throw new Error('队列为空');
throw new Error("队列为空");
return this.nums[this.front]; return this.nums[this.front];
} }

23
chapter_stack_and_queue/stack.md
View file

@ -517,8 +517,8 @@ comments: true
```javascript title="linkedlist_stack.js" ```javascript title="linkedlist_stack.js"
/* 基于链表实现的栈 */ /* 基于链表实现的栈 */
class LinkedListStack { class LinkedListStack {
#stackPeek; // 将头节点作为栈顶 #stackPeek; // 将头节点作为栈顶
#stkSize = 0; // 栈的长度 #stkSize = 0; // 栈的长度
constructor() { constructor() {
this.#stackPeek = null; this.#stackPeek = null;
@ -552,8 +552,7 @@ comments: true
/* 访问栈顶元素 */ /* 访问栈顶元素 */
peek() { peek() {
if (!this.#stackPeek) if (!this.#stackPeek) throw new Error('栈为空');
throw new Error("栈为空");
return this.#stackPeek.val; return this.#stackPeek.val;
} }
@ -1068,15 +1067,13 @@ comments: true
/* 出栈 */ /* 出栈 */
pop() { pop() {
if (this.empty()) if (this.empty()) throw new Error('栈为空');
throw new Error("栈为空");
return this.#stack.pop(); return this.#stack.pop();
} }
/* 访问栈顶元素 */ /* 访问栈顶元素 */
top() { top() {
if (this.empty()) if (this.empty()) throw new Error('栈为空');
throw new Error("栈为空");
return this.#stack[this.#stack.length - 1]; return this.#stack[this.#stack.length - 1];
} }
@ -1084,7 +1081,7 @@ comments: true
toArray() { toArray() {
return this.#stack; return this.#stack;
} }
}; }
``` ```
=== "TypeScript" === "TypeScript"
@ -1114,15 +1111,13 @@ comments: true
/* 出栈 */ /* 出栈 */
pop(): number | undefined { pop(): number | undefined {
if (this.empty()) if (this.empty()) throw new Error('栈为空');
throw new Error('栈为空');
return this.stack.pop(); return this.stack.pop();
} }
/* 访问栈顶元素 */ /* 访问栈顶元素 */
top(): number | undefined { top(): number | undefined {
if (this.empty()) if (this.empty()) throw new Error('栈为空');
throw new Error('栈为空');
return this.stack[this.stack.length - 1]; return this.stack[this.stack.length - 1];
} }
@ -1130,7 +1125,7 @@ comments: true
toArray() { toArray() {
return this.stack; return this.stack;
} }
}; }
``` ```
=== "C" === "C"

12
chapter_tree/avl_tree.md
View file

@ -242,7 +242,8 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
/* 更新节点高度 */ /* 更新节点高度 */
#updateHeight(node) { #updateHeight(node) {
// 节点高度等于最高子树高度 + 1 // 节点高度等于最高子树高度 + 1
node.height = Math.max(this.height(node.left), this.height(node.right)) + 1; node.height =
Math.max(this.height(node.left), this.height(node.right)) + 1;
} }
``` ```
@ -258,7 +259,8 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
/* 更新节点高度 */ /* 更新节点高度 */
updateHeight(node: TreeNode): void { updateHeight(node: TreeNode): void {
// 节点高度等于最高子树高度 + 1 // 节点高度等于最高子树高度 + 1
node.height = Math.max(this.height(node.left), this.height(node.right)) + 1; node.height =
Math.max(this.height(node.left), this.height(node.right)) + 1;
} }
``` ```
@ -1315,7 +1317,8 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
if (node === null) return new TreeNode(val); if (node === null) return new TreeNode(val);
/* 1. 查找插入位置，并插入节点 */ /* 1. 查找插入位置，并插入节点 */
if (val < node.val) node.left = this.#insertHelper(node.left, val); if (val < node.val) node.left = this.#insertHelper(node.left, val);
else if (val > node.val) node.right = this.#insertHelper(node.right, val); else if (val > node.val)
node.right = this.#insertHelper(node.right, val);
else return node; // 重复节点不插入，直接返回 else return node; // 重复节点不插入，直接返回
this.#updateHeight(node); // 更新节点高度 this.#updateHeight(node); // 更新节点高度
/* 2. 执行旋转操作，使该子树重新恢复平衡 */ /* 2. 执行旋转操作，使该子树重新恢复平衡 */
@ -1649,7 +1652,8 @@ AVL 树的特点在于「旋转 Rotation」操作，它能够在不影响二叉
if (node === null) return null; if (node === null) return null;
/* 1. 查找节点，并删除之 */ /* 1. 查找节点，并删除之 */
if (val < node.val) node.left = this.#removeHelper(node.left, val); if (val < node.val) node.left = this.#removeHelper(node.left, val);
else if (val > node.val) node.right = this.#removeHelper(node.right, val); else if (val > node.val)
node.right = this.#removeHelper(node.right, val);
else { else {
if (node.left === null || node.right === null) { if (node.left === null || node.right === null) {
const child = node.left !== null ? node.left : node.right; const child = node.left !== null ? node.left : node.right;

6
chapter_tree/binary_search_tree.md
View file

@ -393,7 +393,8 @@ comments: true
function insert(num) { function insert(num) {
// 若树为空，直接提前返回 // 若树为空，直接提前返回
if (root === null) return; if (root === null) return;
let cur = root, pre = null; let cur = root,
pre = null;
// 循环查找，越过叶节点后跳出 // 循环查找，越过叶节点后跳出
while (cur !== null) { while (cur !== null) {
// 找到重复节点，直接返回 // 找到重复节点，直接返回
@ -808,7 +809,8 @@ comments: true
function remove(num) { function remove(num) {
// 若树为空，直接提前返回 // 若树为空，直接提前返回
if (root === null) return; if (root === null) return;
let cur = root, pre = null; let cur = root,
pre = null;
// 循环查找，越过叶节点后跳出 // 循环查找，越过叶节点后跳出
while (cur !== null) { while (cur !== null) {
// 找到待删除节点，跳出循环 // 找到待删除节点，跳出循环

11
chapter_tree/binary_tree_traversal.md
View file

@ -124,13 +124,10 @@ comments: true
// 初始化一个列表，用于保存遍历序列 // 初始化一个列表，用于保存遍历序列
const list = []; const list = [];
while (queue.length) { while (queue.length) {
let node = queue.shift(); // 队列出队 let node = queue.shift(); // 队列出队
list.push(node.val); // 保存节点值 list.push(node.val); // 保存节点值
if (node.left) if (node.left) queue.push(node.left); // 左子节点入队
queue.push(node.left); // 左子节点入队 if (node.right) queue.push(node.right); // 右子节点入队
if (node.right)
queue.push(node.right); // 右子节点入队
} }
return list; return list;
} }