yetao
/
hello-algo
mirror of https://github.com/krahets/hello-algo.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

build

Browse Source
docs
krahets 8 months ago
parent d5a7899137
commit 0a9daa8b9f
11 changed files with 689 additions and 101 deletions
Show Stats Download Patch File Download Diff File

2
docs/chapter_array_and_linkedlist/array.md
Unescape View File

@ -314,7 +314,7 @@ comments: true
### 随机访问元素 ###
def random_access(nums)
# 在区间 [0, nums.length) 中随机抽取一个数字
random_index = Random.rand 0...(nums.length - 1)
random_index = Random.rand(0...nums.length)
# 获取并返回随机元素
nums[random_index]

10
docs/chapter_array_and_linkedlist/linked_list.md
Unescape View File

@ -427,11 +427,11 @@ comments: true
```ruby title="linked_list.rb"
# 初始化链表 1 -> 3 -> 2 -> 5 -> 4
# 初始化各个节点
n0 = ListNode.new 1
n1 = ListNode.new 3
n2 = ListNode.new 2
n3 = ListNode.new 5
n4 = ListNode.new 4
n0 = ListNode.new(1)
n1 = ListNode.new(3)
n2 = ListNode.new(2)
n3 = ListNode.new(5)
n4 = ListNode.new(4)
# 构建节点之间的引用
n0.next = n1
n1.next = n2

10
docs/chapter_array_and_linkedlist/list.md
Unescape View File

@ -551,10 +551,10 @@ comments: true
nums << 4
# 在中间插入元素
nums.insert 3, 6 # 在索引 3 处插入数字 6
nums.insert(3, 6) # 在索引 3 处插入数字 6
# 删除元素
nums.delete_at 3 # 删除索引 3 处的元素
nums.delete_at(3) # 删除索引 3 处的元素
```
=== "Zig"
@ -2288,7 +2288,7 @@ comments: true
@capacity = 10
@size = 0
@extend_ratio = 2
@arr = Array.new capacity
@arr = Array.new(capacity)
end
### 访问元素 ###
@ -2360,9 +2360,9 @@ comments: true
def to_array
sz = size
# 仅转换有效长度范围内的列表元素
arr = Array.new sz
arr = Array.new(sz)
for i in 0...sz
arr[i] = get i
arr[i] = get(i)
end
arr
end

105
docs/chapter_computational_complexity/iteration_and_recursion.md
Unescape View File

@ -185,7 +185,17 @@ comments: true
=== "Ruby"
```ruby title="iteration.rb"
[class]{}-[func]{for_loop}
### for 循环 ###
def for_loop(n)
res = 0
# 循环求和 1, 2, ..., n-1, n
for i in 1..n
res += i
end
res
end
```
=== "Zig"
@ -417,7 +427,19 @@ comments: true
=== "Ruby"
```ruby title="iteration.rb"
[class]{}-[func]{while_loop}
### while 循环 ###
def while_loop(n)
res = 0
i = 1 # 初始化条件变量
# 循环求和 1, 2, ..., n-1, n
while i <= n
res += i
i += 1 # 更新条件变量
end
res
end
```
=== "Zig"
@ -664,7 +686,21 @@ comments: true
=== "Ruby"
```ruby title="iteration.rb"
[class]{}-[func]{while_loop_ii}
### while 循环（两次更新）###
def while_loop_ii(n)
res = 0
i = 1 # 初始化条件变量
# 循环求和 1, 4, 10, ...
while i <= n
res += i
# 更新条件变量
i += 1
i *= 2
end
res
end
```
=== "Zig"
@ -904,7 +940,20 @@ comments: true
=== "Ruby"
```ruby title="iteration.rb"
[class]{}-[func]{nested_for_loop}
### 双层 for 循环 ###
def nested_for_loop(n)
res = ""
# 循环 i = 1, 2, ..., n-1, n
for i in 1..n
# 循环 j = 1, 2, ..., n-1, n
for j in 1..n
res += "(#{i}, #{j}), "
end
end
res
end
```
=== "Zig"
@ -1139,7 +1188,15 @@ comments: true
=== "Ruby"
```ruby title="recursion.rb"
[class]{}-[func]{recur}
### 递归 ###
def recur(n)
# 终止条件
return 1 if n == 1
# 递：递归调用
res = recur(n - 1)
# 归：返回结果
n + res
end
```
=== "Zig"
@ -1362,7 +1419,13 @@ comments: true
=== "Ruby"
```ruby title="recursion.rb"
[class]{}-[func]{tail_recur}
### 尾递归 ###
def tail_recur(n, res)
# 终止条件
return res if n == 0
# 尾递归调用
tail_recur(n - 1, res + n)
end
```
=== "Zig"
@ -1594,7 +1657,15 @@ comments: true
=== "Ruby"
```ruby title="recursion.rb"
[class]{}-[func]{fib}
### 斐波那契数列：递归 ###
def fib(n)
# 终止条件 f(1) = 0, f(2) = 1
return n - 1 if n == 1 || n == 2
# 递归调用 f(n) = f(n-1) + f(n-2)
res = fib(n - 1) + fib(n - 2)
# 返回结果 f(n)
res
end
```
=== "Zig"
@ -1936,7 +2007,25 @@ comments: true
=== "Ruby"
```ruby title="recursion.rb"
[class]{}-[func]{for_loop_recur}
### 使用迭代模拟递归 ###
def for_loop_recur(n)
# 使用一个显式的栈来模拟系统调用栈
stack = []
res = 0
# 递：递归调用
for i in n.downto(0)
# 通过“入栈操作”模拟“递”
stack << i
end
# 归：返回结果
while !stack.empty?
res += stack.pop
end
# res = 1+2+3+...+n
res
end
```
=== "Zig"

152
docs/chapter_computational_complexity/space_complexity.md
Unescape View File

@ -341,7 +341,30 @@ comments: true
=== "Ruby"
```ruby title=""
### 类 ###
class Node
attr_accessor :val # 节点值
attr_accessor :next # 指向下一节点的引用
def initialize(x)
@val = x
end
end
### 函数 ###
def function
# 执行某些操作...
0
end
### 算法 ###
def algorithm(n) # 输入数据
a = 0 # 暂存数据（常量）
b = 0 # 暂存数据（变量）
node = Node.new(0) # 暂存数据（对象）
c = function # 栈帧空间（调用函数）
a + b + c # 输出数据
end
```
=== "Zig"
@ -505,7 +528,11 @@ comments: true
=== "Ruby"
```ruby title=""
def algorithm(n)
a = 0 # O(1)
b = Array.new(10000) # O(1)
nums = Array.new(n) if n > 10 # O(n)
end
```
=== "Zig"
@ -542,13 +569,13 @@ comments: true
// 执行某些操作
return 0;
}
/* 循环 O(1) */
/* 循环的空间复杂度为 O(1) */
void loop(int n) {
for (int i = 0; i < n; i++) {
func();
}
}
/* 递归 O(n) */
/* 递归的空间复杂度为 O(n) */
void recur(int n) {
if (n == 1) return;
return recur(n - 1);
@ -562,13 +589,13 @@ comments: true
// 执行某些操作
return 0;
}
/* 循环 O(1) */
/* 循环的空间复杂度为 O(1) */
void loop(int n) {
for (int i = 0; i < n; i++) {
function();
}
}
/* 递归 O(n) */
/* 递归的空间复杂度为 O(n) */
void recur(int n) {
if (n == 1) return;
return recur(n - 1);
@ -582,13 +609,13 @@ comments: true
// 执行某些操作
return 0;
}
/* 循环 O(1) */
/* 循环的空间复杂度为 O(1) */
void Loop(int n) {
for (int i = 0; i < n; i++) {
Function();
}
}
/* 递归 O(n) */
/* 递归的空间复杂度为 O(n) */
int Recur(int n) {
if (n == 1) return 1;
return Recur(n - 1);
@ -603,14 +630,14 @@ comments: true
return 0
}
/* 循环 O(1) */
/* 循环的空间复杂度为 O(1) */
func loop(n int) {
for i := 0; i < n; i++ {
function()
}
}
/* 递归 O(n) */
/* 递归的空间复杂度为 O(n) */
func recur(n int) {
if n == 1 {
return
@ -628,14 +655,14 @@ comments: true
return 0
}
/* 循环 O(1) */
/* 循环的空间复杂度为 O(1) */
func loop(n: Int) {
for _ in 0 ..< n {
function()
}
}
/* 递归 O(n) */
/* 递归的空间复杂度为 O(n) */
func recur(n: Int) {
if n == 1 {
return
@ -651,13 +678,13 @@ comments: true
// 执行某些操作
return 0;
}
/* 循环 O(1) */
/* 循环的空间复杂度为 O(1) */
function loop(n) {
for (let i = 0; i < n; i++) {
constFunc();
}
}
/* 递归 O(n) */
/* 递归的空间复杂度为 O(n) */
function recur(n) {
if (n === 1) return;
return recur(n - 1);
@ -671,13 +698,13 @@ comments: true
// 执行某些操作
return 0;
}
/* 循环 O(1) */
/* 循环的空间复杂度为 O(1) */
function loop(n: number): void {
for (let i = 0; i < n; i++) {
constFunc();
}
}
/* 递归 O(n) */
/* 递归的空间复杂度为 O(n) */
function recur(n: number): void {
if (n === 1) return;
return recur(n - 1);
@ -691,13 +718,13 @@ comments: true
// 执行某些操作
return 0;
}
/* 循环 O(1) */
/* 循环的空间复杂度为 O(1) */
void loop(int n) {
for (int i = 0; i < n; i++) {
function();
}
}
/* 递归 O(n) */
/* 递归的空间复杂度为 O(n) */
void recur(int n) {
if (n == 1) return;
return recur(n - 1);
@ -711,13 +738,13 @@ comments: true
// 执行某些操作
return 0;
}
/* 循环 O(1) */
/* 循环的空间复杂度为 O(1) */
fn loop(n: i32) {
for i in 0..n {
function();
}
}
/* 递归 O(n) */
/* 递归的空间复杂度为 O(n) */
fn recur(n: i32) {
if n == 1 {
return;
@ -733,13 +760,13 @@ comments: true
// 执行某些操作
return 0;
}
/* 循环 O(1) */
/* 循环的空间复杂度为 O(1) */
void loop(int n) {
for (int i = 0; i < n; i++) {
func();
}
}
/* 递归 O(n) */
/* 递归的空间复杂度为 O(n) */
void recur(int n) {
if (n == 1) return;
return recur(n - 1);
@ -753,13 +780,13 @@ comments: true
// 执行某些操作
return 0
}
/* 循环 O(1) */
/* 循环的空间复杂度为 O(1) */
fun loop(n: Int) {
for (i in 0..<n) {
function()
}
}
/* 递归 O(n) */
/* 递归的空间复杂度为 O(n) */
fun recur(n: Int) {
if (n == 1) return
return recur(n - 1)
@ -769,7 +796,21 @@ comments: true
=== "Ruby"
```ruby title=""
def function
# 执行某些操作
0
end
### 循环的空间复杂度为 O(1) ###
def loop(n)
(0...n).each { function }
end
### 递归的空间复杂度为 O(n) ###
def recur(n)
return if n == 1
recur(n - 1)
end
```
=== "Zig"
@ -1134,9 +1175,24 @@ $$
=== "Ruby"
```ruby title="space_complexity.rb"
[class]{}-[func]{function}
[class]{}-[func]{constant}
### 函数 ###
def function
# 执行某些操作
0
end
### 常数阶 ###
def constant(n)
# 常量、变量、对象占用 O(1) 空间
a = 0
nums = [0] * 10000
node = ListNode.new
# 循环中的变量占用 O(1) 空间
(0...n).each { c = 0 }
# 循环中的函数占用 O(1) 空间
(0...n).each { function }
end
```
=== "Zig"
@ -1438,7 +1494,17 @@ $$
=== "Ruby"
```ruby title="space_complexity.rb"
[class]{}-[func]{linear}
### 线性阶 ###
def linear(n)
# 长度为 n 的列表占用 O(n) 空间
nums = Array.new(n, 0)
# 长度为 n 的哈希表占用 O(n) 空间
hmap = {}
for i in 0...n
hmap[i] = i.to_s
end
end
```
=== "Zig"
@ -1620,7 +1686,12 @@ $$
=== "Ruby"
```ruby title="space_complexity.rb"
[class]{}-[func]{linear_recur}
### 线性阶（递归实现）###
def linear_recur(n)
puts "递归 n = #{n}"
return if n == 1
linear_recur(n - 1)
end
```
=== "Zig"
@ -1860,7 +1931,11 @@ $$
=== "Ruby"
```ruby title="space_complexity.rb"
[class]{}-[func]{quadratic}
### 平方阶 ###
def quadratic(n)
# 二维列表占用 O(n^2) 空间
Array.new(n) { Array.new(n, 0) }
end
```
=== "Zig"
@ -2055,7 +2130,14 @@ $$
=== "Ruby"
```ruby title="space_complexity.rb"
[class]{}-[func]{quadratic_recur}
### 平方阶（递归实现）###
def quadratic_recur(n)
return 0 unless n > 0
# 数组 nums 长度为 n, n-1, ..., 2, 1
nums = Array.new(n, 0)
quadratic_recur(n - 1)
end
```
=== "Zig"
@ -2253,7 +2335,15 @@ $$
=== "Ruby"
```ruby title="space_complexity.rb"
[class]{}-[func]{build_tree}
### 指数阶（建立满二叉树）###
def build_tree(n)
return if n == 0
TreeNode.new.tap do |root|
root.left = build_tree(n - 1)
root.right = build_tree(n - 1)
end
end
```
=== "Zig"

189
docs/chapter_computational_complexity/time_complexity.md
Unescape View File

@ -193,7 +193,16 @@ comments: true
=== "Ruby"
```ruby title=""
# 在某运行平台下
def algorithm(n)
a = 2 # 1 ns
a = a + 1 # 1 ns
a = a * 2 # 10 ns
# 循环 n 次
(n...0).each do # 1 ns
puts 0 # 5 ns
end
end
```
=== "Zig"
@ -478,7 +487,20 @@ $$
=== "Ruby"
```ruby title=""
# 算法 A 的时间复杂度：常数阶
def algorithm_A(n)
puts 0
end
# 算法 B 的时间复杂度：线性阶
def algorithm_B(n)
(0...n).each { puts 0 }
end
# 算法 C 的时间复杂度：常数阶
def algorithm_C(n)
(0...1_000_000).each { puts 0 }
end
```
=== "Zig"
@ -694,7 +716,15 @@ $$
=== "Ruby"
```ruby title=""
def algorithm(n)
a = 1 # +1
a = a + 1 # +1
a = a * 2 # +1
# 循环 n 次
(0...n).each do # +1
puts 0 # +1
end
end
```
=== "Zig"
@ -978,7 +1008,16 @@ $T(n)$ 是一次函数，说明其运行时间的增长趋势是线性的，因
=== "Ruby"
```ruby title=""
def algorithm(n)
a = 1 # +0（技巧 1）
a = a + n # +0（技巧 1）
# +n（技巧 2）
(0...(5 * n + 1)).each do { puts 0 }
# +n*n（技巧 3）
(0...(2 * n)).each do
(0...(n + 1)).each do { puts 0 }
end
end
```
=== "Zig"
@ -1216,7 +1255,15 @@ $$
=== "Ruby"
```ruby title="time_complexity.rb"
[class]{}-[func]{constant}
### 常数阶 ###
def constant(n)
count = 0
size = 100000
(0...size).each { count += 1 }
count
end
```
=== "Zig"
@ -1394,7 +1441,12 @@ $$
=== "Ruby"
```ruby title="time_complexity.rb"
[class]{}-[func]{linear}
### 线性阶 ###
def linear(n)
count = 0
(0...n).each { count += 1 }
count
end
```
=== "Zig"
@ -1587,7 +1639,17 @@ $$
=== "Ruby"
```ruby title="time_complexity.rb"
[class]{}-[func]{array_traversal}
### 线性阶（遍历数组）###
def array_traversal(nums)
count = 0
# 循环次数与数组长度成正比
for num in nums
count += 1
end
count
end
```
=== "Zig"
@ -1807,7 +1869,19 @@ $$
=== "Ruby"
```ruby title="time_complexity.rb"
[class]{}-[func]{quadratic}
### 平方阶 ###
def quadratic(n)
count = 0
# 循环次数与数据大小 n 成平方关系
for i in 0...n
for j in 0...n
count += 1
end
end
count
end
```
=== "Zig"
@ -2113,7 +2187,26 @@ $$
=== "Ruby"
```ruby title="time_complexity.rb"
[class]{}-[func]{bubble_sort}
### 平方阶（冒泡排序）###
def bubble_sort(nums)
count = 0 # 计数器
# 外循环：未排序区间为 [0, i]
for i in (nums.length - 1).downto(0)
# 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for j in 0...i
if nums[j] > nums[j + 1]
# 交换 nums[j] 与 nums[j + 1]
tmp = nums[j]
nums[j] = nums[j + 1]
nums[j + 1] = tmp
count += 3 # 元素交换包含 3 个单元操作
end
end
end
count
end
```
=== "Zig"
@ -2375,7 +2468,19 @@ $$
=== "Ruby"
```ruby title="time_complexity.rb"
[class]{}-[func]{exponential}
### 指数阶（循环实现）###
def exponential(n)
count, base = 0, 1
# 细胞每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
(0...n).each do
(0...base).each { count += 1 }
base *= 2
end
# count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
count
end
```
=== "Zig"
@ -2544,7 +2649,11 @@ $$
=== "Ruby"
```ruby title="time_complexity.rb"
[class]{}-[func]{exp_recur}
### 指数阶（递归实现）###
def exp_recur(n)
return 1 if n == 1
exp_recur(n - 1) + exp_recur(n - 1) + 1
end
```
=== "Zig"
@ -2741,7 +2850,17 @@ $$
=== "Ruby"
```ruby title="time_complexity.rb"
[class]{}-[func]{logarithmic}
### 对数阶（循环实现）###
def logarithmic(n)
count = 0
while n > 1
n /= 2
count += 1
end
count
end
```
=== "Zig"
@ -2904,7 +3023,11 @@ $$
=== "Ruby"
```ruby title="time_complexity.rb"
[class]{}-[func]{log_recur}
### 对数阶（递归实现）###
def log_recur(n)
return 0 unless n > 1
log_recur(n / 2) + 1
end
```
=== "Zig"
@ -3118,7 +3241,15 @@ $$
=== "Ruby"
```ruby title="time_complexity.rb"
[class]{}-[func]{linear_log_recur}
### 线性对数阶 ###
def linear_log_recur(n)
return 1 unless n > 1
count = linear_log_recur(n / 2) + linear_log_recur(n / 2)
(0...n).each { count += 1 }
count
end
```
=== "Zig"
@ -3350,7 +3481,16 @@ $$
=== "Ruby"
```ruby title="time_complexity.rb"
[class]{}-[func]{factorial_recur}
### 阶乘阶（递归实现）###
def factorial_recur(n)
return 1 if n == 0
count = 0
# 从 1 个分裂出 n 个
(0...n).each { count += factorial_recur(n - 1) }
count
end
```
=== "Zig"
@ -3745,9 +3885,24 @@ $$
=== "Ruby"
```ruby title="worst_best_time_complexity.rb"
[class]{}-[func]{random_numbers}
[class]{}-[func]{find_one}
### 生成一个数组，元素为: 1, 2, ..., n ，顺序被打乱 ###
def random_numbers(n)
# 生成数组 nums =: 1, 2, 3, ..., n
nums = Array.new(n) { |i| i + 1 }
# 随机打乱数组元素
nums.shuffle!
end
### 查找数组 nums 中数字 1 所在索引 ###
def find_one(nums)
for i in 0...nums.length
# 当元素 1 在数组头部时，达到最佳时间复杂度 O(1)
# 当元素 1 在数组尾部时，达到最差时间复杂度 O(n)
return i if nums[i] == 1
end
-1
end
```
=== "Zig"

2
en/docs/chapter_array_and_linkedlist/array.md
Unescape View File

@ -299,7 +299,7 @@ Accessing elements in an array is highly efficient, allowing us to randomly acce
### 随机访问元素 ###
def random_access(nums)
# 在区间 [0, nums.length) 中随机抽取一个数字
random_index = Random.rand 0...(nums.length - 1)
random_index = Random.rand(0...nums.length)
# 获取并返回随机元素
nums[random_index]

6
en/docs/chapter_array_and_linkedlist/list.md
Unescape View File

@ -2154,7 +2154,7 @@ To enhance our understanding of how lists work, we will attempt to implement a s
@capacity = 10
@size = 0
@extend_ratio = 2
@arr = Array.new capacity
@arr = Array.new(capacity)
end
### 访问元素 ###
@ -2226,9 +2226,9 @@ To enhance our understanding of how lists work, we will attempt to implement a s
def to_array
sz = size
# 仅转换有效长度范围内的列表元素
arr = Array.new sz
arr = Array.new(sz)
for i in 0...sz
arr[i] = get i
arr[i] = get(i)
end
arr
end

105
en/docs/chapter_computational_complexity/iteration_and_recursion.md
Unescape View File

@ -185,7 +185,17 @@ The following function uses a `for` loop to perform a summation of $1 + 2 + \dot
=== "Ruby"
```ruby title="iteration.rb"
[class]{}-[func]{for_loop}
### for 循环 ###
def for_loop(n)
res = 0
# 循环求和 1, 2, ..., n-1, n
for i in 1..n
res += i
end
res
end
```
=== "Zig"
@ -417,7 +427,19 @@ Below we use a `while` loop to implement the sum $1 + 2 + \dots + n$.
=== "Ruby"
```ruby title="iteration.rb"
[class]{}-[func]{while_loop}
### while 循环 ###
def while_loop(n)
res = 0
i = 1 # 初始化条件变量
# 循环求和 1, 2, ..., n-1, n
while i <= n
res += i
i += 1 # 更新条件变量
end
res
end
```
=== "Zig"
@ -664,7 +686,21 @@ For example, in the following code, the condition variable $i$ is updated twice
=== "Ruby"
```ruby title="iteration.rb"
[class]{}-[func]{while_loop_ii}
### while 循环（两次更新）###
def while_loop_ii(n)
res = 0
i = 1 # 初始化条件变量
# 循环求和 1, 4, 10, ...
while i <= n
res += i
# 更新条件变量
i += 1
i *= 2
end
res
end
```
=== "Zig"
@ -904,7 +940,20 @@ We can nest one loop structure within another. Below is an example using `for` l
=== "Ruby"
```ruby title="iteration.rb"
[class]{}-[func]{nested_for_loop}
### 双层 for 循环 ###
def nested_for_loop(n)
res = ""
# 循环 i = 1, 2, ..., n-1, n
for i in 1..n
# 循环 j = 1, 2, ..., n-1, n
for j in 1..n
res += "(#{i}, #{j}), "
end
end
res
end
```
=== "Zig"
@ -1139,7 +1188,15 @@ Observe the following code, where simply calling the function `recur(n)` can com
=== "Ruby"
```ruby title="recursion.rb"
[class]{}-[func]{recur}
### 递归 ###
def recur(n)
# 终止条件
return 1 if n == 1
# 递：递归调用
res = recur(n - 1)
# 归：返回结果
n + res
end
```
=== "Zig"
@ -1362,7 +1419,13 @@ For example, in calculating $1 + 2 + \dots + n$, we can make the result variable
=== "Ruby"
```ruby title="recursion.rb"
[class]{}-[func]{tail_recur}
### 尾递归 ###
def tail_recur(n, res)
# 终止条件
return res if n == 0
# 尾递归调用
tail_recur(n - 1, res + n)
end
```
=== "Zig"
@ -1594,7 +1657,15 @@ Using the recursive relation, and considering the first two numbers as terminati
=== "Ruby"
```ruby title="recursion.rb"
[class]{}-[func]{fib}
### 斐波那契数列：递归 ###
def fib(n)
# 终止条件 f(1) = 0, f(2) = 1
return n - 1 if n == 1 || n == 2
# 递归调用 f(n) = f(n-1) + f(n-2)
res = fib(n - 1) + fib(n - 2)
# 返回结果 f(n)
res
end
```
=== "Zig"
@ -1936,7 +2007,25 @@ Therefore, **we can use an explicit stack to simulate the behavior of the call s
=== "Ruby"
```ruby title="recursion.rb"
[class]{}-[func]{for_loop_recur}
### 使用迭代模拟递归 ###
def for_loop_recur(n)
# 使用一个显式的栈来模拟系统调用栈
stack = []
res = 0
# 递：递归调用
for i in n.downto(0)
# 通过“入栈操作”模拟“递”
stack << i
end
# 归：返回结果
while !stack.empty?
res += stack.pop
end
# res = 1+2+3+...+n
res
end
```
=== "Zig"

65
en/docs/chapter_computational_complexity/space_complexity.md
Unescape View File

@ -1080,9 +1080,24 @@ Note that memory occupied by initializing variables or calling functions in a lo
=== "Ruby"
```ruby title="space_complexity.rb"
[class]{}-[func]{function}
[class]{}-[func]{constant}
### 函数 ###
def function
# 执行某些操作
0
end
### 常数阶 ###
def constant(n)
# 常量、变量、对象占用 O(1) 空间
a = 0
nums = [0] * 10000
node = ListNode.new
# 循环中的变量占用 O(1) 空间
(0...n).each { c = 0 }
# 循环中的函数占用 O(1) 空间
(0...n).each { function }
end
```
=== "Zig"
@ -1384,7 +1399,17 @@ Linear order is common in arrays, linked lists, stacks, queues, etc., where the
=== "Ruby"
```ruby title="space_complexity.rb"
[class]{}-[func]{linear}
### 线性阶 ###
def linear(n)
# 长度为 n 的列表占用 O(n) 空间
nums = Array.new(n, 0)
# 长度为 n 的哈希表占用 O(n) 空间
hmap = {}
for i in 0...n
hmap[i] = i.to_s
end
end
```
=== "Zig"
@ -1566,7 +1591,12 @@ As shown below, this function's recursive depth is $n$, meaning there are $n$ in
=== "Ruby"
```ruby title="space_complexity.rb"
[class]{}-[func]{linear_recur}
### 线性阶（递归实现）###
def linear_recur(n)
puts "递归 n = #{n}"
return if n == 1
linear_recur(n - 1)
end
```
=== "Zig"
@ -1806,7 +1836,11 @@ Quadratic order is common in matrices and graphs, where the number of elements i
=== "Ruby"
```ruby title="space_complexity.rb"
[class]{}-[func]{quadratic}
### 平方阶 ###
def quadratic(n)
# 二维列表占用 O(n^2) 空间
Array.new(n) { Array.new(n, 0) }
end
```
=== "Zig"
@ -2001,7 +2035,14 @@ As shown below, the recursive depth of this function is $n$, and in each recursi
=== "Ruby"
```ruby title="space_complexity.rb"
[class]{}-[func]{quadratic_recur}
### 平方阶（递归实现）###
def quadratic_recur(n)
return 0 unless n > 0
# 数组 nums 长度为 n, n-1, ..., 2, 1
nums = Array.new(n, 0)
quadratic_recur(n - 1)
end
```
=== "Zig"
@ -2199,7 +2240,15 @@ Exponential order is common in binary trees. Observe the below image, a "full bi
=== "Ruby"
```ruby title="space_complexity.rb"
[class]{}-[func]{build_tree}
### 指数阶（建立满二叉树）###
def build_tree(n)
return if n == 0
TreeNode.new.tap do |root|
root.left = build_tree(n - 1)
root.right = build_tree(n - 1)
end
end
```
=== "Zig"

144
en/docs/chapter_computational_complexity/time_complexity.md
Unescape View File

@ -1143,7 +1143,15 @@ Constant order means the number of operations is independent of the input data s
=== "Ruby"
```ruby title="time_complexity.rb"
[class]{}-[func]{constant}
### 常数阶 ###
def constant(n)
count = 0
size = 100000
(0...size).each { count += 1 }
count
end
```
=== "Zig"
@ -1321,7 +1329,12 @@ Linear order indicates the number of operations grows linearly with the input da
=== "Ruby"
```ruby title="time_complexity.rb"
[class]{}-[func]{linear}
### 线性阶 ###
def linear(n)
count = 0
(0...n).each { count += 1 }
count
end
```
=== "Zig"
@ -1514,7 +1527,17 @@ Operations like array traversal and linked list traversal have a time complexity
=== "Ruby"
```ruby title="time_complexity.rb"
[class]{}-[func]{array_traversal}
### 线性阶（遍历数组）###
def array_traversal(nums)
count = 0
# 循环次数与数组长度成正比
for num in nums
count += 1
end
count
end
```
=== "Zig"
@ -1734,7 +1757,19 @@ Quadratic order means the number of operations grows quadratically with the inpu
=== "Ruby"
```ruby title="time_complexity.rb"
[class]{}-[func]{quadratic}
### 平方阶 ###
def quadratic(n)
count = 0
# 循环次数与数据大小 n 成平方关系
for i in 0...n
for j in 0...n
count += 1
end
end
count
end
```
=== "Zig"
@ -2040,7 +2075,26 @@ For instance, in bubble sort, the outer loop runs $n - 1$ times, and the inner l
=== "Ruby"
```ruby title="time_complexity.rb"
[class]{}-[func]{bubble_sort}
### 平方阶（冒泡排序）###
def bubble_sort(nums)
count = 0 # 计数器
# 外循环：未排序区间为 [0, i]
for i in (nums.length - 1).downto(0)
# 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for j in 0...i
if nums[j] > nums[j + 1]
# 交换 nums[j] 与 nums[j + 1]
tmp = nums[j]
nums[j] = nums[j + 1]
nums[j + 1] = tmp
count += 3 # 元素交换包含 3 个单元操作
end
end
end
count
end
```
=== "Zig"
@ -2302,7 +2356,19 @@ The following image and code simulate the cell division process, with a time com
=== "Ruby"
```ruby title="time_complexity.rb"
[class]{}-[func]{exponential}
### 指数阶（循环实现）###
def exponential(n)
count, base = 0, 1
# 细胞每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
(0...n).each do
(0...base).each { count += 1 }
base *= 2
end
# count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
count
end
```
=== "Zig"
@ -2471,7 +2537,11 @@ In practice, exponential order often appears in recursive functions. For example
=== "Ruby"
```ruby title="time_complexity.rb"
[class]{}-[func]{exp_recur}
### 指数阶（递归实现）###
def exp_recur(n)
return 1 if n == 1
exp_recur(n - 1) + exp_recur(n - 1) + 1
end
```
=== "Zig"
@ -2668,7 +2738,17 @@ The following image and code simulate the "halving each round" process, with a t
=== "Ruby"
```ruby title="time_complexity.rb"
[class]{}-[func]{logarithmic}
### 对数阶（循环实现）###
def logarithmic(n)
count = 0
while n > 1
n /= 2
count += 1
end
count
end
```
=== "Zig"
@ -2831,7 +2911,11 @@ Like exponential order, logarithmic order also frequently appears in recursive f
=== "Ruby"
```ruby title="time_complexity.rb"
[class]{}-[func]{log_recur}
### 对数阶（递归实现）###
def log_recur(n)
return 0 unless n > 1
log_recur(n / 2) + 1
end
```
=== "Zig"
@ -3045,7 +3129,15 @@ Linear-logarithmic order often appears in nested loops, with the complexities of
=== "Ruby"
```ruby title="time_complexity.rb"
[class]{}-[func]{linear_log_recur}
### 线性对数阶 ###
def linear_log_recur(n)
return 1 unless n > 1
count = linear_log_recur(n / 2) + linear_log_recur(n / 2)
(0...n).each { count += 1 }
count
end
```
=== "Zig"
@ -3277,7 +3369,16 @@ Factorials are typically implemented using recursion. As shown in the image and
=== "Ruby"
```ruby title="time_complexity.rb"
[class]{}-[func]{factorial_recur}
### 阶乘阶（递归实现）###
def factorial_recur(n)
return 1 if n == 0
count = 0
# 从 1 个分裂出 n 个
(0...n).each { count += factorial_recur(n - 1) }
count
end
```
=== "Zig"
@ -3672,9 +3773,24 @@ The "worst-case time complexity" corresponds to the asymptotic upper bound, deno
=== "Ruby"
```ruby title="worst_best_time_complexity.rb"
[class]{}-[func]{random_numbers}
[class]{}-[func]{find_one}
### 生成一个数组，元素为: 1, 2, ..., n ，顺序被打乱 ###
def random_numbers(n)
# 生成数组 nums =: 1, 2, 3, ..., n
nums = Array.new(n) { |i| i + 1 }
# 随机打乱数组元素
nums.shuffle!
end
### 查找数组 nums 中数字 1 所在索引 ###
def find_one(nums)
for i in 0...nums.length
# 当元素 1 在数组头部时，达到最佳时间复杂度 O(1)
# 当元素 1 在数组尾部时，达到最差时间复杂度 O(n)
return i if nums[i] == 1
end
-1
end
```
=== "Zig"

Write Preview
Loading…
Cancel
Save