github/hello-algo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

build

Browse Source
This commit is contained in:
krahets 2023-02-08 16:47:52 +08:00
parent 139e34bdb1
commit 7156a5f832
15 changed files with 367 additions and 208 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
chapter_array_and_linkedlist/array.md
View File

@ -313,6 +313,8 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
```javascript title="array.js" ```javascript title="array.js"
/* 扩展数组长度 */ /* 扩展数组长度 */
// 请注意，JavaScript 的 Array 是动态数组，可以直接扩展
// 为了方便学习，本函数将 Array 看作是长度不可变的数组
function extend(nums, enlarge) { function extend(nums, enlarge) {
// 初始化一个扩展长度后的数组 // 初始化一个扩展长度后的数组
const res = new Array(nums.length + enlarge).fill(0); const res = new Array(nums.length + enlarge).fill(0);
@ -329,6 +331,8 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
```typescript title="array.ts" ```typescript title="array.ts"
/* 扩展数组长度 */ /* 扩展数组长度 */
// 请注意，TypeScript 的 Array 是动态数组，可以直接扩展
// 为了方便学习，本函数将 Array 看作是长度不可变的数组
function extend(nums: number[], enlarge: number): number[] { function extend(nums: number[], enlarge: number): number[] {
// 初始化一个扩展长度后的数组 // 初始化一个扩展长度后的数组
const res = new Array(nums.length + enlarge).fill(0); const res = new Array(nums.length + enlarge).fill(0);
@ -502,7 +506,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
// 将 num 赋给 index 处元素 // 将 num 赋给 index 处元素
nums[index] = num; nums[index] = num;
} }
/* 删除索引 index 处元素 */ /* 删除索引 index 处元素 */
function remove(nums, index) { function remove(nums, index) {
// 把索引 index 之后的所有元素向前移动一位 // 把索引 index 之后的所有元素向前移动一位
@ -524,7 +528,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
// 将 num 赋给 index 处元素 // 将 num 赋给 index 处元素
nums[index] = num; nums[index] = num;
} }
/* 删除索引 index 处元素 */ /* 删除索引 index 处元素 */
function remove(nums: number[], index: number): void { function remove(nums: number[], index: number): void {
// 把索引 index 之后的所有元素向前移动一位 // 把索引 index 之后的所有元素向前移动一位
@ -705,7 +709,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
count++; count++;
} }
// 直接遍历数组 // 直接遍历数组
for(let num of nums){ for (let num of nums) {
count += 1; count += 1;
} }
} }

3
chapter_array_and_linkedlist/linked_list.md
View File

@ -587,8 +587,9 @@ comments: true
/* 访问链表中索引为 index 的结点 */ /* 访问链表中索引为 index 的结点 */
function access(head, index) { function access(head, index) {
for (let i = 0; i < index; i++) { for (let i = 0; i < index; i++) {
if (!head) if (!head) {
return null; return null;
}
head = head.next; head = head.next;
} }
return head; return head;

22
chapter_array_and_linkedlist/list.md
View File

@ -1195,6 +1195,17 @@ comments: true
// 更新列表容量 // 更新列表容量
this.#capacity = this.#nums.length; this.#capacity = this.#nums.length;
} }
/* 将列表转换为数组 */
toArray() {
let size = this.size();
// 仅转换有效长度范围内的列表元素
const nums = new Array(size);
for (let i = 0; i < size; i++) {
nums[i] = this.get(i);
}
return nums;
}
} }
``` ```
@ -1289,6 +1300,17 @@ comments: true
// 更新列表容量 // 更新列表容量
this._capacity = this.nums.length; this._capacity = this.nums.length;
} }
/* 将列表转换为数组 */
public toArray(): number[] {
let size = this.size();
// 仅转换有效长度范围内的列表元素
let nums = new Array(size);
for (let i = 0; i < size; i++) {
nums[i] = this.get(i);
}
return nums;
}
} }
``` ```

124
chapter_computational_complexity/space_time_tradeoff.md
View File

@ -34,18 +34,16 @@ comments: true
```java title="leetcode_two_sum.java" ```java title="leetcode_two_sum.java"
/* 方法一：暴力枚举 */ /* 方法一：暴力枚举 */
class SolutionBruteForce { int[] twoSumBruteForce(int[] nums, int target) {
public int[] twoSum(int[] nums, int target) { int size = nums.length;
int size = nums.length; // 两层循环，时间复杂度 O(n^2)
// 两层循环，时间复杂度 O(n^2) for (int i = 0; i < size - 1; i++) {
for (int i = 0; i < size - 1; i++) { for (int j = i + 1; j < size; j++) {
for (int j = i + 1; j < size; j++) { if (nums[i] + nums[j] == target)
if (nums[i] + nums[j] == target) return new int[] { i, j };
return new int[] { i, j };
}
} }
return new int[0];
} }
return new int[0];
} }
``` ```
@ -53,34 +51,30 @@ comments: true
```cpp title="leetcode_two_sum.cpp" ```cpp title="leetcode_two_sum.cpp"
/* 方法一：暴力枚举 */ /* 方法一：暴力枚举 */
class SolutionBruteForce { vector<int> twoSumBruteForce(vector<int>& nums, int target) {
public: int size = nums.size();
vector<int> twoSum(vector<int>& nums, int target) { // 两层循环，时间复杂度 O(n^2)
int size = nums.size(); for (int i = 0; i < size - 1; i++) {
// 两层循环，时间复杂度 O(n^2) for (int j = i + 1; j < size; j++) {
for (int i = 0; i < size - 1; i++) { if (nums[i] + nums[j] == target)
for (int j = i + 1; j < size; j++) { return { i, j };
if (nums[i] + nums[j] == target)
return { i, j };
}
} }
return {};
} }
}; return {};
}
``` ```
=== "Python" === "Python"
```python title="leetcode_two_sum.py" ```python title="leetcode_two_sum.py"
""" 方法一：暴力枚举 """ """ 方法一：暴力枚举 """
class SolutionBruteForce: def two_sum_brute_force(nums: List[int], target: int) -> List[int]:
def twoSum(self, nums: List[int], target: int) -> List[int]: # 两层循环，时间复杂度 O(n^2)
# 两层循环，时间复杂度 O(n^2) for i in range(len(nums) - 1):
for i in range(len(nums) - 1): for j in range(i + 1, len(nums)):
for j in range(i + 1, len(nums)): if nums[i] + nums[j] == target:
if nums[i] + nums[j] == target: return i, j
return i, j return []
return []
``` ```
=== "Go" === "Go"
@ -103,6 +97,7 @@ comments: true
=== "JavaScript" === "JavaScript"
```javascript title="leetcode_two_sum.js" ```javascript title="leetcode_two_sum.js"
/* 方法一：暴力枚举 */
function twoSumBruteForce(nums, target) { function twoSumBruteForce(nums, target) {
const n = nums.length; const n = nums.length;
// 两层循环，时间复杂度 O(n^2) // 两层循环，时间复杂度 O(n^2)
@ -120,6 +115,7 @@ comments: true
=== "TypeScript" === "TypeScript"
```typescript title="leetcode_two_sum.ts" ```typescript title="leetcode_two_sum.ts"
/* 方法一：暴力枚举 */
function twoSumBruteForce(nums: number[], target: number): number[] { function twoSumBruteForce(nums: number[], target: number): number[] {
const n = nums.length; const n = nums.length;
// 两层循环，时间复杂度 O(n^2) // 两层循环，时间复杂度 O(n^2)
@ -210,20 +206,18 @@ comments: true
```java title="leetcode_two_sum.java" ```java title="leetcode_two_sum.java"
/* 方法二：辅助哈希表 */ /* 方法二：辅助哈希表 */
class SolutionHashMap { int[] twoSumHashTable(int[] nums, int target) {
public int[] twoSum(int[] nums, int target) { int size = nums.length;
int size = nums.length; // 辅助哈希表，空间复杂度 O(n)
// 辅助哈希表，空间复杂度 O(n) Map<Integer, Integer> dic = new HashMap<>();
Map<Integer, Integer> dic = new HashMap<>(); // 单层循环，时间复杂度 O(n)
// 单层循环，时间复杂度 O(n) for (int i = 0; i < size; i++) {
for (int i = 0; i < size; i++) { if (dic.containsKey(target - nums[i])) {
if (dic.containsKey(target - nums[i])) { return new int[] { dic.get(target - nums[i]), i };
return new int[] { dic.get(target - nums[i]), i };
}
dic.put(nums[i], i);
} }
return new int[0]; dic.put(nums[i], i);
} }
return new int[0];
} }
``` ```
@ -231,38 +225,34 @@ comments: true
```cpp title="leetcode_two_sum.cpp" ```cpp title="leetcode_two_sum.cpp"
/* 方法二：辅助哈希表 */ /* 方法二：辅助哈希表 */
class SolutionHashMap { vector<int> twoSumHashTable(vector<int>& nums, int target) {
public: int size = nums.size();
vector<int> twoSum(vector<int>& nums, int target) { // 辅助哈希表，空间复杂度 O(n)
int size = nums.size(); unordered_map<int, int> dic;
// 辅助哈希表，空间复杂度 O(n) // 单层循环，时间复杂度 O(n)
unordered_map<int, int> dic; for (int i = 0; i < size; i++) {
// 单层循环，时间复杂度 O(n) if (dic.find(target - nums[i]) != dic.end()) {
for (int i = 0; i < size; i++) { return { dic[target - nums[i]], i };
if (dic.find(target - nums[i]) != dic.end()) {
return { dic[target - nums[i]], i };
}
dic.emplace(nums[i], i);
} }
return {}; dic.emplace(nums[i], i);
} }
}; return {};
}
``` ```
=== "Python" === "Python"
```python title="leetcode_two_sum.py" ```python title="leetcode_two_sum.py"
""" 方法二：辅助哈希表 """ """ 方法二：辅助哈希表 """
class SolutionHashMap: def two_sum_hash_table(nums: List[int], target: int) -> List[int]:
def twoSum(self, nums: List[int], target: int) -> List[int]: # 辅助哈希表，空间复杂度 O(n)
# 辅助哈希表，空间复杂度 O(n) dic = {}
dic = {} # 单层循环，时间复杂度 O(n)
# 单层循环，时间复杂度 O(n) for i in range(len(nums)):
for i in range(len(nums)): if target - nums[i] in dic:
if target - nums[i] in dic: return dic[target - nums[i]], i
return dic[target - nums[i]], i dic[nums[i]] = i
dic[nums[i]] = i return []
return []
``` ```
=== "Go" === "Go"
@ -285,6 +275,7 @@ comments: true
=== "JavaScript" === "JavaScript"
```javascript title="leetcode_two_sum.js" ```javascript title="leetcode_two_sum.js"
/* 方法二：辅助哈希表 */
function twoSumHashTable(nums, target) { function twoSumHashTable(nums, target) {
// 辅助哈希表，空间复杂度 O(n) // 辅助哈希表，空间复杂度 O(n)
let m = {}; let m = {};
@ -303,6 +294,7 @@ comments: true
=== "TypeScript" === "TypeScript"
```typescript title="leetcode_two_sum.ts" ```typescript title="leetcode_two_sum.ts"
/* 方法二：辅助哈希表 */
function twoSumHashTable(nums: number[], target: number): number[] { function twoSumHashTable(nums: number[], target: number): number[] {
// 辅助哈希表，空间复杂度 O(n) // 辅助哈希表，空间复杂度 O(n)
let m: Map<number, number> = new Map(); let m: Map<number, number> = new Map();

2
chapter_computational_complexity/time_complexity.md
View File

@ -1705,7 +1705,6 @@ $$
// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1 // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
return count; return count;
} }
``` ```
=== "TypeScript" === "TypeScript"
@ -1872,7 +1871,6 @@ $$
if (n == 1) return 1; if (n == 1) return 1;
return expRecur(n - 1) + expRecur(n - 1) + 1; return expRecur(n - 1) + expRecur(n - 1) + 1;
} }
``` ```
=== "C" === "C"

114
chapter_hashing/hash_map.md
View File

@ -731,7 +731,7 @@ $$
this.val = val; this.val = val;
} }
} }
/* 基于数组简易实现的哈希表 */ /* 基于数组简易实现的哈希表 */
class ArrayHashMap { class ArrayHashMap {
#bucket; #bucket;
@ -739,12 +739,12 @@ $$
// 初始化一个长度为 100 的桶（数组） // 初始化一个长度为 100 的桶（数组）
this.#bucket = new Array(100).fill(null); this.#bucket = new Array(100).fill(null);
} }
/* 哈希函数 */ /* 哈希函数 */
#hashFunc(key) { #hashFunc(key) {
return key % 100; return key % 100;
} }
/* 查询操作 */ /* 查询操作 */
get(key) { get(key) {
let index = this.#hashFunc(key); let index = this.#hashFunc(key);
@ -752,19 +752,61 @@ $$
if (entry === null) return null; if (entry === null) return null;
return entry.val; return entry.val;
} }
/* 添加操作 */ /* 添加操作 */
set(key, val) { set(key, val) {
let index = this.#hashFunc(key); let index = this.#hashFunc(key);
this.#bucket[index] = new Entry(key, val); this.#bucket[index] = new Entry(key, val);
} }
/* 删除操作 */ /* 删除操作 */
delete(key) { delete(key) {
let index = this.#hashFunc(key); let index = this.#hashFunc(key);
// 置为 null ，代表删除 // 置为 null ，代表删除
this.#bucket[index] = null; this.#bucket[index] = null;
} }
/* 获取所有键值对 */
entries() {
let arr = [];
for (let i = 0; i < this.#bucket.length; i++) {
if (this.#bucket[i]) {
arr.push(this.#bucket[i]);
}
}
return arr;
}
/* 获取所有键 */
keys() {
let arr = [];
for (let i = 0; i < this.#bucket.length; i++) {
if (this.#bucket[i]) {
arr.push(this.#bucket[i]?.key);
}
}
return arr;
}
/* 获取所有值 */
values() {
let arr = [];
for (let i = 0; i < this.#bucket.length; i++) {
if (this.#bucket[i]) {
arr.push(this.#bucket[i]?.val);
}
}
return arr;
}
/* 打印哈希表 */
print() {
let entrySet = this.entries();
for (const entry of entrySet) {
if (!entry) continue;
console.info(`${entry.key} -> ${entry.val}`);
}
}
} }
``` ```
@ -773,30 +815,30 @@ $$
```typescript title="array_hash_map.ts" ```typescript title="array_hash_map.ts"
/* 键值对 Number -> String */ /* 键值对 Number -> String */
class Entry { class Entry {
public key: number; public key: number;
public val: string; public val: string;
constructor(key: number, val: string) { constructor(key: number, val: string) {
this.key = key; this.key = key;
this.val = val; this.val = val;
} }
} }
/* 基于数组简易实现的哈希表 */ /* 基于数组简易实现的哈希表 */
class ArrayHashMap { class ArrayHashMap {
private readonly bucket: (Entry | null)[]; private readonly bucket: (Entry | null)[];
constructor() { constructor() {
// 初始化一个长度为 100 的桶（数组） // 初始化一个长度为 100 的桶（数组）
this.bucket = (new Array(100)).fill(null); this.bucket = (new Array(100)).fill(null);
} }
/* 哈希函数 */ /* 哈希函数 */
private hashFunc(key: number): number { private hashFunc(key: number): number {
return key % 100; return key % 100;
} }
/* 查询操作 */ /* 查询操作 */
public get(key: number): string | null { public get(key: number): string | null {
let index = this.hashFunc(key); let index = this.hashFunc(key);
@ -804,19 +846,61 @@ $$
if (entry === null) return null; if (entry === null) return null;
return entry.val; return entry.val;
} }
/* 添加操作 */ /* 添加操作 */
public set(key: number, val: string) { public set(key: number, val: string) {
let index = this.hashFunc(key); let index = this.hashFunc(key);
this.bucket[index] = new Entry(key, val); this.bucket[index] = new Entry(key, val);
} }
/* 删除操作 */ /* 删除操作 */
public delete(key: number) { public delete(key: number) {
let index = this.hashFunc(key); let index = this.hashFunc(key);
// 置为 null ，代表删除 // 置为 null ，代表删除
this.bucket[index] = 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;
}
/* 打印哈希表 */
public print() {
let entrySet = this.entries();
for (const entry of entrySet) {
if (!entry) continue;
console.info(`${entry.key} -> ${entry.val}`);
}
}
} }
``` ```

42
chapter_heap/heap.md
View File

@ -279,9 +279,6 @@ comments: true
=== "C++" === "C++"
```cpp title="my_heap.cpp" ```cpp title="my_heap.cpp"
// 使用动态数组，这样无需考虑扩容问题
vector<int> maxHeap;
/* 获取左子结点索引 */ /* 获取左子结点索引 */
int left(int i) { int left(int i) {
return 2 * i + 1; return 2 * i + 1;
@ -339,18 +336,6 @@ comments: true
=== "JavaScript" === "JavaScript"
```javascript title="my_heap.js" ```javascript title="my_heap.js"
#maxHeap;
/* 构造函数，建立空堆或根据输入列表建堆 */
constructor(nums) {
// 将列表元素原封不动添加进堆
this.#maxHeap = nums === undefined ? [] : [...nums];
// 堆化除叶结点以外的其他所有结点
for (let i = this.#parent(this.size() - 1); i >= 0; i--) {
this.#siftDown(i);
}
}
/* 获取左子结点索引 */ /* 获取左子结点索引 */
#left(i) { #left(i) {
return 2 * i + 1; return 2 * i + 1;
@ -370,29 +355,18 @@ comments: true
=== "TypeScript" === "TypeScript"
```typescript title="my_heap.ts" ```typescript title="my_heap.ts"
private maxHeap: number[];
/* 构造函数，建立空堆或根据输入列表建堆 */
constructor(nums?: number[]) {
// 将列表元素原封不动添加进堆
this.maxHeap = nums === undefined ? [] : [...nums];
// 堆化除叶结点以外的其他所有结点
for (let i = this.parent(this.size() - 1); i >= 0; i--) {
this.siftDown(i);
}
}
/* 获取左子结点索引 */ /* 获取左子结点索引 */
private left(i: number): number { left(i: number): number {
return 2 * i + 1; return 2 * i + 1;
} }
/* 获取右子结点索引 */ /* 获取右子结点索引 */
private right(i: number): number { right(i: number): number {
return 2 * i + 2; return 2 * i + 2;
} }
/* 获取父结点索引 */ /* 获取父结点索引 */
private parent(i: number): number { parent(i: number): number {
return Math.floor((i - 1) / 2); // 向下整除 return Math.floor((i - 1) / 2); // 向下整除
} }
``` ```
@ -491,7 +465,7 @@ comments: true
```typescript title="my_heap.ts" ```typescript title="my_heap.ts"
/* 访问堆顶元素 */ /* 访问堆顶元素 */
public peek(): number { peek(): number {
return this.maxHeap[0]; return this.maxHeap[0];
} }
``` ```
@ -667,7 +641,7 @@ comments: true
```typescript title="my_heap.ts" ```typescript title="my_heap.ts"
/* 元素入堆 */ /* 元素入堆 */
public push(val: number): void { push(val: number): void {
// 添加结点 // 添加结点
this.maxHeap.push(val); this.maxHeap.push(val);
// 从底至顶堆化 // 从底至顶堆化
@ -675,7 +649,7 @@ comments: true
} }
/* 从结点 i 开始，从底至顶堆化 */ /* 从结点 i 开始，从底至顶堆化 */
private siftUp(i: number): void { siftUp(i: number): void {
while (true) { while (true) {
// 获取结点 i 的父结点 // 获取结点 i 的父结点
const p = this.parent(i); const p = this.parent(i);
@ -944,7 +918,7 @@ comments: true
```typescript title="my_heap.ts" ```typescript title="my_heap.ts"
/* 元素出堆 */ /* 元素出堆 */
public poll(): number { poll(): number {
// 判空处理 // 判空处理
if (this.isEmpty()) throw new RangeError("Heap is empty."); if (this.isEmpty()) throw new RangeError("Heap is empty.");
// 交换根结点与最右叶结点（即交换首元素与尾元素） // 交换根结点与最右叶结点（即交换首元素与尾元素）
@ -958,7 +932,7 @@ comments: true
} }
/* 从结点 i 开始，从顶至底堆化 */ /* 从结点 i 开始，从顶至底堆化 */
private siftDown(i: number): void { siftDown(i: number): void {
while (true) { while (true) {
// 判断结点 i, l, r 中值最大的结点，记为 ma // 判断结点 i, l, r 中值最大的结点，记为 ma
const l = this.left(i), r = this.right(i); const l = this.left(i), r = this.right(i);

20
chapter_searching/binary_search.md
View File

@ -162,17 +162,17 @@ $$
```typescript title="binary_search.ts" ```typescript title="binary_search.ts"
/* 二分查找（双闭区间） */ /* 二分查找（双闭区间） */
const binarySearch = function (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 - i) / 2); // 计算中点索引 m const m = Math.floor(i + (j - i) / 2); // 计算中点索引 m
if (nums[m] < target) { // 此情况说明 target 在区间 [m+1, j] 中 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;
} }
} }
@ -356,17 +356,17 @@ $$
```typescript title="binary_search.ts" ```typescript title="binary_search.ts"
/* 二分查找（左闭右开） */ /* 二分查找（左闭右开） */
const binarySearch1 = function (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 - i) / 2); // 计算中点索引 m const m = Math.floor(i + (j - i) / 2); // 计算中点索引 m
if (nums[m] < target) { // 此情况说明 target 在区间 [m+1, j) 中 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;
} }
} }

1
chapter_searching/linear_search.md
View File

@ -88,7 +88,6 @@ comments: true
// 未找到目标元素，返回 -1 // 未找到目标元素，返回 -1
return -1; return -1;
} }
``` ```
=== "TypeScript" === "TypeScript"

4
chapter_sorting/bubble_sort.md
View File

@ -374,10 +374,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; // 此轮冒泡未交换任何元素，直接跳出
} }
} }
``` ```

4
chapter_sorting/insertion_sort.md
View File

@ -124,10 +124,10 @@ comments: true
let j = i - 1; let 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 赋值到正确位置
} }
} }
``` ```

86
chapter_sorting/quick_sort.md
View File

@ -139,7 +139,7 @@ comments: true
=== "JavaScript" === "JavaScript"
``` js title="quick_sort.js" ```javascript title="quick_sort.js"
/* 元素交换 */ /* 元素交换 */
function swap(nums, i, j) { function swap(nums, i, j) {
let tmp = nums[i]; let tmp = nums[i];
@ -349,14 +349,14 @@ comments: true
```javascript title="quick_sort.js" ```javascript title="quick_sort.js"
/* 快速排序 */ /* 快速排序 */
function quickSort(nums, left, right) { quickSort(nums, left, right) {
// 子数组长度为 1 时终止递归 // 子数组长度为 1 时终止递归
if (left >= right) return; if (left >= right) return;
// 哨兵划分 // 哨兵划分
const pivot = partition(nums, left, right); const pivot = this.partition(nums, left, right);
// 递归左子数组、右子数组 // 递归左子数组、右子数组
quickSort(nums, left, pivot - 1); this.quickSort(nums, left, pivot - 1);
quickSort(nums, pivot + 1, right); this.quickSort(nums, pivot + 1, right);
} }
``` ```
@ -364,16 +364,16 @@ comments: true
```typescript title="quick_sort.ts" ```typescript title="quick_sort.ts"
/* 快速排序 */ /* 快速排序 */
function quickSort(nums: number[], left: number, right: number): void { quickSort(nums: number[], left: number, right: number): void {
// 子数组长度为 1 时终止递归 // 子数组长度为 1 时终止递归
if (left >= right) { if (left >= right) {
return; return;
} }
// 哨兵划分 // 哨兵划分
const pivot = partition(nums, left, right); const pivot = this.partition(nums, left, right);
// 递归左子数组、右子数组 // 递归左子数组、右子数组
quickSort(nums, left, pivot - 1); this.quickSort(nums, left, pivot - 1);
quickSort(nums, pivot + 1, right); this.quickSort(nums, pivot + 1, right);
} }
``` ```
@ -585,25 +585,29 @@ comments: true
```javascript title="quick_sort.js" ```javascript title="quick_sort.js"
/* 选取三个元素的中位数 */ /* 选取三个元素的中位数 */
function medianThree(nums, left, mid, right) { medianThree(nums, left, mid, right) {
// 使用了异或操作来简化代码 // 使用了异或操作来简化代码
// 异或规则为 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])) if ((nums[left] < nums[mid]) ^ (nums[left] < nums[right])) return left;
return left; else if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right])) return mid;
else if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right])) else return right;
return mid;
else
return right;
} }
/* 哨兵划分（三数取中值） */ /* 哨兵划分（三数取中值） */
function partition(nums, left, right) { partition(nums, left, right) {
// 选取三个候选元素的中位数 // 选取三个候选元素的中位数
let med = medianThree(nums, left, Math.floor((left + right) / 2), right); let med = this.medianThree(nums, left, Math.floor((left + right) / 2), right);
// 将中位数交换至数组最左端 // 将中位数交换至数组最左端
swap(nums, left, med); this.swap(nums, left, med);
// 以 nums[left] 作为基准数 // 以 nums[left] 作为基准数
// 下同省略... let i = left, j = right;
while (i < j) {
while (i < j && nums[j] >= nums[left]) j--; // 从右向左找首个小于基准数的元素
while (i < j && nums[i] <= nums[left]) i++; // 从左向右找首个大于基准数的元素
this.swap(nums, i, j); // 交换这两个元素
}
this.swap(nums, i, left); // 将基准数交换至两子数组的分界线
return i; // 返回基准数的索引
} }
``` ```
@ -611,7 +615,7 @@ comments: true
```typescript title="quick_sort.ts" ```typescript title="quick_sort.ts"
/* 选取三个元素的中位数 */ /* 选取三个元素的中位数 */
function 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])) {
@ -624,13 +628,25 @@ comments: true
} }
/* 哨兵划分（三数取中值） */ /* 哨兵划分（三数取中值） */
function partition(nums: number[], left: number, right: number): number { partition(nums: number[], left: number, right: number): number {
// 选取三个候选元素的中位数 // 选取三个候选元素的中位数
let med = medianThree(nums, left, Math.floor((left + right) / 2), right); let med = this.medianThree(nums, left, Math.floor((left + right) / 2), right);
// 将中位数交换至数组最左端 // 将中位数交换至数组最左端
swap(nums, left, med); this.swap(nums, left, med);
// 以 nums[left] 作为基准数 // 以 nums[left] 作为基准数
// 下同省略... let i = left, j = right;
while (i < j) {
while (i < j && nums[j] >= nums[left]) {
j--; // 从右向左找首个小于基准数的元素
}
while (i < j && nums[i] <= nums[left]) {
i++; // 从左向右找首个大于基准数的元素
}
this.swap(nums, i, j); // 交换这两个元素
}
this.swap(nums, i, left); // 将基准数交换至两子数组的分界线
return i; // 返回基准数的索引
}
``` ```
=== "C" === "C"
@ -789,17 +805,17 @@ comments: true
```javascript title="quick_sort.js" ```javascript title="quick_sort.js"
/* 快速排序（尾递归优化） */ /* 快速排序（尾递归优化） */
function quickSort(nums, left, right) { quickSort(nums, left, right) {
// 子数组长度为 1 时终止 // 子数组长度为 1 时终止
while (left < right) { while (left < right) {
// 哨兵划分操作 // 哨兵划分操作
let pivot = partition(nums, left, right); let pivot = this.partition(nums, left, right);
// 对两个子数组中较短的那个执行快排 // 对两个子数组中较短的那个执行快排
if (pivot - left < right - pivot) { if (pivot - left < right - pivot) {
quickSort(nums, left, pivot - 1); // 递归排序左子数组 this.quickSort(nums, left, pivot - 1); // 递归排序左子数组
left = pivot + 1; // 剩余待排序区间为 [pivot + 1, right] left = pivot + 1; // 剩余待排序区间为 [pivot + 1, right]
} else { } else {
quickSort(nums, pivot + 1, right); // 递归排序右子数组 this.quickSort(nums, pivot + 1, right); // 递归排序右子数组
right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1] right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1]
} }
} }
@ -810,17 +826,17 @@ comments: true
```typescript title="quick_sort.ts" ```typescript title="quick_sort.ts"
/* 快速排序（尾递归优化） */ /* 快速排序（尾递归优化） */
function quickSort(nums: number[], left: number, right: number): void { quickSort(nums: number[], left: number, right: number): void {
// 子数组长度为 1 时终止 // 子数组长度为 1 时终止
while (left < right) { while (left < right) {
// 哨兵划分操作 // 哨兵划分操作
let pivot = partition(nums, left, right); let pivot = this.partition(nums, left, right);
// 对两个子数组中较短的那个执行快排 // 对两个子数组中较短的那个执行快排
if (pivot - left < right - pivot) { if (pivot - left < right - pivot) {
quickSort(nums, left, pivot - 1); // 递归排序左子数组 this.quickSort(nums, left, pivot - 1); // 递归排序左子数组
left = pivot + 1; // 剩余待排序区间为 [pivot + 1, right] left = pivot + 1; // 剩余待排序区间为 [pivot + 1, right]
} else { } else {
quickSort(nums, pivot + 1, right); // 递归排序右子数组 this.quickSort(nums, pivot + 1, right); // 递归排序右子数组
right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1] right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1]
} }
} }

54
chapter_stack_and_queue/queue.md
View File

@ -544,18 +544,22 @@ comments: true
#front; // 头结点 #front #front; // 头结点 #front
#rear; // 尾结点 #rear #rear; // 尾结点 #rear
#queSize = 0; #queSize = 0;
constructor() { constructor() {
this.#front = null; this.#front = null;
this.#rear = null; this.#rear = null;
} }
/* 获取队列的长度 */ /* 获取队列的长度 */
get size() { get size() {
return this.#queSize; return this.#queSize;
} }
/* 判断队列是否为空 */ /* 判断队列是否为空 */
isEmpty() { isEmpty() {
return this.size === 0; return this.size === 0;
} }
/* 入队 */ /* 入队 */
push(num) { push(num) {
// 尾结点后添加 num // 尾结点后添加 num
@ -571,6 +575,7 @@ comments: true
} }
this.#queSize++; this.#queSize++;
} }
/* 出队 */ /* 出队 */
poll() { poll() {
const num = this.peek(); const num = this.peek();
@ -579,12 +584,24 @@ comments: true
this.#queSize--; this.#queSize--;
return num; return num;
} }
/* 访问队首元素 */ /* 访问队首元素 */
peek() { peek() {
if (this.size === 0) if (this.size === 0)
throw new Error("队列为空"); throw new Error("队列为空");
return this.#front.val; return this.#front.val;
} }
/* 将链表转化为 Array 并返回 */
toArray() {
let node = this.#front;
const res = new Array(this.size);
for (let i = 0; i < res.length; i++) {
res[i] = node.val;
node = node.next;
}
return res;
}
} }
``` ```
@ -596,18 +613,22 @@ comments: true
private front: ListNode | null; // 头结点 front private front: ListNode | null; // 头结点 front
private rear: ListNode | null; // 尾结点 rear private rear: ListNode | null; // 尾结点 rear
private queSize: number = 0; private queSize: number = 0;
constructor() { constructor() {
this.front = null; this.front = null;
this.rear = null; this.rear = null;
} }
/* 获取队列的长度 */ /* 获取队列的长度 */
get size(): number { get size(): number {
return this.queSize; return this.queSize;
} }
/* 判断队列是否为空 */ /* 判断队列是否为空 */
isEmpty(): boolean { isEmpty(): boolean {
return this.size === 0; return this.size === 0;
} }
/* 入队 */ /* 入队 */
push(num: number): void { push(num: number): void {
// 尾结点后添加 num // 尾结点后添加 num
@ -623,6 +644,7 @@ comments: true
} }
this.queSize++; this.queSize++;
} }
/* 出队 */ /* 出队 */
poll(): number { poll(): number {
const num = this.peek(); const num = this.peek();
@ -633,12 +655,24 @@ comments: true
this.queSize--; this.queSize--;
return num; return num;
} }
/* 访问队首元素 */ /* 访问队首元素 */
peek(): number { peek(): number {
if (this.size === 0) if (this.size === 0)
throw new Error("队列为空"); throw new Error("队列为空");
return this.front!.val; return this.front!.val;
} }
/* 将链表转化为 Array 并返回 */
toArray(): number[] {
let node = this.front;
const res = new Array<number>(this.size);
for (let i = 0; i < res.length; i++) {
res[i] = node!.val;
node = node!.next;
}
return res;
}
} }
``` ```
@ -1126,6 +1160,16 @@ comments: true
throw new Error("队列为空"); throw new Error("队列为空");
return this.#nums[this.#front]; return this.#nums[this.#front];
} }
/* 返回 Array */
toArray() {
// 仅转换有效长度范围内的列表元素
const arr = new Array(this.size);
for (let i = 0, j = this.#front; i < this.size; i++, j++) {
arr[i] = this.#nums[j % this.capacity];
}
return arr;
}
} }
``` ```
@ -1187,6 +1231,16 @@ comments: true
throw new Error("队列为空"); throw new Error("队列为空");
return this.nums[this.front]; return this.nums[this.front];
} }
/* 返回 Array */
toArray(): number[] {
// 仅转换有效长度范围内的列表元素
const arr = new Array(this.size);
for (let i = 0, j = this.front; i < this.size; i++, j++) {
arr[i] = this.nums[j % this.capacity];
}
return arr;
}
} }
``` ```

70
chapter_stack_and_queue/stack.md
View File

@ -513,23 +513,23 @@ 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;
} }
/* 获取栈的长度 */ /* 获取栈的长度 */
get size() { get size() {
return this.#stkSize; return this.#stkSize;
} }
/* 判断栈是否为空 */ /* 判断栈是否为空 */
isEmpty() { isEmpty() {
return this.size == 0; return this.size == 0;
} }
/* 入栈 */ /* 入栈 */
push(num) { push(num) {
const node = new ListNode(num); const node = new ListNode(num);
@ -537,26 +537,22 @@ comments: true
this.#stackPeek = node; this.#stackPeek = node;
this.#stkSize++; this.#stkSize++;
} }
/* 出栈 */ /* 出栈 */
pop() { pop() {
const num = this.peek(); const num = this.peek();
if (!this.#stackPeek) {
throw new Error("栈为空！");
}
this.#stackPeek = this.#stackPeek.next; this.#stackPeek = this.#stackPeek.next;
this.#stkSize--; this.#stkSize--;
return num; return num;
} }
/* 访问栈顶元素 */ /* 访问栈顶元素 */
peek() { peek() {
if (!this.#stackPeek) { if (!this.#stackPeek)
throw new Error("栈为空！"); throw new Error("栈为空");
}
return this.#stackPeek.val; return this.#stackPeek.val;
} }
/* 将链表转化为 Array 并返回 */ /* 将链表转化为 Array 并返回 */
toArray() { toArray() {
let node = this.#stackPeek; let node = this.#stackPeek;
@ -576,22 +572,22 @@ comments: true
/* 基于链表实现的栈 */ /* 基于链表实现的栈 */
class LinkedListStack { class LinkedListStack {
private stackPeek: ListNode | null; // 将头结点作为栈顶 private stackPeek: ListNode | null; // 将头结点作为栈顶
private stkSize: number = 0; // 栈的长度 private stkSize: number = 0; // 栈的长度
constructor() { constructor() {
this.stackPeek = null; this.stackPeek = null;
} }
/* 获取栈的长度 */ /* 获取栈的长度 */
get size(): number { get size(): number {
return this.stkSize; return this.stkSize;
} }
/* 判断栈是否为空 */ /* 判断栈是否为空 */
isEmpty(): boolean { isEmpty(): boolean {
return this.size == 0; return this.size == 0;
} }
/* 入栈 */ /* 入栈 */
push(num: number): void { push(num: number): void {
const node = new ListNode(num); const node = new ListNode(num);
@ -599,26 +595,24 @@ comments: true
this.stackPeek = node; this.stackPeek = node;
this.stkSize++; this.stkSize++;
} }
/* 出栈 */ /* 出栈 */
pop(): number { pop(): number {
const num = this.peek(); const num = this.peek();
if (!this.stackPeek) { if (!this.stackPeek)
throw new Error("栈为空！"); throw new Error("栈为空");
}
this.stackPeek = this.stackPeek.next; this.stackPeek = this.stackPeek.next;
this.stkSize--; this.stkSize--;
return num; return num;
} }
/* 访问栈顶元素 */ /* 访问栈顶元素 */
peek(): number { peek(): number {
if (!this.stackPeek) { if (!this.stackPeek)
throw new Error("栈为空！"); throw new Error("栈为空");
}
return this.stackPeek.val; return this.stackPeek.val;
} }
/* 将链表转化为 Array 并返回 */ /* 将链表转化为 Array 并返回 */
toArray(): number[] { toArray(): number[] {
let node = this.stackPeek; let node = this.stackPeek;
@ -941,30 +935,40 @@ comments: true
constructor() { constructor() {
this.stack = []; this.stack = [];
} }
/* 获取栈的长度 */ /* 获取栈的长度 */
get size() { get size() {
return this.stack.length; return this.stack.length;
} }
/* 判断栈是否为空 */ /* 判断栈是否为空 */
empty() { empty() {
return this.stack.length === 0; return this.stack.length === 0;
} }
/* 入栈 */ /* 入栈 */
push(num) { push(num) {
this.stack.push(num); this.stack.push(num);
} }
/* 出栈 */ /* 出栈 */
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];
} }
/* 返回 Array */
toArray() {
return this.stack;
}
}; };
``` ```
@ -977,30 +981,40 @@ comments: true
constructor() { constructor() {
this.stack = []; this.stack = [];
} }
/* 获取栈的长度 */ /* 获取栈的长度 */
get size(): number { get size(): number {
return this.stack.length; return this.stack.length;
} }
/* 判断栈是否为空 */ /* 判断栈是否为空 */
empty(): boolean { empty(): boolean {
return this.stack.length === 0; return this.stack.length === 0;
} }
/* 入栈 */ /* 入栈 */
push(num: number): void { push(num: number): void {
this.stack.push(num); this.stack.push(num);
} }
/* 出栈 */ /* 出栈 */
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];
} }
/* 返回 Array */
toArray() {
return this.stack;
}
}; };
``` ```

19
chapter_tree/binary_tree_traversal.md
View File

@ -120,12 +120,13 @@ comments: true
// 初始化一个列表，用于保存遍历序列 // 初始化一个列表，用于保存遍历序列
let list = []; let 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) if (node.right)
queue.push(node.right); // 右子结点入队 queue.push(node.right); // 右子结点入队
} }
return list; return list;
} }
@ -368,14 +369,14 @@ comments: true
```javascript title="binary_tree_dfs.js" ```javascript title="binary_tree_dfs.js"
/* 前序遍历 */ /* 前序遍历 */
function preOrder(root){ function preOrder(root) {
if (root === null) return; if (root === null) return;
// 访问优先级：根结点 -> 左子树 -> 右子树 // 访问优先级：根结点 -> 左子树 -> 右子树
list.push(root.val); list.push(root.val);
preOrder(root.left); preOrder(root.left);
preOrder(root.right); preOrder(root.right);
} }
/* 中序遍历 */ /* 中序遍历 */
function inOrder(root) { function inOrder(root) {
if (root === null) return; if (root === null) return;
@ -384,7 +385,7 @@ comments: true
list.push(root.val); list.push(root.val);
inOrder(root.right); inOrder(root.right);
} }
/* 后序遍历 */ /* 后序遍历 */
function postOrder(root) { function postOrder(root) {
if (root === null) return; if (root === null) return;
@ -408,7 +409,7 @@ comments: true
preOrder(root.left); preOrder(root.left);
preOrder(root.right); preOrder(root.right);
} }
/* 中序遍历 */ /* 中序遍历 */
function inOrder(root: TreeNode | null): void { function inOrder(root: TreeNode | null): void {
if (root === null) { if (root === null) {
@ -419,7 +420,7 @@ comments: true
list.push(root.val); list.push(root.val);
inOrder(root.right); inOrder(root.right);
} }
/* 后序遍历 */ /* 后序遍历 */
function postOrder(root: TreeNode | null): void { function postOrder(root: TreeNode | null): void {
if (root === null) { if (root === null) {