2024

Author: HONGJICAI

cpp/.clang-format

@@ -0,0 +1,8 @@
+BasedOnStyle: LLVM
+IndentWidth: 4
+---
+Language: Cpp
+# Force pointers to the type for C++.
+# AccessModifierOffset: -4
+DerivePointerAlignment: false
+PointerAlignment: Left

cpp/100.cpp

@@ -11,7 +11,7 @@
 class Solution {
 public:
   bool isSameTree(TreeNode *p, TreeNode *q) {
-    if (p == NULL || q == NULL)
+    if (p == nullptr || q == nullptr)
       return p == q;
     return p->val == q->val && isSameTree(p->left, q->left) &&
            isSameTree(p->right, q->right);

cpp/102.cpp

@@ -9,19 +9,19 @@
  * };
  */
 class Solution {
-public:
-  vector<vector<int>> levelOrder(TreeNode *root) {
-    vector<vector<int>> result;
-    preOrder(0, root, result);
-    return result;
-  }
   void preOrder(int i, TreeNode *root, vector<vector<int>> &nums) {
-    if (root == NULL)
+    if (root == nullptr)
       return;
     if (nums.size() == i)
-      nums.push_back(vector<int>());
+      nums.push_back({});
     nums[i].push_back(root->val);
     preOrder(i + 1, root->left, nums);
     preOrder(i + 1, root->right, nums);
   }
+public:
+  vector<vector<int>> levelOrder(TreeNode *root) {
+    vector<vector<int>> result;
+    preOrder(0, root, result);
+    return result;
+  }
 };

cpp/103.cpp

@@ -1,50 +1,50 @@
-// queue.cpp
 /**
  * Definition for a binary tree node.
  * struct TreeNode {
  *     int val;
  *     TreeNode *left;
  *     TreeNode *right;
- *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left),
+ * right(right) {}
  * };
  */
 class Solution {
 public:
-  vector<vector<int>> zigzagLevelOrder(TreeNode *root) {
-    queue<TreeNode *> qe;
-    vector<vector<int>> result;
-    if (root == NULL)
-      return result;
-    qe.push(root);
-    TreeNode *p;
-    int level = 0, size;
-    while (!qe.empty()) {
-      result.push_back(vector<int>(qe.size()));
-      size = qe.size();
-      for (int i = 0; i < size; ++i) {
-        p = qe.front();
-        qe.pop();
-        result[level][i] = p->val;
-        if (p->left != NULL)
-          qe.push(p->left);
-        if (p->right != NULL)
-          qe.push(p->right);
-      }
-      if (qe.empty())
-        break;
-      ++level;
-      result.push_back(vector<int>(qe.size()));
-      for (int i = qe.size() - 1; i >= 0; --i) {
-        p = qe.front();
-        qe.pop();
-        result[level][i] = p->val;
-        if (p->left != NULL)
-          qe.push(p->left);
-        if (p->right != NULL)
-          qe.push(p->right);
-      }
-      ++level;
+    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
+        if (root == nullptr)
+            return {};
+        queue<TreeNode*> qe({root});
+        vector<vector<int>> result;
+        int level = 0, size;
+        while (!qe.empty()) {
+            result.push_back(vector<int>(qe.size()));
+            size = qe.size();
+            for (int i = 0; i < size; ++i) {
+                auto p = qe.front();
+                qe.pop();
+                result[level][i] = p->val;
+                if (p->left != nullptr)
+                    qe.push(p->left);
+                if (p->right != nullptr)
+                    qe.push(p->right);
+            }
+            if (qe.empty())
+                break;
+            ++level;
+            result.push_back(vector<int>(qe.size()));
+            for (int i = qe.size() - 1; i >= 0; --i) {
+                auto p = qe.front();
+                qe.pop();
+                result[level][i] = p->val;
+                if (p->left != nullptr)
+                    qe.push(p->left);
+                if (p->right != nullptr)
+                    qe.push(p->right);
+            }
+            ++level;
+        }
+        return result;
     }
-    return result;
-  }
-};
+};

cpp/104.cpp

@@ -1,21 +1,20 @@
-// recursion-6ms.cpp
 /**
  * Definition for a binary tree node.
  * struct TreeNode {
  *     int val;
  *     TreeNode *left;
  *     TreeNode *right;
- *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left),
+ * right(right) {}
  * };
  */
 class Solution {
 public:
-  int maxDepth(TreeNode *root) {
-    if (root == NULL)
-      return 0;
-    int a = 1 + maxDepth(root->left), b = 1 + maxDepth(root->right);
-    if (a >= b)
-      return a;
-    return b;
-  }
+    int maxDepth(TreeNode* root) {
+        if (root == nullptr)
+            return 0;
+        return 1 + max(maxDepth(root->left), maxDepth(root->right));
+    }
 };

cpp/107.cpp

@@ -1,29 +1,32 @@
-// dfsANDreverse.cpp
 /**
  * Definition for a binary tree node.
  * struct TreeNode {
  *     int val;
  *     TreeNode *left;
  *     TreeNode *right;
- *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left),
+ * right(right) {}
  * };
  */
+
 class Solution {
-  vector<vector<int>> result;
+    vector<vector<int>> result;
+    void dfs(TreeNode* root, int depth) {
+        if (root == nullptr)
+            return;
+        if (depth == result.size()) {
+            result.push_back({});
+        }
+        result[depth].push_back(root->val);
+        dfs(root->left, depth + 1);
+        dfs(root->right, depth + 1);
+    }
 
 public:
-  vector<vector<int>> levelOrderBottom(TreeNode *root) {
-    dfs(root, 0);
-    return vector<vector<int>>(result.rbegin(), result.rend());
-  }
-  void dfs(TreeNode *root, int depth) {
-    if (root == NULL)
-      return;
-    if (depth == result.size()) {
-      result.push_back(vector<int>());
+    vector<vector<int>> levelOrderBottom(TreeNode* root) {
+        dfs(root, 0);
+        return {result.rbegin(), result.rend()};
     }
-    result[depth].push_back(root->val);
-    dfs(root->left, depth + 1);
-    dfs(root->right, depth + 1);
-  }
 };

cpp/108.cpp

@@ -9,17 +9,18 @@
  * };
  */
 class Solution {
-public:
-  TreeNode *sortedArrayToBST(vector<int> &nums) {
-    return recursion(0, nums.size(), nums);
-  }
-  TreeNode *recursion(int low, int high, vector<int> &nums) {
-    if (low >= high)
-      return NULL;
-    int mid = (low + high) / 2;
-    TreeNode *p = new TreeNode(nums[mid]);
-    p->left = recursion(low, mid, nums);
-    p->right = recursion(mid + 1, high, nums);
-    return p;
-  }
+    TreeNode* recursion(int low, int high, vector<int>& nums) {
+        if (low >= high)
+            return nullptr;
+        int mid = (low + high) / 2;
+        TreeNode* p = new TreeNode(nums[mid]);
+        p->left = recursion(low, mid, nums);
+        p->right = recursion(mid + 1, high, nums);
+        return p;
+    }
+
+  public:
+    TreeNode* sortedArrayToBST(vector<int>& nums) {
+        return recursion(0, nums.size(), nums);
+    }
 };

cpp/112.cpp

@@ -5,17 +5,17 @@
  *     int val;
  *     TreeNode *left;
  *     TreeNode *right;
- *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
  * };
  */
 class Solution {
-public:
-  bool hasPathSum(TreeNode *root, int sum) {
-    if (root == NULL)
-      return 0;
-    if (root->val == sum && root->left == NULL && root->right == NULL)
-      return 1;
-    return hasPathSum(root->left, sum - root->val) ||
-           hasPathSum(root->right, sum - root->val);
-  }
+  public:
+    bool hasPathSum(TreeNode* root, int sum) {
+        if (root == nullptr)
+            return 0;
+        if (root->val == sum && root->left == nullptr && root->right == nullptr)
+            return 1;
+        return hasPathSum(root->left, sum - root->val) ||
+               hasPathSum(root->right, sum - root->val);
+    }
 };

cpp/113.cpp

@@ -5,26 +5,27 @@
  *     int val;
  *     TreeNode *left;
  *     TreeNode *right;
- *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
  * };
  */
 class Solution {
-  vector<vector<int>> result;
+    vector<vector<int>> result;
+    void hasSum(TreeNode* root, int sum, vector<int>& now) {
+        if (root == nullptr)
+            return;
+        now.push_back(root->val);
+        if (0 == sum - root->val && root->left == nullptr &&
+            root->right == nullptr)
+            result.push_back(now);
+        hasSum(root->left, sum - root->val, now);
+        hasSum(root->right, sum - root->val, now);
+        now.pop_back();
+    }
 
-public:
-  vector<vector<int>> pathSum(TreeNode *root, int sum) {
-    vector<int> now;
-    hasSum(root, sum, now);
-    return result;
-  }
-  void hasSum(TreeNode *root, int sum, vector<int> &now) {
-    if (root == NULL)
-      return;
-    now.push_back(root->val);
-    if (0 == sum - root->val && root->left == NULL && root->right == NULL)
-      result.push_back(now);
-    hasSum(root->left, sum - root->val, now);
-    hasSum(root->right, sum - root->val, now);
-    now.pop_back();
-  }
+  public:
+    vector<vector<int>> pathSum(TreeNode* root, int sum) {
+        vector<int> now;
+        hasSum(root, sum, now);
+        return result;
+    }
 };

cpp/118.cpp

@@ -1,22 +1,16 @@
-// iteration-3ms.cpp
+// iteration-0ms.cpp
 class Solution {
-public:
-  vector<vector<int>> generate(int numRows) {
-    vector<vector<int>> result;
-    if (numRows == 0)
-      return result;
-    result.push_back(vector<int>(1, 1));
-    if (numRows == 1)
-      return result;
-    vector<int> a;
-    for (int row = 1; row < numRows; ++row) {
-      a.push_back(1);
-      for (int i = 1; i < row; ++i)
-        a.push_back(result[row - 1][i] + result[row - 1][i - 1]);
-      a.push_back(1);
-      result.push_back(a);
-      a.clear();
+  public:
+    vector<vector<int>> generate(int numRows) {
+        vector<vector<int>> result{{1}};
+        vector<int> a;
+        for (int row = 1; row < numRows; ++row) {
+            a.push_back(1);
+            for (int i = 1; i < row; ++i)
+                a.push_back(result[row - 1][i] + result[row - 1][i - 1]);
+            a.push_back(1);
+            result.push_back(move(a));
+        }
+        return result;
     }
-    return result;
-  }
 };