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

codes/cpp/chapter_tree/avl_tree.cpp

@@ -8,19 +8,19 @@
 
 /* AVL 树 */
 class AVLTree {
-public:
-    TreeNode* root;  // 根节点
-private:
+  public:
+    TreeNode *root; // 根节点
+  private:
     /* 更新节点高度 */
-    void updateHeight(TreeNode* node) {
+    void updateHeight(TreeNode *node) {
         // 节点高度等于最高子树高度 + 1
         node->height = max(height(node->left), height(node->right)) + 1;
     }
 
     /* 右旋操作 */
-    TreeNode* rightRotate(TreeNode* node) {
-        TreeNode* child = node->left;
-        TreeNode* grandChild = child->right;
+    TreeNode *rightRotate(TreeNode *node) {
+        TreeNode *child = node->left;
+        TreeNode *grandChild = child->right;
         // 以 child 为原点，将 node 向右旋转
         child->right = node;
         node->left = grandChild;
@@ -32,9 +32,9 @@ private:
     }
 
     /* 左旋操作 */
-    TreeNode* leftRotate(TreeNode* node) {
-        TreeNode* child = node->right;
-        TreeNode* grandChild = child->left;
+    TreeNode *leftRotate(TreeNode *node) {
+        TreeNode *child = node->right;
+        TreeNode *grandChild = child->left;
         // 以 child 为原点，将 node 向左旋转
         child->left = node;
         node->right = grandChild;
@@ -46,7 +46,7 @@ private:
     }
 
     /* 执行旋转操作，使该子树重新恢复平衡 */
-    TreeNode* rotate(TreeNode* node) {
+    TreeNode *rotate(TreeNode *node) {
         // 获取节点 node 的平衡因子
         int _balanceFactor = balanceFactor(node);
         // 左偏树
@@ -76,7 +76,7 @@ private:
     }
 
     /* 递归插入节点（辅助方法） */
-    TreeNode* insertHelper(TreeNode* node, int val) {
+    TreeNode *insertHelper(TreeNode *node, int val) {
         if (node == nullptr)
             return new TreeNode(val);
         /* 1. 查找插入位置，并插入节点 */
@@ -85,8 +85,8 @@ private:
         else if (val > node->val)
             node->right = insertHelper(node->right, val);
         else
-            return node;     // 重复节点不插入，直接返回
-        updateHeight(node);  // 更新节点高度
+            return node;    // 重复节点不插入，直接返回
+        updateHeight(node); // 更新节点高度
         /* 2. 执行旋转操作，使该子树重新恢复平衡 */
         node = rotate(node);
         // 返回子树的根节点
@@ -94,7 +94,7 @@ private:
     }
 
     /* 获取中序遍历中的下一个节点（仅适用于 root 有左子节点的情况） */
-    TreeNode* getInOrderNext(TreeNode* node) {
+    TreeNode *getInOrderNext(TreeNode *node) {
         if (node == nullptr)
             return node;
         // 循环访问左子节点，直到叶节点时为最小节点，跳出
@@ -105,7 +105,7 @@ private:
     }
 
     /* 递归删除节点（辅助方法） */
-    TreeNode* removeHelper(TreeNode* node, int val) {
+    TreeNode *removeHelper(TreeNode *node, int val) {
         if (node == nullptr)
             return nullptr;
         /* 1. 查找节点，并删除之 */
@@ -115,7 +115,7 @@ private:
             node->right = removeHelper(node->right, val);
         else {
             if (node->left == nullptr || node->right == nullptr) {
-                TreeNode* child = node->left != nullptr ? node->left : node->right;
+                TreeNode *child = node->left != nullptr ? node->left : node->right;
                 // 子节点数量 = 0 ，直接删除 node 并返回
                 if (child == nullptr) {
                     delete node;
@@ -128,49 +128,50 @@ private:
                 }
             } else {
                 // 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
-                TreeNode* temp = getInOrderNext(node->right);
+                TreeNode *temp = getInOrderNext(node->right);
                 int tempVal = temp->val;
                 node->right = removeHelper(node->right, temp->val);
                 node->val = tempVal;
             }
         }
-        updateHeight(node);  // 更新节点高度
+        updateHeight(node); // 更新节点高度
         /* 2. 执行旋转操作，使该子树重新恢复平衡 */
         node = rotate(node);
         // 返回子树的根节点
         return node;
     }
 
-public:
+  public:
     /* 获取节点高度 */
-    int height(TreeNode* node) {
+    int height(TreeNode *node) {
         // 空节点高度为 -1 ，叶节点高度为 0
         return node == nullptr ? -1 : node->height;
     }
 
     /* 获取平衡因子 */
-    int balanceFactor(TreeNode* node) {
+    int balanceFactor(TreeNode *node) {
         // 空节点平衡因子为 0
-        if (node == nullptr) return 0;
+        if (node == nullptr)
+            return 0;
         // 节点平衡因子 = 左子树高度 - 右子树高度
         return height(node->left) - height(node->right);
     }
 
     /* 插入节点 */
-    TreeNode* insert(int val) {
+    TreeNode *insert(int val) {
         root = insertHelper(root, val);
         return root;
     }
 
     /* 删除节点 */
-    TreeNode* remove(int val) {
+    TreeNode *remove(int val) {
         root = removeHelper(root, val);
         return root;
     }
 
     /* 查找节点 */
-    TreeNode* search(int val) {
-        TreeNode* cur = root;
+    TreeNode *search(int val) {
+        TreeNode *cur = root;
         // 循环查找，越过叶节点后跳出
         while (cur != nullptr) {
             // 目标节点在 cur 的右子树中
@@ -188,7 +189,8 @@ public:
     }
 
     /*构造方法*/
-    AVLTree() : root(nullptr) {}
+    AVLTree() : root(nullptr) {
+    }
 
     /*析构方法*/
     ~AVLTree() {
@@ -196,16 +198,16 @@ public:
     }
 };
 
-void testInsert(AVLTree& tree, int val) {
+void testInsert(AVLTree &tree, int val) {
     tree.insert(val);
     cout << "\n插入节点 " << val << " 后，AVL 树为" << endl;
-    PrintUtil::printTree(tree.root);
+    printTree(tree.root);
 }
 
-void testRemove(AVLTree& tree, int val) {
+void testRemove(AVLTree &tree, int val) {
     tree.remove(val);
     cout << "\n删除节点 " << val << " 后，AVL 树为" << endl;
-    PrintUtil::printTree(tree.root);
+    printTree(tree.root);
 }
 int main() {
     /* 初始化空 AVL 树 */
@@ -229,11 +231,11 @@ int main() {
 
     /* 删除节点 */
     // 请关注删除节点后，AVL 树是如何保持平衡的
-    testRemove(avlTree, 8);  // 删除度为 0 的节点
-    testRemove(avlTree, 5);  // 删除度为 1 的节点
-    testRemove(avlTree, 4);  // 删除度为 2 的节点
+    testRemove(avlTree, 8); // 删除度为 0 的节点
+    testRemove(avlTree, 5); // 删除度为 1 的节点
+    testRemove(avlTree, 4); // 删除度为 2 的节点
 
     /* 查询节点 */
-    TreeNode* node = avlTree.search(7);
+    TreeNode *node = avlTree.search(7);
     cout << "\n查找到的节点对象为 " << node << "，节点值 = " << node->val << endl;
 }

codes/cpp/chapter_tree/binary_search_tree.cpp

@@ -8,13 +8,13 @@
 
 /* 二叉搜索树 */
 class BinarySearchTree {
-private:
-    TreeNode* root;
+  private:
+    TreeNode *root;
 
-public:
+  public:
     BinarySearchTree(vector<int> nums) {
-        sort(nums.begin(), nums.end()); // 排序数组
-        root = buildTree(nums, 0, nums.size() - 1);  // 构建二叉搜索树
+        sort(nums.begin(), nums.end());             // 排序数组
+        root = buildTree(nums, 0, nums.size() - 1); // 构建二叉搜索树
     }
 
     ~BinarySearchTree() {
@@ -22,16 +22,17 @@ public:
     }
 
     /* 获取二叉树根节点 */
-    TreeNode* getRoot() {
+    TreeNode *getRoot() {
         return root;
     }
 
     /* 构建二叉搜索树 */
-    TreeNode* buildTree(vector<int> nums, int i, int j) {
-        if (i > j) return nullptr;
+    TreeNode *buildTree(vector<int> nums, int i, int j) {
+        if (i > j)
+            return nullptr;
         // 将数组中间节点作为根节点
         int mid = (i + j) / 2;
-        TreeNode* root = new TreeNode(nums[mid]);
+        TreeNode *root = new TreeNode(nums[mid]);
         // 递归建立左子树和右子树
         root->left = buildTree(nums, i, mid - 1);
         root->right = buildTree(nums, mid + 1, j);
@@ -39,74 +40,90 @@ public:
     }
 
     /* 查找节点 */
-    TreeNode* search(int num) {
-        TreeNode* cur = root;
+    TreeNode *search(int num) {
+        TreeNode *cur = root;
         // 循环查找，越过叶节点后跳出
         while (cur != nullptr) {
             // 目标节点在 cur 的右子树中
-            if (cur->val < num) cur = cur->right;
+            if (cur->val < num)
+                cur = cur->right;
             // 目标节点在 cur 的左子树中
-            else if (cur->val > num) cur = cur->left;
+            else if (cur->val > num)
+                cur = cur->left;
             // 找到目标节点，跳出循环
-            else break;
+            else
+                break;
         }
         // 返回目标节点
         return cur;
     }
 
     /* 插入节点 */
-    TreeNode* insert(int num) {
+    TreeNode *insert(int num) {
         // 若树为空，直接提前返回
-        if (root == nullptr) return nullptr;
+        if (root == nullptr)
+            return nullptr;
         TreeNode *cur = root, *pre = nullptr;
         // 循环查找，越过叶节点后跳出
         while (cur != nullptr) {
             // 找到重复节点，直接返回
-            if (cur->val == num) return nullptr;
+            if (cur->val == num)
+                return nullptr;
             pre = cur;
             // 插入位置在 cur 的右子树中
-            if (cur->val < num) cur = cur->right;
+            if (cur->val < num)
+                cur = cur->right;
             // 插入位置在 cur 的左子树中
-            else cur = cur->left;
+            else
+                cur = cur->left;
         }
         // 插入节点 val
-        TreeNode* node = new TreeNode(num);
-        if (pre->val < num) pre->right = node;
-        else pre->left = node;
+        TreeNode *node = new TreeNode(num);
+        if (pre->val < num)
+            pre->right = node;
+        else
+            pre->left = node;
         return node;
     }
 
     /* 删除节点 */
-    TreeNode* remove(int num) {
+    TreeNode *remove(int num) {
         // 若树为空，直接提前返回
-        if (root == nullptr) return nullptr;
+        if (root == nullptr)
+            return nullptr;
         TreeNode *cur = root, *pre = nullptr;
         // 循环查找，越过叶节点后跳出
         while (cur != nullptr) {
             // 找到待删除节点，跳出循环
-            if (cur->val == num) break;
+            if (cur->val == num)
+                break;
             pre = cur;
             // 待删除节点在 cur 的右子树中
-            if (cur->val < num) cur = cur->right;
+            if (cur->val < num)
+                cur = cur->right;
             // 待删除节点在 cur 的左子树中
-            else cur = cur->left;
+            else
+                cur = cur->left;
         }
         // 若无待删除节点，则直接返回
-        if (cur == nullptr) return nullptr;
+        if (cur == nullptr)
+            return nullptr;
         // 子节点数量 = 0 or 1
         if (cur->left == nullptr || cur->right == nullptr) {
             // 当子节点数量 = 0 / 1 时， child = nullptr / 该子节点
-            TreeNode* child = cur->left != nullptr ? cur->left : cur->right;
+            TreeNode *child = cur->left != nullptr ? cur->left : cur->right;
             // 删除节点 cur
-            if (pre->left == cur) pre->left = child;
-            else pre->right = child;
+            if (pre->left == cur)
+                pre->left = child;
+            else
+                pre->right = child;
             // 释放内存
             delete cur;
         }
         // 子节点数量 = 2
         else {
             // 获取中序遍历中 cur 的下一个节点
-            TreeNode* nex = getInOrderNext(cur->right);
+            TreeNode *nex = getInOrderNext(cur->right);
             int tmp = nex->val;
             // 递归删除节点 nex
             remove(nex->val);
@@ -117,8 +134,9 @@ public:
     }
 
     /* 获取中序遍历中的下一个节点（仅适用于 root 有左子节点的情况） */
-    TreeNode* getInOrderNext(TreeNode* root) {
-        if (root == nullptr) return root;
+    TreeNode *getInOrderNext(TreeNode *root) {
+        if (root == nullptr)
+            return root;
         // 循环访问左子节点，直到叶节点时为最小节点，跳出
         while (root->left != nullptr) {
             root = root->left;
@@ -127,34 +145,33 @@ public:
     }
 };
 
-
 /* Driver Code */
 int main() {
     /* 初始化二叉搜索树 */
-    vector<int> nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
-    BinarySearchTree* bst = new BinarySearchTree(nums);
+    vector<int> nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
+    BinarySearchTree *bst = new BinarySearchTree(nums);
     cout << endl << "初始化的二叉树为\n" << endl;
-    PrintUtil::printTree(bst->getRoot());
+    printTree(bst->getRoot());
 
     /* 查找节点 */
-    TreeNode* node = bst->search(7);
+    TreeNode *node = bst->search(7);
     cout << endl << "查找到的节点对象为 " << node << "，节点值 = " << node->val << endl;
 
     /* 插入节点 */
     node = bst->insert(16);
     cout << endl << "插入节点 16 后，二叉树为\n" << endl;
-    PrintUtil::printTree(bst->getRoot());
+    printTree(bst->getRoot());
 
     /* 删除节点 */
     bst->remove(1);
     cout << endl << "删除节点 1 后，二叉树为\n" << endl;
-    PrintUtil::printTree(bst->getRoot());
+    printTree(bst->getRoot());
     bst->remove(2);
     cout << endl << "删除节点 2 后，二叉树为\n" << endl;
-    PrintUtil::printTree(bst->getRoot());
+    printTree(bst->getRoot());
     bst->remove(4);
     cout << endl << "删除节点 4 后，二叉树为\n" << endl;
-    PrintUtil::printTree(bst->getRoot());
+    printTree(bst->getRoot());
 
     // 释放内存
     delete bst;

codes/cpp/chapter_tree/binary_tree.cpp

@@ -6,36 +6,35 @@
 
 #include "../include/include.hpp"
 
-
 /* Driver Code */
 int main() {
     /* 初始化二叉树 */
     // 初始化节点
-    TreeNode* n1 = new TreeNode(1);
-    TreeNode* n2 = new TreeNode(2);
-    TreeNode* n3 = new TreeNode(3);
-    TreeNode* n4 = new TreeNode(4);
-    TreeNode* n5 = new TreeNode(5);
+    TreeNode *n1 = new TreeNode(1);
+    TreeNode *n2 = new TreeNode(2);
+    TreeNode *n3 = new TreeNode(3);
+    TreeNode *n4 = new TreeNode(4);
+    TreeNode *n5 = new TreeNode(5);
     // 构建引用指向（即指针）
     n1->left = n2;
     n1->right = n3;
     n2->left = n4;
     n2->right = n5;
     cout << endl << "初始化二叉树\n" << endl;
-    PrintUtil::printTree(n1);
+    printTree(n1);
 
     /* 插入与删除节点 */
-    TreeNode* P = new TreeNode(0);
+    TreeNode *P = new TreeNode(0);
     // 在 n1 -> n2 中间插入节点 P
     n1->left = P;
     P->left = n2;
     cout << endl << "插入节点 P 后\n" << endl;
-    PrintUtil::printTree(n1);
+    printTree(n1);
     // 删除节点 P
     n1->left = n2;
-    delete P;  // 释放内存
+    delete P; // 释放内存
     cout << endl << "删除节点 P 后\n" << endl;
-    PrintUtil::printTree(n1);
+    printTree(n1);
 
     // 释放内存
     freeMemoryTree(n1);

codes/cpp/chapter_tree/binary_tree_bfs.cpp

@@ -7,37 +7,36 @@
 #include "../include/include.hpp"
 
 /* 层序遍历 */
-vector<int> levelOrder(TreeNode* root) {
+vector<int> levelOrder(TreeNode *root) {
     // 初始化队列，加入根节点
-    queue<TreeNode*> queue;
+    queue<TreeNode *> queue;
     queue.push(root);
     // 初始化一个列表，用于保存遍历序列
     vector<int> vec;
     while (!queue.empty()) {
-        TreeNode* node = queue.front();
-        queue.pop();                 // 队列出队
-        vec.push_back(node->val);    // 保存节点值
+        TreeNode *node = queue.front();
+        queue.pop();              // 队列出队
+        vec.push_back(node->val); // 保存节点值
         if (node->left != nullptr)
-            queue.push(node->left);  // 左子节点入队
+            queue.push(node->left); // 左子节点入队
         if (node->right != nullptr)
             queue.push(node->right); // 右子节点入队
     }
     return vec;
 }
 
-
 /* Driver Code */
 int main() {
     /* 初始化二叉树 */
     // 这里借助了一个从数组直接生成二叉树的函数
-    TreeNode* root = vecToTree(vector<int> { 1, 2, 3, 4, 5, 6, 7 });
+    TreeNode *root = vecToTree(vector<int>{1, 2, 3, 4, 5, 6, 7});
     cout << endl << "初始化二叉树\n" << endl;
-    PrintUtil::printTree(root);
+    printTree(root);
 
     /* 层序遍历 */
     vector<int> vec = levelOrder(root);
     cout << endl << "层序遍历的节点打印序列 = ";
-    PrintUtil::printVector(vec);
+    printVector(vec);
 
     return 0;
 }

codes/cpp/chapter_tree/binary_tree_dfs.cpp

@@ -10,8 +10,9 @@
 vector<int> vec;
 
 /* 前序遍历 */
-void preOrder(TreeNode* root) {
-    if (root == nullptr) return;
+void preOrder(TreeNode *root) {
+    if (root == nullptr)
+        return;
     // 访问优先级：根节点 -> 左子树 -> 右子树
     vec.push_back(root->val);
     preOrder(root->left);
@@ -19,8 +20,9 @@ void preOrder(TreeNode* root) {
 }
 
 /* 中序遍历 */
-void inOrder(TreeNode* root) {
-    if (root == nullptr) return;
+void inOrder(TreeNode *root) {
+    if (root == nullptr)
+        return;
     // 访问优先级：左子树 -> 根节点 -> 右子树
     inOrder(root->left);
     vec.push_back(root->val);
@@ -28,40 +30,40 @@ void inOrder(TreeNode* root) {
 }
 
 /* 后序遍历 */
-void postOrder(TreeNode* root) {
-    if (root == nullptr) return;
+void postOrder(TreeNode *root) {
+    if (root == nullptr)
+        return;
     // 访问优先级：左子树 -> 右子树 -> 根节点
     postOrder(root->left);
     postOrder(root->right);
     vec.push_back(root->val);
 }
 
-
 /* Driver Code */
 int main() {
     /* 初始化二叉树 */
     // 这里借助了一个从数组直接生成二叉树的函数
-    TreeNode* root = vecToTree(vector<int> { 1, 2, 3, 4, 5, 6, 7 });
+    TreeNode *root = vecToTree(vector<int>{1, 2, 3, 4, 5, 6, 7});
     cout << endl << "初始化二叉树\n" << endl;
-    PrintUtil::printTree(root);
+    printTree(root);
 
     /* 前序遍历 */
     vec.clear();
     preOrder(root);
     cout << endl << "前序遍历的节点打印序列 = ";
-    PrintUtil::printVector(vec);
+    printVector(vec);
 
     /* 中序遍历 */
     vec.clear();
     inOrder(root);
     cout << endl << "中序遍历的节点打印序列 = ";
-    PrintUtil::printVector(vec);
+    printVector(vec);
 
     /* 后序遍历 */
     vec.clear();
     postOrder(root);
     cout << endl << "后序遍历的节点打印序列 = ";
-    PrintUtil::printVector(vec);
-    
+    printVector(vec);
+
     return 0;
 }