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

Bug fixes and improvements. (#1780)

Browse Source 
* Fix the "尾递归优化" to "递归深度优化" in quick_sort.

* Update landing pages.

* Sync zh and zh-hant versions.

* Sync zh and zh-hant versions.
This commit is contained in:
Yudong Jin
2025-07-10 06:32:25 +08:00
committed by GitHub
parent 6a4d62449c
commit e8dc4736a2
43 changed files with 173 additions and 165 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
codes/c/chapter_sorting/quick_sort.c
View File

@ -89,9 +89,9 @@ void quickSortMedian(int nums[], int left, int right) {
quickSortMedian(nums, pivot + 1, right);
}
// 以下为尾递归优化的快速排序
// 以下为递归深度优化的快速排序
/* 快速排序（尾递归优化） */
/* 快速排序（递归深度优化） */
void quickSortTailCall(int nums[], int left, int right) {
// 子数组长度为 1 时终止
while (left < right) {
@ -127,10 +127,10 @@ int main() {
printf("快速排序（中位基准数优化）完成后 nums = ");
printArray(nums1, size);
/* 快速排序（尾递归优化） */
/* 快速排序（递归深度优化） */
int nums2[] = {2, 4, 1, 0, 3, 5};
quickSortTailCall(nums2, 0, size - 1);
printf("快速排序（尾递归优化）完成后 nums = ");
printf("快速排序（递归深度优化）完成后 nums = ");
printArray(nums1, size);
return 0;

8
codes/cpp/chapter_sorting/quick_sort.cpp
View File

@ -84,7 +84,7 @@ class QuickSortMedian {
}
};
/* 快速排序类（尾递归优化） */
/* 快速排序类（递归深度优化） */
class QuickSortTailCall {
private:
/* 哨兵划分 */
@ -103,7 +103,7 @@ class QuickSortTailCall {
}
public:
/* 快速排序（尾递归优化） */
/* 快速排序（递归深度优化） */
static void quickSort(vector<int> &nums, int left, int right) {
// 子数组长度为 1 时终止
while (left < right) {
@ -135,10 +135,10 @@ int main() {
cout << "快速排序（中位基准数优化）完成后 nums = ";
printVector(nums1);
/* 快速排序（尾递归优化） */
/* 快速排序（递归深度优化） */
vector<int> nums2 = {2, 4, 1, 0, 3, 5};
QuickSortTailCall::quickSort(nums2, 0, nums2.size() - 1);
cout << "快速排序（尾递归优化）完成后 nums = ";
cout << "快速排序（递归深度优化）完成后 nums = ";
printVector(nums2);
return 0;

8
codes/csharp/chapter_sorting/quick_sort.cs
View File

@ -89,7 +89,7 @@ class QuickSortMedian {
}
}
/* 快速排序类（尾递归优化） */
/* 快速排序类（递归深度优化） */
class QuickSortTailCall {
/* 元素交换 */
static void Swap(int[] nums, int i, int j) {
@ -111,7 +111,7 @@ class QuickSortTailCall {
return i; // 返回基准数的索引
}
/* 快速排序（尾递归优化） */
/* 快速排序（递归深度优化） */
public static void QuickSort(int[] nums, int left, int right) {
// 子数组长度为 1 时终止
while (left < right) {
@ -142,9 +142,9 @@ public class quick_sort {
QuickSortMedian.QuickSort(nums1, 0, nums1.Length - 1);
Console.WriteLine("快速排序（中位基准数优化）完成后 nums1 = " + string.Join(",", nums1));
/* 快速排序（尾递归优化） */
/* 快速排序（递归深度优化） */
int[] nums2 = [2, 4, 1, 0, 3, 5];
QuickSortTailCall.QuickSort(nums2, 0, nums2.Length - 1);
Console.WriteLine("快速排序（尾递归优化）完成后 nums2 = " + string.Join(",", nums2));
Console.WriteLine("快速排序（递归深度优化）完成后 nums2 = " + string.Join(",", nums2));
}
}

8
codes/dart/chapter_sorting/quick_sort.dart
View File

@ -86,7 +86,7 @@ class QuickSortMedian {
}
}
/* 快速排序类（尾递归优化） */
/* 快速排序类（递归深度优化） */
class QuickSortTailCall {
/* 元素交换 */
static void _swap(List<int> nums, int i, int j) {
@ -108,7 +108,7 @@ class QuickSortTailCall {
return i; // 返回基准数的索引
}
/* 快速排序（尾递归优化） */
/* 快速排序（递归深度优化） */
static void quickSort(List<int> nums, int left, int right) {
// 子数组长度为 1 时终止
while (left < right) {
@ -138,8 +138,8 @@ void main() {
QuickSortMedian.quickSort(nums1, 0, nums1.length - 1);
print("快速排序（中位基准数优化）完成后 nums1 = $nums1");
/* 快速排序（尾递归优化） */
/* 快速排序（递归深度优化） */
List<int> nums2 = [2, 4, 1, 0, 3, 5];
QuickSortTailCall.quickSort(nums2, 0, nums2.length - 1);
print("快速排序（尾递归优化）完成后 nums2 = $nums2");
print("快速排序（递归深度优化）完成后 nums2 = $nums2");
}

4
codes/go/chapter_sorting/quick_sort.go
View File

@ -10,7 +10,7 @@ type quickSort struct{}
// 快速排序（中位基准数优化）
type quickSortMedian struct{}
// 快速排序（尾递归优化）
// 快速排序（递归深度优化）
type quickSortTailCall struct{}
/* 哨兵划分 */
@ -112,7 +112,7 @@ func (q *quickSortTailCall) partition(nums []int, left, right int) int {
return i // 返回基准数的索引
}
/* 快速排序（尾递归优化）*/
/* 快速排序（递归深度优化）*/
func (q *quickSortTailCall) quickSort(nums []int, left, right int) {
// 子数组长度为 1 时终止
for left < right {

4
codes/go/chapter_sorting/quick_sort_test.go
View File

@ -25,10 +25,10 @@ func TestQuickSortMedian(t *testing.T) {
fmt.Println("快速排序（中位基准数优化）完成后 nums = ", nums)
}
// 快速排序（尾递归优化）
// 快速排序（递归深度优化）
func TestQuickSortTailCall(t *testing.T) {
q := quickSortTailCall{}
nums := []int{4, 1, 3, 1, 5, 2}
q.quickSort(nums, 0, len(nums)-1)
fmt.Println("快速排序（尾递归优化）完成后 nums = ", nums)
fmt.Println("快速排序（递归深度优化）完成后 nums = ", nums)
}

8
codes/java/chapter_sorting/quick_sort.java
View File

@ -96,7 +96,7 @@ class QuickSortMedian {
}
}
/* 快速排序类（尾递归优化） */
/* 快速排序类（递归深度优化） */
class QuickSortTailCall {
/* 元素交换 */
static void swap(int[] nums, int i, int j) {
@ -120,7 +120,7 @@ class QuickSortTailCall {
return i; // 返回基准数的索引
}
/* 快速排序（尾递归优化） */
/* 快速排序（递归深度优化） */
public static void quickSort(int[] nums, int left, int right) {
// 子数组长度为 1 时终止
while (left < right) {
@ -150,9 +150,9 @@ public class quick_sort {
QuickSortMedian.quickSort(nums1, 0, nums1.length - 1);
System.out.println("快速排序（中位基准数优化）完成后 nums1 = " + Arrays.toString(nums1));
/* 快速排序（尾递归优化） */
/* 快速排序（递归深度优化） */
int[] nums2 = { 2, 4, 1, 0, 3, 5 };
QuickSortTailCall.quickSort(nums2, 0, nums2.length - 1);
System.out.println("快速排序（尾递归优化）完成后 nums2 = " + Arrays.toString(nums2));
System.out.println("快速排序（递归深度优化）完成后 nums2 = " + Arrays.toString(nums2));
}
}

8
codes/javascript/chapter_sorting/quick_sort.js
View File

@ -100,7 +100,7 @@ class QuickSortMedian {
}
}
/* 快速排序类（尾递归优化） */
/* 快速排序类（递归深度优化） */
class QuickSortTailCall {
/* 元素交换 */
swap(nums, i, j) {
@ -123,7 +123,7 @@ class QuickSortTailCall {
return i; // 返回基准数的索引
}
/* 快速排序（尾递归优化） */
/* 快速排序（递归深度优化） */
quickSort(nums, left, right) {
// 子数组长度为 1 时终止
while (left < right) {
@ -154,8 +154,8 @@ const quickSortMedian = new QuickSortMedian();
quickSortMedian.quickSort(nums1, 0, nums1.length - 1);
console.log('快速排序（中位基准数优化）完成后 nums =', nums1);
/* 快速排序（尾递归优化） */
/* 快速排序（递归深度优化） */
const nums2 = [2, 4, 1, 0, 3, 5];
const quickSortTailCall = new QuickSortTailCall();
quickSortTailCall.quickSort(nums2, 0, nums2.length - 1);
console.log('快速排序（尾递归优化）完成后 nums =', nums2);
console.log('快速排序（递归深度优化）完成后 nums =', nums2);

6
codes/kotlin/chapter_sorting/quick_sort.kt
View File

@ -83,7 +83,7 @@ fun quickSortMedian(nums: IntArray, left: Int, right: Int) {
quickSort(nums, pivot + 1, right)
}
/* 快速排序（尾递归优化） */
/* 快速排序（递归深度优化） */
fun quickSortTailCall(nums: IntArray, left: Int, right: Int) {
// 子数组长度为 1 时终止
var l = left
@ -114,8 +114,8 @@ fun main() {
quickSortMedian(nums1, 0, nums1.size - 1)
println("快速排序（中位基准数优化）完成后 nums1 = ${nums1.contentToString()}")
/* 快速排序（尾递归优化） */
/* 快速排序（递归深度优化） */
val nums2 = intArrayOf(2, 4, 1, 0, 3, 5)
quickSortTailCall(nums2, 0, nums2.size - 1)
println("快速排序（尾递归优化）完成后 nums2 = ${nums2.contentToString()}")
println("快速排序（递归深度优化）完成后 nums2 = ${nums2.contentToString()}")
}

8
codes/python/chapter_sorting/quick_sort.py
View File

@ -79,7 +79,7 @@ class QuickSortMedian:
class QuickSortTailCall:
"""快速排序类（尾递归优化）"""
"""快速排序类（递归深度优化）"""
def partition(self, nums: list[int], left: int, right: int) -> int:
"""哨兵划分"""
@ -97,7 +97,7 @@ class QuickSortTailCall:
return i # 返回基准数的索引
def quick_sort(self, nums: list[int], left: int, right: int):
"""快速排序（尾递归优化）"""
"""快速排序（递归深度优化）"""
# 子数组长度为 1 时终止
while left < right:
# 哨兵划分操作
@ -123,7 +123,7 @@ if __name__ == "__main__":
QuickSortMedian().quick_sort(nums1, 0, len(nums1) - 1)
print("快速排序（中位基准数优化）完成后 nums =", nums1)
# 快速排序（尾递归优化）
# 快速排序（递归深度优化）
nums2 = [2, 4, 1, 0, 3, 5]
QuickSortTailCall().quick_sort(nums2, 0, len(nums2) - 1)
print("快速排序（尾递归优化）完成后 nums =", nums2)
print("快速排序（递归深度优化）完成后 nums =", nums2)

8
codes/ruby/chapter_sorting/quick_sort.rb
View File

@ -92,7 +92,7 @@ class QuickSortMedian
end
end
### 快速排序类（尾递归优化）###
### 快速排序类（递归深度优化）###
class QuickSortTailCall
class << self
### 哨兵划分 ###
@ -115,7 +115,7 @@ class QuickSortTailCall
i # 返回基准数的索引
end
### 快速排序（尾递归优化）###
### 快速排序（递归深度优化）###
def quick_sort(nums, left, right)
# 子数组长度不为 1 时递归
while left < right
@ -146,8 +146,8 @@ if __FILE__ == $0
QuickSortMedian.quick_sort(nums1, 0, nums1.length - 1)
puts "快速排序（中位基准数优化）完成后 nums1 = #{nums1}"
# 快速排序（尾递归优化）
# 快速排序（递归深度优化）
nums2 = [2, 4, 1, 0, 3, 5]
QuickSortTailCall.quick_sort(nums2, 0, nums2.length - 1)
puts "快速排序（尾递归优化）完成后 nums2 = #{nums2}"
puts "快速排序（递归深度优化）完成后 nums2 = #{nums2}"
end

8
codes/rust/chapter_sorting/quick_sort.rs
View File

@ -90,7 +90,7 @@ impl QuickSortMedian {
}
}
/* 快速排序（尾递归优化） */
/* 快速排序（递归深度优化） */
struct QuickSortTailCall;
impl QuickSortTailCall {
@ -111,7 +111,7 @@ impl QuickSortTailCall {
i // 返回基准数的索引
}
/* 快速排序（尾递归优化） */
/* 快速排序（递归深度优化） */
pub fn quick_sort(mut left: i32, mut right: i32, nums: &mut [i32]) {
// 子数组长度为 1 时终止
while left < right {
@ -141,8 +141,8 @@ fn main() {
QuickSortMedian::quick_sort(0, (nums.len() - 1) as i32, &mut nums);
println!("快速排序（中位基准数优化）完成后 nums = {:?}", nums);
/* 快速排序（尾递归优化） */
/* 快速排序（递归深度优化） */
let mut nums = [2, 4, 1, 0, 3, 5];
QuickSortTailCall::quick_sort(0, (nums.len() - 1) as i32, &mut nums);
println!("快速排序（尾递归优化）完成后 nums = {:?}", nums);
println!("快速排序（递归深度优化）完成后 nums = {:?}", nums);
}

6
codes/swift/chapter_sorting/quick_sort.swift
View File

@ -73,7 +73,7 @@ func quickSortMedian(nums: inout [Int], left: Int, right: Int) {
quickSortMedian(nums: &nums, left: pivot + 1, right: right)
}
/* 快速排序（尾递归优化） */
/* 快速排序（递归深度优化） */
func quickSortTailCall(nums: inout [Int], left: Int, right: Int) {
var left = left
var right = right
@ -106,9 +106,9 @@ enum QuickSort {
quickSortMedian(nums: &nums1, left: nums1.startIndex, right: nums1.endIndex - 1)
print("快速排序（中位基准数优化）完成后 nums1 = \(nums1)")
/* 快速排序（尾递归优化） */
/* 快速排序（递归深度优化） */
var nums2 = [2, 4, 1, 0, 3, 5]
quickSortTailCall(nums: &nums2, left: nums2.startIndex, right: nums2.endIndex - 1)
print("快速排序（尾递归优化）完成后 nums2 = \(nums2)")
print("快速排序（递归深度优化）完成后 nums2 = \(nums2)")
}
}

8
codes/typescript/chapter_sorting/quick_sort.ts
View File

@ -113,7 +113,7 @@ class QuickSortMedian {
}
}
/* 快速排序类（尾递归优化） */
/* 快速排序类（递归深度优化） */
class QuickSortTailCall {
/* 元素交换 */
swap(nums: number[], i: number, j: number): void {
@ -140,7 +140,7 @@ class QuickSortTailCall {
return i; // 返回基准数的索引
}
/* 快速排序（尾递归优化） */
/* 快速排序（递归深度优化） */
quickSort(nums: number[], left: number, right: number): void {
// 子数组长度为 1 时终止
while (left < right) {
@ -171,10 +171,10 @@ const quickSortMedian = new QuickSortMedian();
quickSortMedian.quickSort(nums1, 0, nums1.length - 1);
console.log('快速排序（中位基准数优化）完成后 nums =', nums1);
/* 快速排序（尾递归优化） */
/* 快速排序（递归深度优化） */
const nums2 = [2, 4, 1, 0, 3, 5];
const quickSortTailCall = new QuickSortTailCall();
quickSortTailCall.quickSort(nums2, 0, nums2.length - 1);
console.log('快速排序（尾递归优化）完成后 nums =', nums2);
console.log('快速排序（递归深度优化）完成后 nums =', nums2);
export {};

8
codes/zig/chapter_sorting/quick_sort.zig
View File

@ -94,7 +94,7 @@ const QuickSortMedian = struct {
}
};
// 快速排序类（尾递归优化）
// 快速排序类（递归深度优化）
const QuickSortTailCall = struct {
// 元素交换
@ -118,7 +118,7 @@ const QuickSortTailCall = struct {
return i; // 返回基准数的索引
}
// 快速排序（尾递归优化）
// 快速排序（递归深度优化）
pub fn quickSort(nums: []i32, left_: usize, right_: usize) void {
var left = left_;
var right = right_;
@ -152,10 +152,10 @@ pub fn main() !void {
std.debug.print("\n快速排序（中位基准数优化）完成后 nums = ", .{});
inc.PrintUtil.printArray(i32, &nums1);
// 快速排序（尾递归优化）
// 快速排序（递归深度优化）
var nums2 = [_]i32{ 2, 4, 1, 0, 3, 5 };
QuickSortTailCall.quickSort(&nums2, 0, nums2.len - 1);
std.debug.print("\n快速排序（尾递归优化）完成后 nums = ", .{});
std.debug.print("\n快速排序（递归深度优化）完成后 nums = ", .{});
inc.PrintUtil.printArray(i32, &nums2);
_ = try std.io.getStdIn().reader().readByte();