algorithm/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2025-07-04 20:31:59 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add build script for JS and TS codes.

Browse Source
This commit is contained in:
krahets
2023-02-08 19:45:06 +08:00
parent 22b7d65d20
commit 05f0054005
28 changed files with 227 additions and 2217 deletions
Download Patch File Download Diff File Expand all files Collapse all files

144
docs/chapter_computational_complexity/space_complexity.md
View File

@ -623,43 +623,13 @@ $$
=== "JavaScript"
```javascript title="space_complexity.js"
/* 常数阶 */
function constant(n) {
// 常量、变量、对象占用 O(1) 空间
const a = 0;
const b = 0;
const nums = new Array(10000);
const node = new ListNode(0);
// 循环中的变量占用 O(1) 空间
for (let i = 0; i < n; i++) {
const c = 0;
}
// 循环中的函数占用 O(1) 空间
for (let i = 0; i < n; i++) {
constFunc();
}
}
[class]{}-[func]{constant}
```
=== "TypeScript"
```typescript title="space_complexity.ts"
/* 常数阶 */
function constant(n: number): void {
// 常量、变量、对象占用 O(1) 空间
const a = 0;
const b = 0;
const nums = new Array(10000);
const node = new ListNode(0);
// 循环中的变量占用 O(1) 空间
for (let i = 0; i < n; i++) {
const c = 0;
}
// 循环中的函数占用 O(1) 空间
for (let i = 0; i < n; i++) {
constFunc();
}
}
[class]{}-[func]{constant}
```
=== "C"
@ -786,41 +756,13 @@ $$
=== "JavaScript"
```javascript title="space_complexity.js"
/* 线性阶 */
function linear(n) {
// 长度为 n 的数组占用 O(n) 空间
const nums = new Array(n);
// 长度为 n 的列表占用 O(n) 空间
const nodes = [];
for (let i = 0; i < n; i++) {
nodes.push(new ListNode(i));
}
// 长度为 n 的哈希表占用 O(n) 空间
const map = new Map();
for (let i = 0; i < n; i++) {
map.set(i, i.toString());
}
}
[class]{}-[func]{linear}
```
=== "TypeScript"
```typescript title="space_complexity.ts"
/* 线性阶 */
function linear(n: number): void {
// 长度为 n 的数组占用 O(n) 空间
const nums = new Array(n);
// 长度为 n 的列表占用 O(n) 空间
const nodes: ListNode[] = [];
for (let i = 0; i < n; i++) {
nodes.push(new ListNode(i));
}
// 长度为 n 的哈希表占用 O(n) 空间
const map = new Map();
for (let i = 0; i < n; i++) {
map.set(i, i.toString());
}
}
[class]{}-[func]{linear}
```
=== "C"
@ -929,23 +871,13 @@ $$
=== "JavaScript"
```javascript title="space_complexity.js"
/* 线性阶（递归实现） */
function linearRecur(n) {
console.log(`递归 n = ${n}`);
if (n === 1) return;
linearRecur(n - 1);
}
[class]{}-[func]{linearRecur}
```
=== "TypeScript"
```typescript title="space_complexity.ts"
/* 线性阶（递归实现） */
function linearRecur(n: number): void {
console.log(`递归 n = ${n}`);
if (n === 1) return;
linearRecur(n - 1);
}
[class]{}-[func]{linearRecur}
```
=== "C"
@ -1032,39 +964,13 @@ $$
=== "JavaScript"
```javascript title="space_complexity.js"
/* 平方阶 */
function quadratic(n) {
// 矩阵占用 O(n^2) 空间
const numMatrix = Array(n).fill(null).map(() => Array(n).fill(null));
// 二维列表占用 O(n^2) 空间
const numList = [];
for (let i = 0; i < n; i++) {
const tmp = [];
for (let j = 0; j < n; j++) {
tmp.push(0);
}
numList.push(tmp);
}
}
[class]{}-[func]{quadratic}
```
=== "TypeScript"
```typescript title="space_complexity.ts"
/* 平方阶 */
function quadratic(n: number): void {
// 矩阵占用 O(n^2) 空间
const numMatrix = Array(n).fill(null).map(() => Array(n).fill(null));
// 二维列表占用 O(n^2) 空间
const numList = [];
for (let i = 0; i < n; i++) {
const tmp = [];
for (let j = 0; j < n; j++) {
tmp.push(0);
}
numList.push(tmp);
}
}
[class]{}-[func]{quadratic}
```
=== "C"
@ -1163,25 +1069,13 @@ $$
=== "JavaScript"
```javascript title="space_complexity.js"
/* 平方阶（递归实现） */
function quadraticRecur(n) {
if (n <= 0) return 0;
const nums = new Array(n);
console.log(`递归 n = ${n} 中的 nums 长度 = ${nums.length}`);
return quadraticRecur(n - 1);
}
[class]{}-[func]{quadraticRecur}
```
=== "TypeScript"
```typescript title="space_complexity.ts"
/* 平方阶（递归实现） */
function quadraticRecur(n: number): number {
if (n <= 0) return 0;
const nums = new Array(n);
console.log(`递归 n = ${n} 中的 nums 长度 = ${nums.length}`);
return quadraticRecur(n - 1);
}
[class]{}-[func]{quadraticRecur}
```
=== "C"
@ -1273,27 +1167,13 @@ $$
=== "JavaScript"
```javascript title="space_complexity.js"
/* 指数阶（建立满二叉树） */
function buildTree(n) {
if (n === 0) return null;
const root = new TreeNode(0);
root.left = buildTree(n - 1);
root.right = buildTree(n - 1);
return root;
}
[class]{}-[func]{buildTree}
```
=== "TypeScript"
```typescript title="space_complexity.ts"
/* 指数阶（建立满二叉树） */
function buildTree(n: number): TreeNode | null {
if (n === 0) return null;
const root = new TreeNode(0);
root.left = buildTree(n - 1);
root.right = buildTree(n - 1);
return root;
}
[class]{}-[func]{buildTree}
```
=== "C"

67
docs/chapter_computational_complexity/space_time_tradeoff.md
View File

@ -33,19 +33,19 @@ comments: true
=== "Java"
```java title="leetcode_two_sum.java"
[class]{SolutionBruteForce}-[func]{}
[class]{leetcode_two_sum}-[func]{twoSumBruteForce}
```
=== "C++"
```cpp title="leetcode_two_sum.cpp"
[class]{SolutionBruteForce}-[func]{}
[class]{}-[func]{twoSumBruteForce}
```
=== "Python"
```python title="leetcode_two_sum.py"
[class]{SolutionBruteForce}-[func]{}
[class]{}-[func]{two_sum_brute_force}
```
=== "Go"
@ -68,35 +68,13 @@ comments: true
=== "JavaScript"
```javascript title="leetcode_two_sum.js"
function twoSumBruteForce(nums, target) {
const n = nums.length;
// 两层循环，时间复杂度 O(n^2)
for (let i = 0; i < n; i++) {
for (let j = i + 1; j < n; j++) {
if (nums[i] + nums[j] === target) {
return [i, j];
}
}
}
return [];
}
[class]{}-[func]{twoSumBruteForce}
```
=== "TypeScript"
```typescript title="leetcode_two_sum.ts"
function twoSumBruteForce(nums: number[], target: number): number[] {
const n = nums.length;
// 两层循环，时间复杂度 O(n^2)
for (let i = 0; i < n; i++) {
for (let j = i + 1; j < n; j++) {
if (nums[i] + nums[j] === target) {
return [i, j];
}
}
}
return [];
};
[class]{}-[func]{twoSumBruteForce}
```
=== "C"
@ -174,19 +152,19 @@ comments: true
=== "Java"
```java title="leetcode_two_sum.java"
[class]{SolutionHashMap}-[func]{}
[class]{leetcode_two_sum}-[func]{twoSumHashTable}
```
=== "C++"
```cpp title="leetcode_two_sum.cpp"
[class]{SolutionHashMap}-[func]{}
[class]{}-[func]{twoSumHashTable}
```
=== "Python"
```python title="leetcode_two_sum.py"
[class]{SolutionHashMap}-[func]{}
[class]{}-[func]{two_sum_hash_table}
```
=== "Go"
@ -209,38 +187,13 @@ comments: true
=== "JavaScript"
```javascript title="leetcode_two_sum.js"
function twoSumHashTable(nums, target) {
// 辅助哈希表，空间复杂度 O(n)
let m = {};
// 单层循环，时间复杂度 O(n)
for (let i = 0; i < nums.length; i++) {
if (m[nums[i]] !== undefined) {
return [m[nums[i]], i];
} else {
m[target - nums[i]] = i;
}
}
return [];
}
[class]{}-[func]{twoSumHashTable}
```
=== "TypeScript"
```typescript title="leetcode_two_sum.ts"
function twoSumHashTable(nums: number[], target: number): number[] {
// 辅助哈希表，空间复杂度 O(n)
let m: Map<number, number> = new Map();
// 单层循环，时间复杂度 O(n)
for (let i = 0; i < nums.length; i++) {
let index = m.get(nums[i]);
if (index !== undefined) {
return [index, i];
} else {
m.set(target - nums[i], i);
}
}
return [];
};
[class]{}-[func]{twoSumHashTable}
```
=== "C"

230
docs/chapter_computational_complexity/time_complexity.md
View File

@ -827,25 +827,13 @@ $$
=== "JavaScript"
```javascript title="time_complexity.js"
/* 常数阶 */
function constant(n) {
let count = 0;
const size = 100000;
for (let i = 0; i < size; i++) count++;
return count;
}
[class]{}-[func]{constant}
```
=== "TypeScript"
```typescript title="time_complexity.ts"
/* 常数阶 */
function constant(n: number): number {
let count = 0;
const size = 100000;
for (let i = 0; i < size; i++) count++;
return count;
}
[class]{}-[func]{constant}
```
=== "C"
@ -945,23 +933,13 @@ $$
=== "JavaScript"
```javascript title="time_complexity.js"
/* 线性阶 */
function linear(n) {
let count = 0;
for (let i = 0; i < n; i++) count++;
return count;
}
[class]{}-[func]{linear}
```
=== "TypeScript"
```typescript title="time_complexity.ts"
/* 线性阶 */
function linear(n: number): number {
let count = 0;
for (let i = 0; i < n; i++) count++;
return count;
}
[class]{}-[func]{linear}
```
=== "C"
@ -1058,29 +1036,13 @@ $$
=== "JavaScript"
```javascript title="time_complexity.js"
/* 线性阶（遍历数组） */
function arrayTraversal(nums) {
let count = 0;
// 循环次数与数组长度成正比
for (let i = 0; i < nums.length; i++) {
count++;
}
return count;
}
[class]{}-[func]{arrayTraversal}
```
=== "TypeScript"
```typescript title="time_complexity.ts"
/* 线性阶（遍历数组） */
function arrayTraversal(nums: number[]): number {
let count = 0;
// 循环次数与数组长度成正比
for (let i = 0; i < nums.length; i++) {
count++;
}
return count;
}
[class]{}-[func]{arrayTraversal}
```
=== "C"
@ -1182,33 +1144,13 @@ $$
=== "JavaScript"
```javascript title="time_complexity.js"
/* 平方阶 */
function quadratic(n) {
let count = 0;
// 循环次数与数组长度成平方关系
for (let i = 0; i < n; i++) {
for (let j = 0; j < n; j++) {
count++;
}
}
return count;
}
[class]{}-[func]{quadratic}
```
=== "TypeScript"
```typescript title="time_complexity.ts"
/* 平方阶 */
function quadratic(n: number): number {
let count = 0;
// 循环次数与数组长度成平方关系
for (let i = 0; i < n; i++) {
for (let j = 0; j < n; j++) {
count++;
}
}
return count;
}
[class]{}-[func]{quadratic}
```
=== "C"
@ -1334,47 +1276,13 @@ $$
=== "JavaScript"
```javascript title="time_complexity.js"
/* 平方阶（冒泡排序） */
function bubbleSort(nums) {
let count = 0; // 计数器
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
for (let i = nums.length - 1; i > 0; i--) {
// 内循环：冒泡操作
for (let j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j] 与 nums[j + 1]
let tmp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = tmp;
count += 3; // 元素交换包含 3 个单元操作
}
}
}
return count;
}
[class]{}-[func]{bubbleSort}
```
=== "TypeScript"
```typescript title="time_complexity.ts"
/* 平方阶（冒泡排序） */
function bubbleSort(nums: number[]): number {
let count = 0; // 计数器
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
for (let i = nums.length - 1; i > 0; i--) {
// 内循环：冒泡操作
for (let j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// 交换 nums[j] 与 nums[j + 1]
let tmp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = tmp;
count += 3; // 元素交换包含 3 个单元操作
}
}
}
return count;
}
[class]{}-[func]{bubbleSort}
```
=== "C"
@ -1525,40 +1433,13 @@ $$
=== "JavaScript"
```javascript title="time_complexity.js"
/* 指数阶（循环实现） */
function exponential(n) {
let count = 0,
base = 1;
// cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
for (let i = 0; i < n; i++) {
for (let j = 0; j < base; j++) {
count++;
}
base *= 2;
}
// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
return count;
}
[class]{}-[func]{exponential}
```
=== "TypeScript"
```typescript title="time_complexity.ts"
/* 指数阶（循环实现） */
function exponential(n: number): number {
let count = 0,
base = 1;
// cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
for (let i = 0; i < n; i++) {
for (let j = 0; j < base; j++) {
count++;
}
base *= 2;
}
// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
return count;
}
[class]{}-[func]{exponential}
```
=== "C"
@ -1680,22 +1561,13 @@ $$
=== "JavaScript"
```javascript title="time_complexity.js"
/* 指数阶（递归实现） */
function expRecur(n) {
if (n == 1) return 1;
return expRecur(n - 1) + expRecur(n - 1) + 1;
}
[class]{}-[func]{expRecur}
```
=== "TypeScript"
```typescript title="time_complexity.ts"
/* 指数阶（递归实现） */
function expRecur(n: number): number {
if (n == 1) return 1;
return expRecur(n - 1) + expRecur(n - 1) + 1;
}
[class]{}-[func]{expRecur}
```
=== "C"
@ -1784,29 +1656,13 @@ $$
=== "JavaScript"
```javascript title="time_complexity.js"
/* 对数阶（循环实现） */
function logarithmic(n) {
let count = 0;
while (n > 1) {
n = n / 2;
count++;
}
return count;
}
[class]{}-[func]{logarithmic}
```
=== "TypeScript"
```typescript title="time_complexity.ts"
/* 对数阶（循环实现） */
function logarithmic(n: number): number {
let count = 0;
while (n > 1) {
n = n / 2;
count++;
}
return count;
}
[class]{}-[func]{logarithmic}
```
=== "C"
@ -1910,21 +1766,13 @@ $$
=== "JavaScript"
```javascript title="time_complexity.js"
/* 对数阶（递归实现） */
function logRecur(n) {
if (n <= 1) return 0;
return logRecur(n / 2) + 1;
}
[class]{}-[func]{logRecur}
```
=== "TypeScript"
```typescript title="time_complexity.ts"
/* 对数阶（递归实现） */
function logRecur(n: number): number {
if (n <= 1) return 0;
return logRecur(n / 2) + 1;
}
[class]{}-[func]{logRecur}
```
=== "C"
@ -2015,29 +1863,13 @@ $$
=== "JavaScript"
```javascript title="time_complexity.js"
/* 线性对数阶 */
function linearLogRecur(n) {
if (n <= 1) return 1;
let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);
for (let i = 0; i < n; i++) {
count++;
}
return count;
}
[class]{}-[func]{linearLogRecur}
```
=== "TypeScript"
```typescript title="time_complexity.ts"
/* 线性对数阶 */
function linearLogRecur(n: number): number {
if (n <= 1) return 1;
let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);
for (let i = 0; i < n; i++) {
count++;
}
return count;
}
[class]{}-[func]{linearLogRecur}
```
=== "C"
@ -2157,31 +1989,13 @@ $$
=== "JavaScript"
```javascript title="time_complexity.js"
/* 阶乘阶（递归实现） */
function factorialRecur(n) {
if (n == 0) return 1;
let count = 0;
// 从 1 个分裂出 n 个
for (let i = 0; i < n; i++) {
count += factorialRecur(n - 1);
}
return count;
}
[class]{}-[func]{factorialRecur}
```
=== "TypeScript"
```typescript title="time_complexity.ts"
/* 阶乘阶（递归实现） */
function factorialRecur(n: number): number {
if (n == 0) return 1;
let count = 0;
// 从 1 个分裂出 n 个
for (let i = 0; i < n; i++) {
count += factorialRecur(n - 1);
}
return count;
}
[class]{}-[func]{factorialRecur}
```
=== "C"