Merge pull request #2389 from Ritesh7766/main

Create: 0876-middle-of-the-linked-list.cpp, 0094-binary-tree-inorder-traversal.cpp

Author: MHamiid

cpp/0094-binary-tree-inorder-traversal.cpp

@@ -0,0 +1,46 @@
+/**
+ * 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) {}
+ * };
+ */
+#include <stack>
+
+class Solution {
+public:
+    /* Recursive
+    vector<int> helper(TreeNode* node, vector<int>& path) {
+        if (node == NULL)
+            return path;
+
+        path = helper(node->left, path);
+        path.push_back(node->val);
+        path = helper(node->right, path);
+        return path;
+    }
+    */
+
+    // Iterative
+    vector<int> inorderTraversal(TreeNode* root) {
+        stack<TreeNode*> stk;
+        vector<int> path;
+        TreeNode* current = root;
+
+        while (!stk.empty() || current != NULL) {
+            while (current != NULL) {
+                stk.push(current);
+                current = current->left;
+            }
+            TreeNode* node = stk.top();
+            path.push_back(node->val);
+            stk.pop();
+            current = node->right;
+        }
+        return path;
+    }
+};

cpp/0876-middle-of-the-linked-list.cpp

@@ -0,0 +1,29 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+ *     ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+
+class Solution {
+public:
+    ListNode* middleNode(ListNode* head) {
+        /*
+        The slow and fast pointer algorithm is used to find the middle 
+        of a linked list by iterating through the list with a slow 
+        pointer that moves one step at a time and a fast pointer that
+        moves two steps at a time. When the fast pointer reaches the 
+        end of the list, the slow pointer will be at the midpoint of the list.
+        */
+        ListNode *slow_pointer = head, *fast_pointer = head;
+        while (fast_pointer != NULL && fast_pointer->next != NULL) {
+            slow_pointer = slow_pointer->next;
+            fast_pointer = fast_pointer->next->next;
+        }
+        return slow_pointer;
+    }
+};