Retranslate the complete English edition from Simplified Chinese (#2010)

* Retranslate the complete English edition from Simplified Chinese

* Polish three English explanations after reader-focused review

en/codes/java/chapter_computational_complexity/time_complexity.java

@@ -7,7 +7,7 @@
 package chapter_computational_complexity;
 
 public class time_complexity {
-    /* Constant order */
+    /* Constant complexity */
     static int constant(int n) {
         int count = 0;
         int size = 100000;
@@ -16,7 +16,7 @@ public class time_complexity {
         return count;
     }
 
-    /* Linear order */
+    /* Linear complexity */
     static int linear(int n) {
         int count = 0;
         for (int i = 0; i < n; i++)
@@ -24,20 +24,20 @@ public class time_complexity {
         return count;
     }
 
-    /* Linear order (traversing array) */
+    /* Linear complexity (array traversal) */
     static int arrayTraversal(int[] nums) {
         int count = 0;
-        // Number of iterations is proportional to the array length
+        // The number of iterations is proportional to the array length
         for (int num : nums) {
             count++;
         }
         return count;
     }
 
-    /* Exponential order */
+    /* Quadratic complexity */
     static int quadratic(int n) {
         int count = 0;
-        // Number of iterations is quadratically related to the data size n
+        // The number of iterations is proportional to the square of the input size n
         for (int i = 0; i < n; i++) {
             for (int j = 0; j < n; j++) {
                 count++;
@@ -46,29 +46,29 @@ public class time_complexity {
         return count;
     }
 
-    /* Quadratic order (bubble sort) */
+    /* Quadratic complexity (bubble sort) */
     static int bubbleSort(int[] nums) {
         int count = 0; // Counter
-        // Outer loop: unsorted range is [0, i]
+        // Outer loop: the unsorted range is [0, i]
         for (int i = nums.length - 1; i > 0; i--) {
-            // Inner loop: swap the largest element in the unsorted range [0, i] to the rightmost end of that range
+            // Inner loop: move the largest element in the unsorted range [0, i] to its right end through swaps
             for (int j = 0; j < i; j++) {
                 if (nums[j] > nums[j + 1]) {
                     // Swap nums[j] and nums[j + 1]
                     int tmp = nums[j];
                     nums[j] = nums[j + 1];
                     nums[j + 1] = tmp;
-                    count += 3; // Element swap includes 3 unit operations
+                    count += 3; // Swapping two elements takes 3 elementary operations
                 }
             }
         }
         return count;
     }
 
-    /* Exponential order (loop implementation) */
+    /* Exponential complexity (iterative implementation) */
     static int exponential(int n) {
         int count = 0, base = 1;
-        // Cells divide into two every round, forming sequence 1, 2, 4, 8, ..., 2^(n-1)
+        // Each cell divides into two per round, giving the sequence 1, 2, 4, 8, ..., 2^(n-1)
         for (int i = 0; i < n; i++) {
             for (int j = 0; j < base; j++) {
                 count++;
@@ -79,14 +79,14 @@ public class time_complexity {
         return count;
     }
 
-    /* Exponential order (recursive implementation) */
+    /* Exponential complexity (recursive implementation) */
     static int expRecur(int n) {
         if (n == 1)
             return 1;
         return expRecur(n - 1) + expRecur(n - 1) + 1;
     }
 
-    /* Logarithmic order (loop implementation) */
+    /* Logarithmic complexity (iterative implementation) */
     static int logarithmic(int n) {
         int count = 0;
         while (n > 1) {
@@ -96,14 +96,14 @@ public class time_complexity {
         return count;
     }
 
-    /* Logarithmic order (recursive implementation) */
+    /* Logarithmic complexity (recursive implementation) */
     static int logRecur(int n) {
         if (n <= 1)
             return 0;
         return logRecur(n / 2) + 1;
     }
 
-    /* Linearithmic order */
+    /* Linearithmic complexity */
     static int linearLogRecur(int n) {
         if (n <= 1)
             return 1;
@@ -114,54 +114,54 @@ public class time_complexity {
         return count;
     }
 
-    /* Factorial order (recursive implementation) */
+    /* Factorial complexity (recursive implementation) */
     static int factorialRecur(int n) {
         if (n == 0)
             return 1;
         int count = 0;
-        // Split from 1 into n
+        // Split one problem into n subproblems
         for (int i = 0; i < n; i++) {
             count += factorialRecur(n - 1);
         }
         return count;
     }
 
-    /* Driver Code */
+    /* Driver code */
     public static void main(String[] args) {
-        // You can modify n to run and observe the trend of the number of operations for various complexities
+        // Try different values of n to see how the operation count grows for each complexity
         int n = 8;
-        System.out.println("Input data size n = " + n);
+        System.out.println("Input size n = " + n);
 
         int count = constant(n);
-        System.out.println("Constant order operation count = " + count);
+        System.out.println("Operation count for constant complexity = " + count);
 
         count = linear(n);
-        System.out.println("Linear order operation count = " + count);
+        System.out.println("Operation count for linear complexity = " + count);
         count = arrayTraversal(new int[n]);
-        System.out.println("Linear order (array traversal) operation count = " + count);
+        System.out.println("Operation count for linear complexity (array traversal) = " + count);
 
         count = quadratic(n);
-        System.out.println("Quadratic order operation count = " + count);
+        System.out.println("Operation count for quadratic complexity = " + count);
         int[] nums = new int[n];
         for (int i = 0; i < n; i++)
             nums[i] = n - i; // [n,n-1,...,2,1]
         count = bubbleSort(nums);
-        System.out.println("Quadratic order (bubble sort) operation count = " + count);
+        System.out.println("Operation count for quadratic complexity (bubble sort) = " + count);
 
         count = exponential(n);
-        System.out.println("Exponential order (loop implementation) operation count = " + count);
+        System.out.println("Operation count for exponential complexity (iterative implementation) = " + count);
         count = expRecur(n);
-        System.out.println("Exponential order (recursive implementation) operation count = " + count);
+        System.out.println("Operation count for exponential complexity (recursive implementation) = " + count);
 
         count = logarithmic(n);
-        System.out.println("Logarithmic order (loop implementation) operation count = " + count);
+        System.out.println("Operation count for logarithmic complexity (iterative implementation) = " + count);
         count = logRecur(n);
-        System.out.println("Logarithmic order (recursive implementation) operation count = " + count);
+        System.out.println("Operation count for logarithmic complexity (recursive implementation) = " + count);
 
         count = linearLogRecur(n);
-        System.out.println("Linearithmic order (recursive implementation) operation count = " + count);
+        System.out.println("Operation count for linearithmic complexity (recursive implementation) = " + count);
 
         count = factorialRecur(n);
-        System.out.println("Factorial order (recursive implementation) operation count = " + count);
+        System.out.println("Operation count for factorial complexity (recursive implementation) = " + count);
     }
 }