Bug fixes and improvements.

codes/c/chapter_sorting/quick_sort.c

@@ -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;

codes/cpp/chapter_sorting/quick_sort.cpp

@@ -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;

codes/csharp/chapter_sorting/quick_sort.cs

@@ -89,7 +89,7 @@ public static void QuickSort(int[] nums, int left, int right) {
     }
 }
 
-/* 快速排序类（尾递归优化） */
+/* 快速排序类（递归深度优化） */
 class QuickSortTailCall {
     /* 元素交换 */
     static void Swap(int[] nums, int i, int j) {
@@ -111,7 +111,7 @@ static int Partition(int[] nums, int left, int right) {
         return i; // 返回基准数的索引
     }
 
-    /* 快速排序（尾递归优化） */
+    /* 快速排序（递归深度优化） */
     public static void QuickSort(int[] nums, int left, int right) {
         // 子数组长度为 1 时终止
         while (left < right) {
@@ -142,9 +142,9 @@ public void Test() {
         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));
     }
 }

codes/dart/chapter_sorting/quick_sort.dart

@@ -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");
 }

codes/go/chapter_sorting/quick_sort.go

@@ -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 {

codes/go/chapter_sorting/quick_sort_test.go

@@ -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)
 }

codes/java/chapter_sorting/quick_sort.java

@@ -96,7 +96,7 @@ public static void quickSort(int[] nums, int left, int right) {
     }
 }
 
-/* 快速排序类（尾递归优化） */
+/* 快速排序类（递归深度优化） */
 class QuickSortTailCall {
     /* 元素交换 */
     static void swap(int[] nums, int i, int j) {
@@ -120,7 +120,7 @@ static int partition(int[] nums, int left, int right) {
         return i;             // 返回基准数的索引
     }
 
-    /* 快速排序（尾递归优化） */
+    /* 快速排序（递归深度优化） */
     public static void quickSort(int[] nums, int left, int right) {
         // 子数组长度为 1 时终止
         while (left < right) {
@@ -150,9 +150,9 @@ public static void main(String[] args) {
         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));
     }
 }

codes/javascript/chapter_sorting/quick_sort.js

@@ -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);

codes/kotlin/chapter_sorting/quick_sort.kt

@@ -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()}")
 }

codes/python/chapter_sorting/quick_sort.py

@@ -79,7 +79,7 @@ def quick_sort(self, nums: list[int], left: int, right: int):
 
 
 class QuickSortTailCall:
-    """快速排序类（尾递归优化）"""
+    """快速排序类（递归深度优化）"""
 
     def partition(self, nums: list[int], left: int, right: int) -> int:
         """哨兵划分"""
@@ -97,7 +97,7 @@ def partition(self, nums: list[int], left: int, right: int) -> int:
         return i  # 返回基准数的索引
 
     def quick_sort(self, nums: list[int], left: int, right: int):
-        """快速排序（尾递归优化）"""
+        """快速排序（递归深度优化）"""
         # 子数组长度为 1 时终止
         while left < right:
             # 哨兵划分操作
@@ -123,7 +123,7 @@ def quick_sort(self, nums: list[int], left: int, right: int):
     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)

codes/ruby/chapter_sorting/quick_sort.rb

@@ -92,7 +92,7 @@ def quick_sort(nums, left, right)
   end
 end
 
-### 快速排序类（尾递归优化）###
+### 快速排序类（递归深度优化）###
 class QuickSortTailCall
   class << self
     ### 哨兵划分 ###
@@ -115,7 +115,7 @@ def partition(nums, left, right)
       i # 返回基准数的索引
     end
 
-    ### 快速排序（尾递归优化）###
+    ### 快速排序（递归深度优化）###
     def quick_sort(nums, left, right)
       # 子数组长度不为 1 时递归
       while left < right
@@ -146,8 +146,8 @@ def quick_sort(nums, left, right)
   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

codes/rust/chapter_sorting/quick_sort.rs

@@ -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);
 }

codes/swift/chapter_sorting/quick_sort.swift

@@ -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)")
     }
 }

codes/typescript/chapter_sorting/quick_sort.ts

@@ -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 {};

codes/zig/chapter_sorting/quick_sort.zig

@@ -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();