translation: update insertion_sort.md

en/docs/chapter_sorting/insertion_sort.md

@@ -2,20 +2,20 @@
 
 <u>Insertion sort</u> is a simple sorting algorithm that works very much like the process of manually sorting a deck of cards.
 
-Specifically, we select a pivot element from the unsorted interval, compare it with the elements in the sorted interval to its left, and insert the element into the correct position.
+Specifically, we select a key element from the unsorted interval, compare it with the elements in the sorted interval to its left, and insert the element into the correct position.
 
-The figure below shows the process of inserting an element into an array. Assuming the pivot element is `base`, we need to move all elements between the target index and `base` one position to the right, then assign `base` to the target index.
+The figure below illustrates how an element is inserted into the array. Assuming the key element is `base`, we need to shift all elements from the target index up to `base` one position to the right, then assign `base` to the target index.
 
 ![Single insertion operation](insertion_sort.assets/insertion_operation.png)
 
-## Algorithm process
+## Algorithm steps
 
 The overall process of insertion sort is shown in the figure below.
 
-1. Initially, the first element of the array is sorted.
-2. The second element of the array is taken as `base`, and after inserting it into the correct position, **the first two elements of the array are sorted**.
-3. The third element is taken as `base`, and after inserting it into the correct position, **the first three elements of the array are sorted**.
-4. And so on, in the last round, the last element is taken as `base`, and after inserting it into the correct position, **all elements are sorted**.
+1. Consider the first element of the array as sorted.
+2. Select the second element as `base`, insert it into its correct position, **leaving the first two elements sorted**.
+3. Select the third element as `base`, insert it into its correct position, **leaving the first three elements sorted**.
+4. Continuing in this manner, in the final iteration, the last element is taken as `base`, and after inserting it into the correct position, **all elements are sorted**.
 
 ![Insertion sort process](insertion_sort.assets/insertion_sort_overview.png)
 
@@ -33,13 +33,13 @@ Example code is as follows:
 
 ## Advantages of insertion sort
 
-The time complexity of insertion sort is $O(n^2)$, while the time complexity of quicksort, which we will study next, is $O(n \log n)$. Although insertion sort has a higher time complexity, **it is usually faster in cases of small data volumes**.
+The time complexity of insertion sort is $O(n^2)$, while the time complexity of quicksort, which we will study next, is $O(n \log n)$. Although insertion sort has a higher time complexity, **it is usually faster in small input sizes**.
 
-This conclusion is similar to that for linear and binary search. Algorithms like quicksort that have a time complexity of $O(n \log n)$ and are based on the divide-and-conquer strategy often involve more unit operations. In cases of small data volumes, the numerical values of $n^2$ and $n \log n$ are close, and complexity does not dominate, with the number of unit operations per round playing a decisive role.
+This conclusion is similar to that for linear and binary search. Algorithms like quicksort that have a time complexity of $O(n \log n)$ and are based on the divide-and-conquer strategy often involve more unit operations. For small input sizes, the numerical values of $n^2$ and $n \log n$ are close, and complexity does not dominate, with the number of unit operations per round playing a decisive role.
 
-In fact, many programming languages (such as Java) use insertion sort in their built-in sorting functions. The general approach is: for long arrays, use sorting algorithms based on divide-and-conquer strategies, such as quicksort; for short arrays, use insertion sort directly.
+In fact, many programming languages (such as Java) use insertion sort within their built-in sorting functions. The general approach is: for long arrays, use sorting algorithms based on divide-and-conquer strategies, such as quicksort; for short arrays, use insertion sort directly.
 
-Although bubble sort, selection sort, and insertion sort all have a time complexity of $O(n^2)$, in practice, **insertion sort is used significantly more frequently than bubble sort and selection sort**, mainly for the following reasons.
+Although bubble sort, selection sort, and insertion sort all have a time complexity of $O(n^2)$, in practice, **insertion sort is commonly used than bubble sort and selection sort**, mainly for the following reasons.
 
 - Bubble sort is based on element swapping, which requires the use of a temporary variable, involving 3 unit operations; insertion sort is based on element assignment, requiring only 1 unit operation. Therefore, **the computational overhead of bubble sort is generally higher than that of insertion sort**.
 - The time complexity of selection sort is always $O(n^2)$. **Given a set of partially ordered data, insertion sort is usually more efficient than selection sort**.