Format the Java codes with the Reat Hat extension.

codes/java/chapter_sorting/bubble_sort.java

@@ -25,7 +25,7 @@ public class bubble_sort {
         }
     }
 
-    /* 冒泡排序（标志优化）*/
+    /* 冒泡排序（标志优化） */
     static void bubbleSortWithFlag(int[] nums) {
         // 外循环：待排序元素数量为 n-1, n-2, ..., 1
         for (int i = nums.length - 1; i > 0; i--) {
@@ -37,10 +37,11 @@ public class bubble_sort {
                     int tmp = nums[j];
                     nums[j] = nums[j + 1];
                     nums[j + 1] = tmp;
-                    flag = true;  // 记录交换元素
+                    flag = true; // 记录交换元素
                 }
             }
-            if (!flag) break;     // 此轮冒泡未交换任何元素，直接跳出
+            if (!flag)
+                break; // 此轮冒泡未交换任何元素，直接跳出
         }
     }
 

codes/java/chapter_sorting/counting_sort.java

@@ -70,7 +70,7 @@ public class counting_sort {
         int[] nums = { 1, 0, 1, 2, 0, 4, 0, 2, 2, 4 };
         countingSortNaive(nums);
         System.out.println("计数排序（无法排序对象）完成后 nums = " + Arrays.toString(nums));
-        
+
         int[] nums1 = { 1, 0, 1, 2, 0, 4, 0, 2, 2, 4 };
         countingSort(nums1);
         System.out.println("计数排序完成后 nums1 = " + Arrays.toString(nums1));

codes/java/chapter_sorting/insertion_sort.java

@@ -16,10 +16,10 @@ public class insertion_sort {
             int base = nums[i], j = i - 1;
             // 内循环：将 base 插入到左边的正确位置
             while (j >= 0 && nums[j] > base) {
-                nums[j + 1] = nums[j];  // 1. 将 nums[j] 向右移动一位
+                nums[j + 1] = nums[j]; // 1. 将 nums[j] 向右移动一位
                 j--;
             }
-            nums[j + 1] = base;         // 2. 将 base 赋值到正确位置
+            nums[j + 1] = base;        // 2. 将 base 赋值到正确位置
         }
     }
 

codes/java/chapter_sorting/merge_sort.java

@@ -14,13 +14,13 @@ public class merge_sort {
     // 右子数组区间 [mid + 1, right]
     static void merge(int[] nums, int left, int mid, int right) {
         // 初始化辅助数组
-        int[] tmp = Arrays.copyOfRange(nums, left, right + 1);   
-        // 左子数组的起始索引和结束索引  
+        int[] tmp = Arrays.copyOfRange(nums, left, right + 1);
+        // 左子数组的起始索引和结束索引
         int leftStart = left - left, leftEnd = mid - left;
-        // 右子数组的起始索引和结束索引       
+        // 右子数组的起始索引和结束索引
         int rightStart = mid + 1 - left, rightEnd = right - left;
         // i, j 分别指向左子数组、右子数组的首元素
-        int i = leftStart, j = rightStart;                
+        int i = leftStart, j = rightStart;
         // 通过覆盖原数组 nums 来合并左子数组和右子数组
         for (int k = left; k <= right; k++) {
             // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
@@ -38,7 +38,8 @@ public class merge_sort {
     /* 归并排序 */
     static void mergeSort(int[] nums, int left, int right) {
         // 终止条件
-        if (left >= right) return;       // 当子数组长度为 1 时终止递归
+        if (left >= right)
+            return;                      // 当子数组长度为 1 时终止递归
         // 划分阶段
         int mid = (left + right) / 2;    // 计算中点
         mergeSort(nums, left, mid);      // 递归左子数组

codes/java/chapter_sorting/quick_sort.java

@@ -119,7 +119,7 @@ class QuickSortTailCall {
             swap(nums, i, j); // 交换这两个元素
         }
         swap(nums, i, left);  // 将基准数交换至两子数组的分界线
-        return i; // 返回基准数的索引
+        return i;             // 返回基准数的索引
     }
 
     /* 快速排序（尾递归优化） */
@@ -130,8 +130,8 @@ class QuickSortTailCall {
             int pivot = partition(nums, left, right);
             // 对两个子数组中较短的那个执行快排
             if (pivot - left < right - pivot) {
-                quickSort(nums, left, pivot - 1);  // 递归排序左子数组
-                left = pivot + 1;  // 剩余待排序区间为 [pivot + 1, right]
+                quickSort(nums, left, pivot - 1); // 递归排序左子数组
+                left = pivot + 1; // 剩余待排序区间为 [pivot + 1, right]
             } else {
                 quickSort(nums, pivot + 1, right); // 递归排序右子数组
                 right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1]

codes/java/chapter_sorting/radix_sort.java

@@ -47,7 +47,8 @@ public class radix_sort {
         // 获取数组的最大元素，用于判断最大位数
         int m = Integer.MIN_VALUE;
         for (int num : nums)
-            if (num > m) m = num;
+            if (num > m)
+                m = num;
         // 按照从低位到高位的顺序遍历
         for (int exp = 1; exp <= m; exp *= 10)
             // 对数组元素的第 k 位执行计数排序
@@ -59,7 +60,7 @@ public class radix_sort {
 
     public static void main(String[] args) {
         // 基数排序
-        int[] nums = { 10546151, 35663510, 42865989, 34862445, 81883077, 
+        int[] nums = { 10546151, 35663510, 42865989, 34862445, 81883077,
                        88906420, 72429244, 30524779, 82060337, 63832996 };
         radixSort(nums);
         System.out.println("基数排序完成后 nums = " + Arrays.toString(nums));