Format the C code in Clang-Format Style: Microsoft

codes/c/chapter_sorting/bucket_sort.c

@@ -7,8 +7,7 @@
 #include "../include/include.h"
 
 /* 冒泡排序 */
-void bucketSort(double nums[], int size)
-{
+void bucketSort(double nums[], int size) {
     // 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素
     int k = size / 2;
     // 1. 将数组元素分配到各个桶中
@@ -23,18 +22,13 @@ void bucketSort(double nums[], int size)
 }
 
 /* Driver Code */
-int main()
-{
+int main() {
     // 设输入数据为浮点数，范围为 [0, 1)
     double nums[] = {0.49, 0.96, 0.82, 0.09, 0.57, 0.43, 0.91, 0.75, 0.15, 0.37};
     int size = sizeof(nums) / sizeof(double);
     bucketSort(nums, size);
 
     printf("桶排序完成后 nums = ");
-    printf("[");
-    for (int i = 0; i < size - 1; i++)
-    {
-        printf("%g, ", nums[i]);
-    }
-    printf("]");
-}
+    printArray(nums, size);
+
+}

codes/c/chapter_sorting/counting_sort.c

@@ -58,7 +58,7 @@ void countingSort(int nums[], int size) {
     for (int i = size - 1; i >= 0; i--) {
         int num = nums[i];
         res[counter[num] - 1] = num; // 将 num 放置到对应索引处
-        counter[num]--; // 令前缀和自减 1 ，得到下次放置 num 的索引
+        counter[num]--;              // 令前缀和自减 1 ，得到下次放置 num 的索引
     }
     // 使用结果数组 res 覆盖原数组 nums
     memcpy(nums, res, size * sizeof(int));

codes/c/chapter_sorting/insertion_sort.c

@@ -9,18 +9,16 @@
 /* 插入排序 */
 void insertionSort(int nums[], int size) {
     // 外循环：base = nums[1], nums[2], ..., nums[n-1]
-    for (int i = 1; i < size; i++)
-    {
+    for (int i = 1; i < size; i++) {
         int base = nums[i], j = i - 1;
         // 内循环：将 base 插入到左边的正确位置
-        while (j >= 0 && nums[j] > base)
-        {
+        while (j >= 0 && nums[j] > base) {
             // 1. 将 nums[j] 向右移动一位
-            nums[j + 1] = nums[j]; 
+            nums[j + 1] = nums[j];
             j--;
         }
         // 2. 将 base 赋值到正确位置
-        nums[j + 1] = base; 
+        nums[j + 1] = base;
     }
 }
 
@@ -29,8 +27,7 @@ int main() {
     int nums[] = {4, 1, 3, 1, 5, 2};
     insertionSort(nums, 6);
     printf("插入排序完成后 nums = ");
-    for (int i = 0; i < 6; i++)
-    {
+    for (int i = 0; i < 6; i++) {
         printf("%d ", nums[i]);
     }
     printf("\n");

codes/c/chapter_sorting/merge_sort.c

@@ -13,15 +13,15 @@ void merge(int *nums, int left, int mid, int right) {
     int index;
     // 初始化辅助数组
     int tmp[right + 1 - left];
-    for(index = left; index < right + 1; index++) {
+    for (index = left; index < right + 1; index++) {
         tmp[index - left] = nums[index];
     }
-    // 左子数组的起始索引和结束索引  
+    // 左子数组的起始索引和结束索引
     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++
@@ -39,7 +39,8 @@ void merge(int *nums, int left, int mid, int right) {
 /* 归并排序 */
 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);      // 递归左子数组
@@ -51,10 +52,11 @@ void mergeSort(int *nums, int left, int right) {
 /* Driver Code */
 int main() {
     /* 归并排序 */
-    int nums[] = { 7, 3, 2, 6, 0, 1, 5, 4 };
+    int nums[] = {7, 3, 2, 6, 0, 1, 5, 4};
     int size = sizeof(nums) / sizeof(int);
     mergeSort(nums, 0, size - 1);
     printf("归并排序完成后 nums = ");
     printArray(nums, size);
+
     return 0;
 }

codes/c/chapter_sorting/quick_sort.c

@@ -72,13 +72,13 @@ int quickSortMedianPartition(int nums[], int left, int right) {
     int i = left, j = right;
     while (i < j) {
         while (i < j && nums[j] >= nums[left])
-            j--;          // 从右向左找首个小于基准数的元素
+            j--; // 从右向左找首个小于基准数的元素
         while (i < j && nums[i] <= nums[left])
             i++;          // 从左向右找首个大于基准数的元素
         swap(nums, i, j); // 交换这两个元素
     }
-    swap(nums, i, left);  // 将基准数交换至两子数组的分界线
-    return i;             // 返回基准数的索引
+    swap(nums, i, left); // 将基准数交换至两子数组的分界线
+    return i;            // 返回基准数的索引
 }
 
 // 中位基准数优化-快速排序
@@ -93,7 +93,6 @@ void quickSortMedian(int nums[], int left, int right) {
     quickSortMedian(nums, pivot + 1, right);
 }
 
-
 /* 快速排序类（尾递归优化） */
 /* 尾递归优化-哨兵划分 */
 int quickSortTailCallPartition(int nums[], int left, int right) {
@@ -101,16 +100,15 @@ int quickSortTailCallPartition(int nums[], int left, int right) {
     int i = left, j = right;
     while (i < j) {
         while (i < j && nums[j] >= nums[left])
-            j--;          // 从右向左找首个小于基准数的元素
+            j--; // 从右向左找首个小于基准数的元素
         while (i < j && nums[i] <= nums[left])
             i++;          // 从左向右找首个大于基准数的元素
         swap(nums, i, j); // 交换这两个元素
     }
-    swap(nums, i, left);  // 将基准数交换至两子数组的分界线
-    return i; // 返回基准数的索引
+    swap(nums, i, left); // 将基准数交换至两子数组的分界线
+    return i;            // 返回基准数的索引
 }
 
-
 // 快速排序（尾递归优化）
 void quickSortTailCall(int nums[], int left, int right) {
     // 子数组长度为 1 时终止
@@ -119,16 +117,15 @@ void quickSortTailCall(int nums[], int left, int right) {
         int pivot = quickSortTailCallPartition(nums, left, right);
         // 对两个子数组中较短的那个执行快排
         if (pivot - left < right - pivot) {
-            quickSortTailCall(nums, left, pivot - 1);  // 递归排序左子数组
-            left = pivot + 1;  // 剩余待排序区间为 [pivot + 1, right]
+            quickSortTailCall(nums, left, pivot - 1); // 递归排序左子数组
+            left = pivot + 1;                         // 剩余待排序区间为 [pivot + 1, right]
         } else {
             quickSortTailCall(nums, pivot + 1, right); // 递归排序右子数组
-            right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1]
+            right = pivot - 1;                         // 剩余待排序区间为 [left, pivot - 1]
         }
     }
 }
 
-
 /* Driver Code */
 int main() {
     /* 快速排序 */

codes/c/chapter_sorting/radix_sort.c

@@ -15,7 +15,7 @@ int digit(int num, int exp) {
 /* 计数排序（根据 nums 第 k 位排序） */
 void countingSortDigit(int nums[], int size, int exp) {
     // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
-    int *counter = (int *) malloc((sizeof(int) * 10));
+    int *counter = (int *)malloc((sizeof(int) * 10));
     // 统计 0~9 各数字的出现次数
     for (int i = 0; i < size; i++) {
         // 获取 nums[i] 第 k 位，记为 d
@@ -28,11 +28,11 @@ void countingSortDigit(int nums[], int size, int exp) {
         counter[i] += counter[i - 1];
     }
     // 倒序遍历，根据桶内统计结果，将各元素填入 res
-    int *res = (int *) malloc(sizeof(int) * size);
+    int *res = (int *)malloc(sizeof(int) * size);
     for (int i = size - 1; i >= 0; i--) {
         int d = digit(nums[i], exp);
         int j = counter[d] - 1; // 获取 d 在数组中的索引 j
-        res[j] = nums[i];      // 将当前元素填入索引 j
+        res[j] = nums[i];       // 将当前元素填入索引 j
         counter[d]--;           // 将 d 的数量减 1
     }
     // 使用结果覆盖原数组 nums
@@ -59,12 +59,13 @@ void radixSort(int nums[], int size) {
         countingSortDigit(nums, size, exp);
 }
 
+/* Driver Code */
 int main() {
     // 基数排序
-    int nums[] = {10546151, 35663510, 42865989, 34862445, 81883077, 
+    int nums[] = {10546151, 35663510, 42865989, 34862445, 81883077,
                   88906420, 72429244, 30524779, 82060337, 63832996};
     int size = sizeof(nums) / sizeof(int);
     radixSort(nums, size);
     printf("基数排序完成后 nums = ");
     printArray(nums, size);
-}
+}