added 145, 589, 590, 2331, added cpp solution for 94, 144

Author: rustykitty

0094-binary-tree-inorder-traversal.cpp

@@ -0,0 +1,35 @@
+/*
+94. Binary Tree Inorder Traversal
+
+Submitted: December 2, 2024
+
+Runtime: 0 ms (beats 100.00%)
+
+Memory: 11.04 MB (beats 14.19%)
+*/
+
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     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<int> inorderTraversal(TreeNode* root) {
+        vector<int> result;
+        traversalHelper(result, root);
+        return result;
+    }
+    void traversalHelper(vector<int>& vec, TreeNode* root) {
+        if (root == nullptr) return;
+        traversalHelper(vec, root->left);
+        vec.push_back(root->val);
+        traversalHelper(vec, root->right);
+    }
+};

0144-binary-tree-preorder-traversal.cpp

@@ -0,0 +1,25 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     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<int> preorderTraversal(TreeNode* root) {
+        vector<int> result;
+        traversalHelper(result, root);
+        return result;
+    }
+    void traversalHelper(vector<int>& vec, TreeNode* root) {
+        if (root == nullptr) return;
+        vec.push_back(root->val);
+        traversalHelper(vec, root->left);
+        traversalHelper(vec, root->right);
+    }
+};

0145-binary-tree-postorder-traversal.cpp

@@ -0,0 +1,34 @@
+/*
+145. Binary Tree Postorder Traversal
+
+December 2, 2024
+
+Runtime: 0 ms (beats 100.00%)
+Memory: 10.90% (beats 15.34%)
+*/
+
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     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<int> postorderTraversal(TreeNode* root) {
+        vector<int> result;
+        traversalHelper(result, root);
+        return result;
+    }
+    void traversalHelper(vector<int>& vec, TreeNode* root) {
+        if (root == nullptr) return;
+        traversalHelper(vec, root->left);
+        traversalHelper(vec, root->right);
+        vec.push_back(root->val);
+    }
+};

0589-n-ary-tree-preorder-traversal.cpp

@@ -0,0 +1,44 @@
+/*
+589. N-ary Tree Preorder Traversal
+
+Submitted: December 2, 2024
+
+Runtime: 14 ms (beats 47.33%)
+Memory: 15.65 MB (beats 14.49%)
+*/
+
+/*
+// Definition for a Node.
+class Node {
+public:
+    int val;
+    vector<Node*> children;
+
+    Node() {}
+
+    Node(int _val) {
+        val = _val;
+    }
+
+    Node(int _val, vector<Node*> _children) {
+        val = _val;
+        children = _children;
+    }
+};
+*/
+
+class Solution {
+public:
+    vector<int> preorder(Node* root) {
+        vector<int> result;
+        traversalHelper(result, root);
+        return result;
+    }
+    void traversalHelper(vector<int>& vec, Node* root) {
+        if (root == nullptr) return;
+        vec.push_back(root->val);
+        for (Node* child : root->children) {
+            traversalHelper(vec, child);
+        }
+    }
+};

0590-n-ary-tree-postorder-traversal.cpp

@@ -0,0 +1,44 @@
+/*
+590. N-ary Tree Postorder Traversal
+
+Submitted: December 2, 2024
+
+12 ms (beats 66.60%)
+Memory: 15.64 MB (beats 18.30%)
+*/
+
+/*
+// Definition for a Node.
+class Node {
+public:
+    int val;
+    vector<Node*> children;
+
+    Node() {}
+
+    Node(int _val) {
+        val = _val;
+    }
+
+    Node(int _val, vector<Node*> _children) {
+        val = _val;
+        children = _children;
+    }
+};
+*/
+
+class Solution {
+public:
+    vector<int> postorder(Node* root) {
+        vector<int> result;
+        traversalHelper(result, root);
+        return result;
+    }
+    void traversalHelper(vector<int>& vec, Node* root) {
+        if (root == nullptr) return;
+        for (Node* child : root->children) {
+            traversalHelper(vec, child);
+        }
+        vec.push_back(root->val);
+    }
+};

2331-evaluate-boolean-binary-tree.cpp

@@ -0,0 +1,28 @@
+/*
+2331. Evaluate Boolean Binary Tree 
+
+Submitted: December 2, 2024
+
+0 ms (beats 100.00%)
+24.32 MB (beats 5.76%)
+*/
+
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     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:
+    bool evaluateTree(TreeNode* root) {
+        if (root->val == 0 || root->val == 1) return (bool) root->val;
+        else if (root->val == 2) return evaluateTree(root->left) || evaluateTree(root->right);
+        else return evaluateTree(root->left) && evaluateTree(root->right);
+    }
+};