Format C++ codes in Clang-Format Style: Microsoft

codes/cpp/chapter_sorting/bubble_sort.cpp

@@ -7,7 +7,7 @@
 #include "../include/include.hpp"
 
 /* 冒泡排序 */
-void bubbleSort(vector<int>& nums) {
+void bubbleSort(vector<int> &nums) {
     // 外循环：待排序元素数量为 n-1, n-2, ..., 1
     for (int i = nums.size() - 1; i > 0; i--) {
         // 内循环：冒泡操作
@@ -22,7 +22,7 @@ void bubbleSort(vector<int>& nums) {
 }
 
 /* 冒泡排序（标志优化）*/
-void bubbleSortWithFlag(vector<int>& nums) {
+void bubbleSortWithFlag(vector<int> &nums) {
     // 外循环：待排序元素数量为 n-1, n-2, ..., 1
     for (int i = nums.size() - 1; i > 0; i--) {
         bool flag = false; // 初始化标志位
@@ -32,25 +32,25 @@ void bubbleSortWithFlag(vector<int>& nums) {
                 // 交换 nums[j] 与 nums[j + 1]
                 // 这里使用了 std::swap() 函数
                 swap(nums[j], nums[j + 1]);
-                flag = true;  // 记录交换元素
+                flag = true; // 记录交换元素
             }
         }
-        if (!flag) break;     // 此轮冒泡未交换任何元素，直接跳出
+        if (!flag)
+            break; // 此轮冒泡未交换任何元素，直接跳出
     }
 }
 
-
 /* Driver Code */
 int main() {
-    vector<int> nums = { 4, 1, 3, 1, 5, 2 };
+    vector<int> nums = {4, 1, 3, 1, 5, 2};
     bubbleSort(nums);
     cout << "冒泡排序完成后 nums = ";
-    PrintUtil::printVector(nums);
+    printVector(nums);
 
-    vector<int> nums1 = { 4, 1, 3, 1, 5, 2 };
+    vector<int> nums1 = {4, 1, 3, 1, 5, 2};
     bubbleSortWithFlag(nums1);
     cout << "冒泡排序完成后 nums1 = ";
-    PrintUtil::printVector(nums1);
+    printVector(nums1);
 
     return 0;
 }

codes/cpp/chapter_sorting/bucket_sort.cpp

@@ -7,44 +7,38 @@
 #include "../include/include.hpp"
 
 /* 桶排序 */
-void bucketSort(vector<float> &nums)
-{
+void bucketSort(vector<float> &nums) {
     // 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素
     int k = nums.size() / 2;
     vector<vector<float>> buckets(k);
     // 1. 将数组元素分配到各个桶中
-    for (float num : nums)
-    {
+    for (float num : nums) {
         // 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
         int i = num * k;
         // 将 num 添加进桶 bucket_idx
         buckets[i].push_back(num);
     }
     // 2. 对各个桶执行排序
-    for (vector<float> &bucket : buckets)
-    {
+    for (vector<float> &bucket : buckets) {
         // 使用内置排序函数，也可以替换成其他排序算法
         sort(bucket.begin(), bucket.end());
     }
     // 3. 遍历桶合并结果
     int i = 0;
-    for (vector<float> &bucket : buckets)
-    {
-        for (float num : bucket)
-        {
+    for (vector<float> &bucket : buckets) {
+        for (float num : bucket) {
             nums[i++] = num;
         }
     }
 }
 
 /* Driver Code */
-int main()
-{
+int main() {
     // 设输入数据为浮点数，范围为 [0, 1)
     vector<float> nums = {0.49f, 0.96f, 0.82f, 0.09f, 0.57f, 0.43f, 0.91f, 0.75f, 0.15f, 0.37f};
     bucketSort(nums);
     cout << "桶排序完成后 nums = ";
-    PrintUtil::printVector(nums);
+    printVector(nums);
 
     return 0;
 }

codes/cpp/chapter_sorting/counting_sort.cpp

@@ -8,7 +8,7 @@
 
 /* 计数排序 */
 // 简单实现，无法用于排序对象
-void countingSortNaive(vector<int>& nums) {
+void countingSortNaive(vector<int> &nums) {
     // 1. 统计数组最大元素 m
     int m = 0;
     for (int num : nums) {
@@ -31,7 +31,7 @@ void countingSortNaive(vector<int>& nums) {
 
 /* 计数排序 */
 // 完整实现，可排序对象，并且是稳定排序
-void countingSort(vector<int>& nums) {
+void countingSort(vector<int> &nums) {
     // 1. 统计数组最大元素 m
     int m = 0;
     for (int num : nums) {
@@ -55,7 +55,7 @@ void countingSort(vector<int>& nums) {
     for (int i = n - 1; i >= 0; i--) {
         int num = nums[i];
         res[counter[num] - 1] = num; // 将 num 放置到对应索引处
-        counter[num]--; // 令前缀和自减 1 ，得到下次放置 num 的索引
+        counter[num]--;              // 令前缀和自减 1 ，得到下次放置 num 的索引
     }
     // 使用结果数组 res 覆盖原数组 nums
     nums = res;
@@ -63,15 +63,15 @@ void countingSort(vector<int>& nums) {
 
 /* Driver Code */
 int main() {
-    vector<int> nums = { 1, 0, 1, 2, 0, 4, 0, 2, 2, 4 };
+    vector<int> nums = {1, 0, 1, 2, 0, 4, 0, 2, 2, 4};
     countingSortNaive(nums);
     cout << "计数排序（无法排序对象）完成后 nums = ";
-    PrintUtil::printVector(nums);
+    printVector(nums);
 
-    vector<int> nums1 = { 1, 0, 1, 2, 0, 4, 0, 2, 2, 4 };
+    vector<int> nums1 = {1, 0, 1, 2, 0, 4, 0, 2, 2, 4};
     countingSort(nums1);
     cout << "计数排序完成后 nums1 = ";
-    PrintUtil::printVector(nums1);
+    printVector(nums1);
 
     return 0;
 }

codes/cpp/chapter_sorting/insertion_sort.cpp

@@ -7,26 +7,25 @@
 #include "../include/include.hpp"
 
 /* 插入排序 */
-void insertionSort(vector<int>& nums) {
+void insertionSort(vector<int> &nums) {
     // 外循环：base = nums[1], nums[2], ..., nums[n-1]
     for (int i = 1; i < nums.size(); i++) {
         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 赋值到正确位置
     }
 }
 
-
 /* Driver Code */
 int main() {
-    vector<int> nums = { 4, 1, 3, 1, 5, 2 };
+    vector<int> nums = {4, 1, 3, 1, 5, 2};
     insertionSort(nums);
     cout << "插入排序完成后 nums = ";
-    PrintUtil::printVector(nums);
+    printVector(nums);
 
     return 0;
 }

codes/cpp/chapter_sorting/merge_sort.cpp

@@ -9,15 +9,15 @@
 /* 合并左子数组和右子数组 */
 // 左子数组区间 [left, mid]
 // 右子数组区间 [mid + 1, right]
-void merge(vector<int>& nums, int left, int mid, int right) {
+void merge(vector<int> &nums, int left, int mid, int right) {
     // 初始化辅助数组
-    vector<int> tmp(nums.begin() + left, nums.begin() + right + 1);   
-    // 左子数组的起始索引和结束索引  
+    vector<int> tmp(nums.begin() + left, nums.begin() + 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++
@@ -33,9 +33,10 @@ void merge(vector<int>& nums, int left, int mid, int right) {
 }
 
 /* 归并排序 */
-void mergeSort(vector<int>& nums, int left, int right) {
+void mergeSort(vector<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);      // 递归左子数组
@@ -44,14 +45,13 @@ void mergeSort(vector<int>& nums, int left, int right) {
     merge(nums, left, mid, right);
 }
 
-
 /* Driver Code */
 int main() {
     /* 归并排序 */
-    vector<int> nums = { 7, 3, 2, 6, 0, 1, 5, 4 };
+    vector<int> nums = {7, 3, 2, 6, 0, 1, 5, 4};
     mergeSort(nums, 0, nums.size() - 1);
     cout << "归并排序完成后 nums = ";
-    PrintUtil::printVector(nums);
+    printVector(nums);
 
     return 0;
 }

codes/cpp/chapter_sorting/quick_sort.cpp

@@ -8,32 +8,32 @@
 
 /* 快速排序类 */
 class QuickSort {
-private:
+  private:
     /* 元素交换 */
-    static void swap(vector<int>& nums, int i, int j) {
+    static void swap(vector<int> &nums, int i, int j) {
         int tmp = nums[i];
         nums[i] = nums[j];
         nums[j] = tmp;
     }
 
     /* 哨兵划分 */
-    static int partition(vector<int>& nums, int left, int right) {
+    static int partition(vector<int> &nums, int left, int right) {
         // 以 nums[left] 作为基准数
         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;            // 返回基准数的索引
     }
 
-public:
+  public:
     /* 快速排序 */
-    static void quickSort(vector<int>& nums, int left, int right) {
+    static void quickSort(vector<int> &nums, int left, int right) {
         // 子数组长度为 1 时终止递归
         if (left >= right)
             return;
@@ -47,16 +47,16 @@ public:
 
 /* 快速排序类（中位基准数优化） */
 class QuickSortMedian {
-private:
+  private:
     /* 元素交换 */
-    static void swap(vector<int>& nums, int i, int j) {
+    static void swap(vector<int> &nums, int i, int j) {
         int tmp = nums[i];
         nums[i] = nums[j];
         nums[j] = tmp;
     }
 
     /* 选取三个元素的中位数 */
-    static int medianThree(vector<int>& nums, int left, int mid, int right) {
+    static int medianThree(vector<int> &nums, int left, int mid, int right) {
         // 此处使用异或运算来简化代码
         // 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1
         if ((nums[left] < nums[mid]) ^ (nums[left] < nums[right]))
@@ -68,7 +68,7 @@ private:
     }
 
     /* 哨兵划分（三数取中值） */
-    static int partition(vector<int>& nums, int left, int right) {
+    static int partition(vector<int> &nums, int left, int right) {
         // 选取三个候选元素的中位数
         int med = medianThree(nums, left, (left + right) / 2, right);
         // 将中位数交换至数组最左端
@@ -77,18 +77,18 @@ private:
         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;            // 返回基准数的索引
     }
 
-public:
+  public:
     /* 快速排序 */
-    static void quickSort(vector<int>& nums, int left, int right) {
+    static void quickSort(vector<int> &nums, int left, int right) {
         // 子数组长度为 1 时终止递归
         if (left >= right)
             return;
@@ -102,68 +102,67 @@ public:
 
 /* 快速排序类（尾递归优化） */
 class QuickSortTailCall {
-private:
+  private:
     /* 元素交换 */
-    static void swap(vector<int>& nums, int i, int j) {
+    static void swap(vector<int> &nums, int i, int j) {
         int tmp = nums[i];
         nums[i] = nums[j];
         nums[j] = tmp;
     }
 
     /* 哨兵划分 */
-    static int partition(vector<int>& nums, int left, int right) {
+    static int partition(vector<int> &nums, int left, int right) {
         // 以 nums[left] 作为基准数
         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;            // 返回基准数的索引
     }
 
-public:
+  public:
     /* 快速排序（尾递归优化） */
-    static void quickSort(vector<int>& nums, int left, int right) {
+    static void quickSort(vector<int> &nums, int left, int right) {
         // 子数组长度为 1 时终止
         while (left < right) {
             // 哨兵划分操作
             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]
+                right = pivot - 1;                 // 剩余待排序区间为 [left, pivot - 1]
             }
         }
     }
 };
 
-
 /* Driver Code */
 int main() {
     /* 快速排序 */
-    vector<int> nums { 2, 4, 1, 0, 3, 5 };
+    vector<int> nums{2, 4, 1, 0, 3, 5};
     QuickSort::quickSort(nums, 0, nums.size() - 1);
     cout << "快速排序完成后 nums = ";
-    PrintUtil::printVector(nums);
+    printVector(nums);
 
     /* 快速排序（中位基准数优化） */
-    vector<int> nums1 = { 2, 4, 1, 0, 3, 5 };
+    vector<int> nums1 = {2, 4, 1, 0, 3, 5};
     QuickSortMedian::quickSort(nums1, 0, nums1.size() - 1);
     cout << "快速排序（中位基准数优化）完成后 nums = ";
-    PrintUtil::printVector(nums);
+    printVector(nums);
 
     /* 快速排序（尾递归优化） */
-    vector<int> nums2 = { 2, 4, 1, 0, 3, 5 };
+    vector<int> nums2 = {2, 4, 1, 0, 3, 5};
     QuickSortTailCall::quickSort(nums2, 0, nums2.size() - 1);
     cout << "快速排序（尾递归优化）完成后 nums = ";
-    PrintUtil::printVector(nums);
+    printVector(nums);
 
     return 0;
 }

codes/cpp/chapter_sorting/radix_sort.cpp

@@ -14,7 +14,7 @@ int digit(int num, int exp) {
 }
 
 /* 计数排序（根据 nums 第 k 位排序） */
-void countingSortDigit(vector<int>& nums, int exp) {
+void countingSortDigit(vector<int> &nums, int exp) {
     // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
     vector<int> counter(10, 0);
     int n = nums.size();
@@ -41,7 +41,7 @@ void countingSortDigit(vector<int>& nums, int exp) {
 }
 
 /* 基数排序 */
-void radixSort(vector<int>& nums) {
+void radixSort(vector<int> &nums) {
     // 获取数组的最大元素，用于判断最大位数
     int m = *max_element(nums.begin(), nums.end());
     // 按照从低位到高位的顺序遍历
@@ -56,11 +56,11 @@ void radixSort(vector<int>& nums) {
 /* Driver Code */
 int main() {
     // 基数排序
-    vector<int> nums = { 10546151, 35663510, 42865989, 34862445, 81883077, 
-                         88906420, 72429244, 30524779, 82060337, 63832996 };
+    vector<int> nums = {10546151, 35663510, 42865989, 34862445, 81883077,
+                        88906420, 72429244, 30524779, 82060337, 63832996};
     radixSort(nums);
     cout << "基数排序完成后 nums = ";
-    PrintUtil::printVector(nums);
+    printVector(nums);
 
     return 0;
 }