feat(src): add 107-levelOrderBottom, 108-sortedArrayToBST, 109-sortedListToBST

Author: kwu130

src/107-levelOrderBottom.cpp

@@ -0,0 +1,64 @@
+//
+// Created by 1412 on 2025/12/5.
+//
+
+#include <bits/stdc++.h>
+#include "common.h"
+
+using namespace std;
+using treeHelper::TreeNode;
+
+class Solution {
+public:
+    vector<vector<int>> levelOrderBottom(TreeNode* root) {
+        vector<vector<int>> res;
+        if (root == nullptr) return res;
+        queue<TreeNode*> q;
+        q.push(root);
+        while (!q.empty()) {
+            size_t n = q.size();
+            vector<int> level;
+            while (n--) {
+                TreeNode* node = q.front();
+                q.pop();
+                level.push_back(node->val);
+                if (node->left != nullptr) q.push(node->left);
+                if (node->right != nullptr) q.push(node->right);
+            }
+            res.push_back(level);
+        }
+        ranges::reverse(res);
+        return res;
+    }
+};
+
+void test() {
+    Solution s;
+    int nullptr_value = -1;
+    TreeNode* root = treeHelper::build({3, 9, 20, nullptr_value, nullptr_value, 15, 7}, nullptr_value);
+    vector<vector<int>> expected = {
+        {15, 7},
+        {9, 20},
+        {3}
+    };
+    vector<vector<int>> res = s.levelOrderBottom(root);
+    assert(res == expected);
+    treeHelper::free(root);
+
+    root = treeHelper::build({1}, nullptr_value);
+    expected = {{1}};
+    res = s.levelOrderBottom(root);
+    assert(res == expected);
+    treeHelper::free(root);
+
+    root = treeHelper::build({}, nullptr_value);
+    expected = {};
+    res = s.levelOrderBottom(root);
+    assert(res == expected);
+    treeHelper::free(root);
+}
+
+int main() {
+    test();
+    return 0;
+}

src/108-sortedArrayToBST.cpp

@@ -0,0 +1,54 @@
+//
+// Created by 1412 on 2025/12/5.
+//
+
+#include <bits/stdc++.h>
+#include "common.h"
+
+using namespace std;
+using treeHelper::TreeNode;
+
+class Solution {
+public:
+    TreeNode* sortedArrayToBST(vector<int>& nums) {
+        if (nums.size() == 0) {
+            return nullptr;
+        }
+        return build(nums, 0, nums.size() - 1);
+    }
+
+private:
+    TreeNode* build(vector<int>& nums, int left, int right) {
+        if (left > right) {
+            return nullptr;
+        }
+        int mid = left + (right - left) / 2;
+        TreeNode* root = new TreeNode(nums[mid]);
+        root->left = build(nums, left, mid - 1);
+        root->right = build(nums, mid + 1, right);
+        return root;
+    }
+};
+
+void test() {
+    Solution s;
+    vector<int> nums = {-10, -3, 0, 5, 9};
+    int nullptr_value = -1;
+    TreeNode* expected = treeHelper::build({0, -10, 5, nullptr_value, -3, nullptr_value, 9}, nullptr_value);
+    TreeNode* res = s.sortedArrayToBST(nums);
+    assert(treeHelper::equal(res, expected));
+    treeHelper::free(res);
+    treeHelper::free(expected);
+
+    nums = {1, 3};
+    expected = treeHelper::build({1, nullptr_value, 3}, nullptr_value);
+    res = s.sortedArrayToBST(nums);
+    assert(treeHelper::equal(res, expected));
+    treeHelper::free(res);
+    treeHelper::free(expected);
+}
+
+int main() {
+    test();
+    return 0;
+}

src/109-sortedListToBST.cpp

@@ -0,0 +1,58 @@
+//
+// Created by 1412 on 2025/12/5.
+//
+
+#include <bits/stdc++.h>
+#include "common.h"
+
+using namespace std;
+using listHelper::ListNode;
+using treeHelper::TreeNode;
+
+class Solution {
+public:
+    TreeNode* sortedListToBST(ListNode* head) { return build(head, nullptr); }
+
+private:
+    TreeNode* build(ListNode* left, ListNode* right) {
+        if (left == right) {
+            return nullptr;
+        }
+        ListNode* slow = left;
+        ListNode* fast = left;
+        // find the middle node
+        while (fast != right && fast->next != right) {
+            slow = slow->next;
+            fast = fast->next->next;
+        }
+        TreeNode* root = new TreeNode(slow->val);
+        root->left = build(left, slow);
+        root->right = build(slow->next, right);
+        return root;
+    }
+};
+
+void test() {
+    Solution s;
+    ListNode* head = listHelper::build({-10, -3, 0, 5, 9});
+    TreeNode* root = s.sortedListToBST(head);
+    int nullptr_value = -1;
+    TreeNode* expected = treeHelper::build({0, -3, 9, -10, nullptr_value, 5}, nullptr_value);
+    assert(treeHelper::equal(root, expected));
+    listHelper::free(head);
+    treeHelper::free(root);
+    treeHelper::free(expected);
+
+    head = listHelper::build({});
+    root = s.sortedListToBST(head);
+    expected = treeHelper::build({}, nullptr_value);
+    assert(treeHelper::equal(root, expected));
+    listHelper::free(head);
+    treeHelper::free(root);
+    treeHelper::free(expected);
+}
+
+int main() {
+    test();
+    return 0;
+}