Add 5 solutions for binary tree traversal problems

- Added solutions for preorder and postorder traversal of binary trees. - Added solutions for preorder and postorder traversal of n-ary trees. - Added solution for inorder traversal of binary trees.

Author: PacemakerX

solutions_leetCode/144_binary-tree-preorder-traversal/README.md

@@ -0,0 +1,49 @@
+# Binary Tree Preorder Traversal
+
+**Question ID**: 144 
+**Language**: C++ 
+**Status**: Accepted 
+**Runtime**: 0 ms
+**Memory**: 11.00 MB
+
+## Solution Code
+
+```cpp
+//https://leetcode.com/problems/binary-tree-preorder-traversal
+/**
+ * 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> order;
+ vector<int> preorderTraversal(TreeNode* root) {
+
+  order.clear();
+  Traversal(root);
+
+  return order;
+ }
+
+ void Traversal(TreeNode* node){
+ if(node==nullptr)
+ return;
+
+  order.push_back(node->val);
+
+  if(node->left!=nullptr)
+  Traversal(node->left);
+
+  if(node->right!=nullptr)
+  Traversal(node->right);
+
+ }
+};
+```

solutions_leetCode/144_binary-tree-preorder-traversal/metadata.json

@@ -0,0 +1,17 @@
+{
+ "id": 1488359612,
+ "question_id": 144,
+ "lang": "cpp",
+ "lang_name": "C++",
+ "timestamp": 1735166931,
+ "status": 10,
+ "status_display": "Accepted",
+ "runtime": "0 ms",
+ "url": "https://leetcode.com/submissions/detail/1488359612/",
+ "is_pending": "Not Pending",
+ "title": "Binary Tree Preorder Traversal",
+ "memory": "11.00 MB",
+ "title_slug": "binary-tree-preorder-traversal",
+ "has_notes": false,
+ "flag_type": 1
+}

solutions_leetCode/144_binary-tree-preorder-traversal/solution.cpp

@@ -0,0 +1,42 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+// https://leetcode.com/problems/binary-tree-preorder-traversal
+/**
+ * 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> order;
+ vector<int> preorderTraversal(TreeNode *root)
+ {
+
+ order.clear();
+ Traversal(root);
+
+ return order;
+ }
+
+ void Traversal(TreeNode *node)
+ {
+ if (node == nullptr)
+ return;
+
+ order.push_back(node->val);
+
+ if (node->left != nullptr)
+ Traversal(node->left);
+
+ if (node->right != nullptr)
+ Traversal(node->right);
+ }
+};

solutions_leetCode/145_binary-tree-postorder-traversal/README.md

@@ -0,0 +1,49 @@
+# Binary Tree Postorder Traversal
+
+**Question ID**: 145 
+**Language**: C++ 
+**Status**: Accepted 
+**Runtime**: 0 ms 
+**Memory**: 11.18 MB
+
+## Solution Code
+```cpp
+//https://leetcode.com/problems/binary-tree-postorder-traversal
+/**
+ * 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> order;
+ vector<int> postorderTraversal(TreeNode* root) {
+  order.clear();
+
+  Traversal(root);
+
+  return order;
+ }
+
+ void Traversal(TreeNode* node){
+ if(node==nullptr)
+ return;
+ 
+ if(node->left!=nullptr)
+ Traversal(node->left);
+ 
+
+  if(node->right!=nullptr)
+  Traversal(node->right);
+
+  order.push_back(node->val);
+ }
+};
+```

solutions_leetCode/145_binary-tree-postorder-traversal/metadata.json

@@ -0,0 +1,17 @@
+{
+ "id": 1488362191,
+ "question_id": 145,
+ "lang": "cpp",
+ "lang_name": "C++",
+ "timestamp": 1735167261,
+ "status": 10,
+ "status_display": "Accepted",
+ "runtime": "0 ms",
+ "url": "https://leetcode.com/submissions/detail/1488362191/",
+ "is_pending": "Not Pending",
+ "title": "Binary Tree Postorder Traversal",
+ "memory": "11.18 MB",
+ "title_slug": "binary-tree-postorder-traversal",
+ "has_notes": false,
+ "flag_type": 1
+}

solutions_leetCode/145_binary-tree-postorder-traversal/solution.cpp

@@ -0,0 +1,43 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+// https://leetcode.com/problems/binary-tree-postorder-traversal
+
+/**
+ * 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> order;
+ vector<int> postorderTraversal(TreeNode *root)
+ {
+ order.clear();
+
+ Traversal(root);
+
+ return order;
+ }
+
+ void Traversal(TreeNode *node)
+ {
+ if (node == nullptr)
+ return;
+
+ if (node->left != nullptr)
+ Traversal(node->left);
+
+ if (node->right != nullptr)
+ Traversal(node->right);
+
+ order.push_back(node->val);
+ }
+};

solutions_leetCode/589_n-ary-tree-preorder-traversal/README.md

@@ -0,0 +1,55 @@
+# N-ary Tree Preorder Traversal
+
+**Question ID**: 589 
+**Language**: C++ 
+**Status**: Accepted 
+**Runtime**: 17 ms
+**Memory**: 15.74 MB
+
+## Solution Code
+
+```cpp
+//https://leetcode.com/problems/n-ary-tree-preorder-traversal
+/*
+// 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> order;
+ vector<int> preorder(Node* root) {
+ order.clear();
+
+  Traversal(root);
+
+  return order;
+ }
+
+ void Traversal(Node* node){
+ if(node==nullptr)
+ return;
+
+  order.push_back(node->val);
+
+  for(auto n : node->children)
+  Traversal(n);
+
+ }
+};
+```

solutions_leetCode/589_n-ary-tree-preorder-traversal/metadata.json

@@ -0,0 +1,17 @@
+{
+ "id": 1488361003,
+ "question_id": 589,
+ "lang": "cpp",
+ "lang_name": "C++",
+ "timestamp": 1735167057,
+ "status": 10,
+ "status_display": "Accepted",
+ "runtime": "17 ms",
+ "url": "https://leetcode.com/submissions/detail/1488361003/",
+ "is_pending": "Not Pending",
+ "title": "N-ary Tree Preorder Traversal",
+ "memory": "15.74 MB",
+ "title_slug": "n-ary-tree-preorder-traversal",
+ "has_notes": false,
+ "flag_type": 1
+}

solutions_leetCode/589_n-ary-tree-preorder-traversal/solution.cpp

@@ -0,0 +1,49 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+// https://leetcode.com/problems/n-ary-tree-preorder-traversal
+
+/*
+// 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> order;
+ vector<int> preorder(Node *root)
+ {
+ order.clear();
+
+ Traversal(root);
+
+ return order;
+ }
+
+ void Traversal(Node *node)
+ {
+ if (node == nullptr)
+ return;
+
+ order.push_back(node->val);
+
+ for (auto n : node->children)
+ Traversal(n);
+ }
+};