feat(src): implement trees helper functions and add 94-inorderTraversal, 95-generateTrees

Author: kwu130

include/common.h

@@ -59,6 +59,67 @@ inline void free(ListNode* head) {
 }
 }  // namespace listHelper
 
+namespace treeHelper {
+struct TreeNode {
+    int val;
+    TreeNode* left;
+    TreeNode* right;
+    TreeNode()
+        : val(0),
+          left(nullptr),
+          right(nullptr) {}
+    explicit TreeNode(int x)
+        : val(x),
+          left(nullptr),
+          right(nullptr) {}
+    TreeNode(const int x, TreeNode* left, TreeNode* right)
+        : val(x),
+          left(left),
+          right(right) {}
+};
+
+inline TreeNode* build(const std::vector<int>& vec, int nullptr_val = -1) {
+    if (vec.empty() || vec[0] == nullptr_val) return nullptr;
+
+    std::queue<TreeNode*> q;
+    auto* root = new TreeNode(vec[0]);
+    q.push(root);
+
+    size_t i = 1;
+    while (!q.empty() && i < vec.size()) {
+        TreeNode* cur = q.front();
+        q.pop();
+
+        if (i < vec.size() && vec[i] != nullptr_val) {
+            cur->left = new TreeNode(vec[i]);
+            q.push(cur->left);
+        }
+        i++;
+
+        if (i < vec.size() && vec[i] != nullptr_val) {
+            cur->right = new TreeNode(vec[i]);
+            q.push(cur->right);
+        }
+        i++;
+    }
+    return root;
+}
+
+inline bool equal(const TreeNode* a, const TreeNode* b) {
+    if (a == nullptr && b == nullptr) return true;
+    if (a == nullptr || b == nullptr) return false;
+    if (a->val != b->val) return false;
+
+    return equal(a->left, b->left) && equal(a->right, b->right);
+}
+
+inline void free(const TreeNode* root) {
+    if (root == nullptr) return;
+    free(root->left);
+    free(root->right);
+    delete root;
+}
+}  // namespace treeHelper
 
 namespace compareHelper {
 template <typename V>

src/94-inorderTraversal.cpp

@@ -0,0 +1,55 @@
+//
+// Created by 1412 on 2025/11/23.
+//
+
+#include <bits/stdc++.h>
+#include "common.h"
+
+using namespace std;
+using treeHelper::TreeNode;
+
+class Solution {
+public:
+    vector<int> inorderTraversal(TreeNode* root) {
+        vector<int> res;
+        stack<TreeNode*> s;
+        while (root != nullptr || !s.empty()) {
+            while (root != nullptr) {
+                s.push(root);
+                root = root->left;
+            }
+            root = s.top();
+            s.pop();
+            res.push_back(root->val);
+            root = root->right;
+        }
+        return res;
+    }
+};
+
+void test() {
+    Solution s;
+    int nullptr_val = -1;
+    TreeNode* root = treeHelper::build({1, nullptr_val, 2, 3}, nullptr_val);
+    vector<int> expected = {1, 3, 2};
+    vector<int> res = s.inorderTraversal(root);
+    assert(res == expected);
+    treeHelper::free(root);
+
+    root = treeHelper::build({}, nullptr_val);
+    expected = {};
+    res = s.inorderTraversal(root);
+    assert(res == expected);
+    treeHelper::free(root);
+
+    root = treeHelper::build({1}, nullptr_val);
+    expected = {1};
+    res = s.inorderTraversal(root);
+    assert(res == expected);
+    treeHelper::free(root);
+}
+
+int main() {
+    test();
+    return 0;
+}

src/95-generateTrees.cpp

@@ -0,0 +1,71 @@
+//
+// Created by 1412 on 2025/11/24.
+//
+
+#include <bits/stdc++.h>
+#include "common.h"
+
+using namespace std;
+using treeHelper::TreeNode;
+
+class Solution {
+public:
+    vector<TreeNode*> generateTrees(int n) {
+        if (n == 0) {
+            return {nullptr};
+        }
+        return generateTrees(1, n);
+    }
+
+private:
+    vector<TreeNode*> generateTrees(int min, int max) {
+        if (min > max) {
+            return {nullptr};
+        }
+        vector<TreeNode*> res;
+        for (int i = min; i <= max; i++) {
+            auto left = generateTrees(min, i - 1);
+            auto right = generateTrees(i + 1, max);
+            for (auto l : left) {
+                for (auto r : right) {
+                    TreeNode* root = new TreeNode(i);
+                    root->left = l;
+                    root->right = r;
+                    res.push_back(root);
+                }
+            }
+        }
+        return res;
+    }
+};
+
+void test() {
+    Solution s;
+    vector<TreeNode*> res = s.generateTrees(3);
+    vector<TreeNode*> expected;
+    int nullptr_val = -1;
+    expected.push_back(treeHelper::build({1, nullptr_val, 2, nullptr_val, 3}, nullptr_val));
+    expected.push_back(treeHelper::build({1, nullptr_val, 3, 2}, nullptr_val));
+    expected.push_back(treeHelper::build({2, 1, 3}, nullptr_val));
+    expected.push_back(treeHelper::build({3, 1, nullptr_val, nullptr_val, 2}, nullptr_val));
+    expected.push_back(treeHelper::build({3, 2, nullptr_val, 1}, nullptr_val));
+    for (size_t i = 0; i < res.size(); i++) {
+        assert(treeHelper::equal(res[i], expected[i]));
+        treeHelper::free(res[i]);
+        treeHelper::free(expected[i]);
+    }
+
+    res = s.generateTrees(1);
+    expected.clear();
+    expected.push_back(treeHelper::build({1}, nullptr_val));
+    for (size_t i = 0; i < res.size(); i++) {
+        assert(treeHelper::equal(res[i], expected[i]));
+        treeHelper::free(res[i]);
+        treeHelper::free(expected[i]);
+    }
+}
+
+int main() {
+    test();
+    return 0;
+}