CS_learn/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-04-08 13:21:19 +08:00
Code Issues Packages Projects Releases Wiki Activity

build

Browse Source
This commit is contained in:
krahets
2024-05-04 19:57:03 +08:00
parent 6d966b8b5d
commit 2395804410
27 changed files with 792 additions and 91 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
docs/chapter_sorting/bubble_sort.md
View File

@@ -276,7 +276,20 @@ comments: true
=== "Ruby"
```ruby title="bubble_sort.rb"
[class]{}-[func]{bubble_sort}
### 冒泡排序 ###
def bubble_sort(nums)
n = nums.length
# 外循环：未排序区间为 [0, i]
for i in (n - 1).downto(1)
# 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for j in 0...i
if nums[j] > nums[j + 1]
# 交换 nums[j] 与 nums[j + 1]
nums[j], nums[j + 1] = nums[j + 1], nums[j]
end
end
end
end
```
=== "Zig"
@@ -587,7 +600,25 @@ comments: true
=== "Ruby"
```ruby title="bubble_sort.rb"
[class]{}-[func]{bubble_sort_with_flag}
### 冒泡排序（标志优化）###
def bubble_sort_with_flag(nums)
n = nums.length
# 外循环：未排序区间为 [0, i]
for i in (n - 1).downto(1)
flag = false # 初始化标志位
# 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端
for j in 0...i
if nums[j] > nums[j + 1]
# 交换 nums[j] 与 nums[j + 1]
nums[j], nums[j + 1] = nums[j + 1], nums[j]
flag = true # 记录交换元素
end
end
break unless flag # 此轮“冒泡”未交换任何元素，直接跳出
end
end
```
=== "Zig"

45
docs/chapter_sorting/counting_sort.md
View File

@@ -348,7 +348,25 @@ comments: true
=== "Ruby"
```ruby title="counting_sort.rb"
[class]{}-[func]{counting_sort_naive}
### 计数排序 ###
def counting_sort_naive(nums)
# 简单实现，无法用于排序对象
# 1. 统计数组最大元素 m
m = 0
nums.each { |num| m = [m, num].max }
# 2. 统计各数字的出现次数
# counter[num] 代表 num 的出现次数
counter = Array.new(m + 1, 0)
nums.each { |num| counter[num] += 1 }
# 3. 遍历 counter ，将各元素填入原数组 nums
i = 0
for num in 0...(m + 1)
(0...counter[num]).each do
nums[i] = num
i += 1
end
end
end
```
=== "Zig"
@@ -854,7 +872,30 @@ $$
=== "Ruby"
```ruby title="counting_sort.rb"
[class]{}-[func]{counting_sort}
### 计数排序 ###
def counting_sort(nums)
# 完整实现，可排序对象，并且是稳定排序
# 1. 统计数组最大元素 m
m = nums.max
# 2. 统计各数字的出现次数
# counter[num] 代表 num 的出现次数
counter = Array.new(m + 1, 0)
nums.each { |num| counter[num] += 1 }
# 3. 求 counter 的前缀和，将“出现次数”转换为“尾索引”
# 即 counter[num]-1 是 num 在 res 中最后一次出现的索引
(0...m).each { |i| counter[i + 1] += counter[i] }
# 4. 倒序遍历 nums, 将各元素填入结果数组 res
# 初始化数组 res 用于记录结果
n = nums.length
res = Array.new(n, 0)
(n - 1).downto(0).each do |i|
num = nums[i]
res[counter[num] - 1] = num # 将 num 放置到对应索引处
counter[num] -= 1 # 令前缀和自减 1 ，得到下次放置 num 的索引
end
# 使用结果数组 res 覆盖原数组 nums
(0...n).each { |i| nums[i] = res[i] }
end
```
=== "Zig"

82
docs/chapter_sorting/quick_sort.md
View File

@@ -353,7 +353,24 @@ comments: true
=== "Ruby"
```ruby title="quick_sort.rb"
[class]{QuickSort}-[func]{partition}
### 哨兵划分 ###
def partition(nums, left, right)
# 以 nums[left] 为基准数
i, j = left, right
while i < j
while i < j && nums[j] >= nums[left]
j -= 1 # 从右向左找首个小于基准数的元素
end
while i < j && nums[i] <= nums[left]
i += 1 # 从左向右找首个大于基准数的元素
end
# 元素交换
nums[i], nums[j] = nums[j], nums[i]
end
# 将基准数交换至两子数组的分界线
nums[i], nums[left] = nums[left], nums[i]
i # 返回基准数的索引
end
```
=== "Zig"
@@ -594,7 +611,18 @@ comments: true
=== "Ruby"
```ruby title="quick_sort.rb"
[class]{QuickSort}-[func]{quick_sort}
### 快速排序类 ###
def quick_sort(nums, left, right)
# 子数组长度不为 1 时递归
if left < right
# 哨兵划分
pivot = partition(nums, left, right)
# 递归左子数组、右子数组
quick_sort(nums, left, pivot - 1)
quick_sort(nums, pivot + 1, right)
end
nums
end
```
=== "Zig"
@@ -1067,9 +1095,38 @@ comments: true
=== "Ruby"
```ruby title="quick_sort.rb"
[class]{QuickSortMedian}-[func]{median_three}
### 选取三个候选元素的中位数 ###
def median_three(nums, left, mid, right)
# 选取三个候选元素的中位数
_l, _m, _r = nums[left], nums[mid], nums[right]
# m 在 l 和 r 之间
return mid if (_l <= _m && _m <= _r) || (_r <= _m && _m <= _l)
# l 在 m 和 r 之间
return left if (_m <= _l && _l <= _r) || (_r <= _l && _l <= _m)
return right
end
[class]{QuickSortMedian}-[func]{partition}
### 哨兵划分（三数取中值）###
def partition(nums, left, right)
### 以 nums[left] 为基准数
med = median_three(nums, left, (left + right) / 2, right)
# 将中位数交换至数组最左断
nums[left], nums[med] = nums[med], nums[left]
i, j = left, right
while i < j
while i < j && nums[j] >= nums[left]
j -= 1 # 从右向左找首个小于基准数的元素
end
while i < j && nums[i] <= nums[left]
i += 1 # 从左向右找首个大于基准数的元素
end
# 元素交换
nums[i], nums[j] = nums[j], nums[i]
end
# 将基准数交换至两子数组的分界线
nums[i], nums[left] = nums[left], nums[i]
i # 返回基准数的索引
end
```
=== "Zig"
@@ -1377,7 +1434,22 @@ comments: true
=== "Ruby"
```ruby title="quick_sort.rb"
[class]{QuickSortTailCall}-[func]{quick_sort}
### 快速排序（尾递归优化）###
def quick_sort(nums, left, right)
# 子数组长度不为 1 时递归
while left < right
# 哨兵划分
pivot = partition(nums, left, right)
# 对两个子数组中较短的那个执行快速排序
if pivot - left < right - pivot
quick_sort(nums, left, pivot - 1)
left = pivot + 1 # 剩余未排序区间为 [pivot + 1, right]
else
quick_sort(nums, pivot + 1, right)
right = pivot - 1 # 剩余未排序区间为 [left, pivot - 1]
end
end
end
```
=== "Zig"

46
docs/chapter_sorting/radix_sort.md
View File

@@ -677,11 +677,51 @@ $$
=== "Ruby"
```ruby title="radix_sort.rb"
[class]{}-[func]{digit}
### 获取元素 num 的第 k 位，其中 exp = 10^(k-1) ###
def digit(num, exp)
# 转入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
(num / exp) % 10
end
[class]{}-[func]{counting_sort_digit}
### 计数排序（根据 nums 第 k 位排序）###
def counting_sort_digit(nums, exp)
# 十进制的位范围为 0~9 ，因此需要长度为 10 的桶数组
counter = Array.new(10, 0)
n = nums.length
# 统计 0~9 各数字的出现次数
for i in 0...n
d = digit(nums[i], exp) # 获取 nums[i] 第 k 位，记为 d
counter[d] += 1 # 统计数字 d 的出现次数
end
# 求前缀和，将“出现个数”转换为“数组索引”
(1...10).each { |i| counter[i] += counter[i - 1] }
# 倒序遍历，根据桶内统计结果，将各元素填入 res
res = Array.new(n, 0)
for i in (n - 1).downto(0)
d = digit(nums[i], exp)
j = counter[d] - 1 # 获取 d 在数组中的索引 j
res[j] = nums[i] # 将当前元素填入索引 j
counter[d] -= 1 # 将 d 的数量减 1
end
# 使用结果覆盖原数组 nums
(0...n).each { |i| nums[i] = res[i] }
end
[class]{}-[func]{radix_sort}
### 基数排序 ###
def radix_sort(nums)
# 获取数组的最大元素，用于判断最大位数
m = nums.max
# 按照从低位到高位的顺序遍历
exp = 1
while exp <= m
# 对数组元素的第 k 位执行计数排序
# k = 1 -> exp = 1
# k = 2 -> exp = 10
# 即 exp = 10^(k-1)
counting_sort_digit(nums, exp)
exp *= 10
end
end
```
=== "Zig"

17
docs/chapter_sorting/selection_sort.md
View File

@@ -306,7 +306,22 @@ comments: true
=== "Ruby"
```ruby title="selection_sort.rb"
[class]{}-[func]{selection_sort}
### 选择排序 ###
def selection_sort(nums)
n = nums.length
# 外循环：未排序区间为 [i, n-1]
for i in 0...(n - 1)
# 内循环：找到未排序区间内的最小元素
k = i
for j in (i + 1)...n
if nums[j] < nums[k]
k = j # 记录最小元素的索引
end
end
# 将该最小元素与未排序区间的首个元素交换
nums[i], nums[k] = nums[k], nums[i]
end
end
```
=== "Zig"