Merge branch 'neetcode-gh:main' into main

Author: acmoroca

cpp/1-Two-Sum.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+    vector<int> twoSum(vector<int>& nums, int target) {
+        unordered_map<int, int> umap;
+        for(int i=0; i<nums.size(); i++) {
+            if (umap.find(target-nums[i]) != umap.end()){
+                return {umap[target-nums[i]], i};
+            }
+            
+            umap[nums[i]] = i;
+        }
+        
+        return {};
+    }
+};

cpp/100-Same-Tree.cpp

@@ -0,0 +1,21 @@
+/**
+ * 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 isSameTree(TreeNode* p, TreeNode* q) {
+        if (p == NULL and q == NULL) return true;
+        if (p==NULL || q==NULL) return false;
+        if (p->val != q->val) return false;
+        
+        return isSameTree(p->left, q->left) && isSameTree(p->right, q->right); 
+    }
+};

cpp/104-Maximum-Depth-of-Binary-Tree.cpp

@@ -0,0 +1,40 @@
+/**
+ * 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) {}
+ * };
+ */
+
+// Using Stack
+// class Solution {
+// public:
+//     int maxDepth(TreeNode* root) {
+//         if (root == NULL) return 0;
+//         stack<pair<TreeNode*, int>> stk;
+//         int res = 0; 
+//         stk.push({root, 1});
+        
+//         while (!stk.empty()) {
+//             auto t = stk.top();
+//             res = max(res, t.second);
+//             stk.pop();
+//             if (t.first->left) stk.push({t.first->left, t.second+1});
+//             if (t.first->right) stk.push({t.first->right, t.second+1});
+//         }
+//         return res;
+//     }
+// };
+
+// Using Recursion
+class Solution {
+public:
+    int maxDepth(TreeNode* root) {
+        if (root == NULL) return 0;
+        return max(maxDepth(root->left)+1, maxDepth(root->right)+1);
+    }
+};

cpp/121-Best-Time-to-Buy-and-Sell-Stock.cpp

@@ -0,0 +1,29 @@
+class Solution {
+public:
+    int maxProfit(vector<int>& prices) {
+        int n = prices.size();
+        // Preprocessing
+        // Polulate a smallest from beginning array
+        // Polulate a largest from the end array
+        vector<int> smallest(n, -1), largest(n, -1);
+        
+        smallest[0] = prices[0];
+        largest[n-1] = prices[n-1];
+        
+        for (int i = 1; i < n; i++) {
+            smallest[i] = min(smallest[i-1], prices[i]);
+        }
+        
+        for (int i = n-2; i>=0; i--) {
+            largest[i] = max(largest[i+1], prices[i]); 
+        }
+        
+        // Logic
+        // Max difference b/w the smallest and largest element 
+        int res = 0;
+        for(int i=0; i<n; i++) res = max(res, largest[i]-smallest[i]);
+        
+        return res;
+        
+    }       
+};

cpp/125-Valid-Palindrome.cpp

@@ -0,0 +1,29 @@
+class Solution {
+public:
+    bool isPalindrome(string s) {
+        int start = 0, end = s.length()-1;
+        
+        while (start < end) {
+            char a = s[start], b = s[end];
+            
+            // Convert to caps
+            if (a >= 'a' && a <= 'z') a = a-'a'+'A';
+            if (b >= 'a' && b <= 'z') b = b - 'a' + 'A';
+                
+            // Logic
+            if ( (a < 'A' || a > 'Z') && (a < '0' || a > '9') ) {
+                start ++;
+                continue;
+            }
+            if ( (b < 'A' || b > 'Z') && (b < '0' || b > '9') ) {
+                end --;
+                continue;
+            }            
+            if(a != b) return false;
+            start ++;
+            end --; 
+        }
+        
+       return true;  
+    }
+};

cpp/143-Reorder-List.cpp

@@ -0,0 +1,72 @@
+/**
+ * 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:
+  void reorderList(ListNode* head) {
+    ListNode* prev = nullptr;
+    ListNode* slow = head;
+    ListNode* fast = head;
+
+    // set slow to middle node
+    while (fast != nullptr && fast->next != nullptr) {
+      prev = slow;
+      slow = slow->next;
+      fast = fast->next->next;
+    }
+
+    if (prev != nullptr) {
+      prev->next = reverseList(slow);
+      mergeTwoLists(head, prev->next);
+    }
+  }
+
+ private:
+  ListNode* reverseList(ListNode* head) {
+    ListNode* prev = nullptr;
+    ListNode* curr = head;
+
+    while (curr != nullptr) {
+      ListNode* next = curr->next;
+      curr->next = prev;
+      prev = curr;
+      curr = next;
+    }
+
+    return prev;
+  }
+
+  // invariant: list2 length = [list1 length, list1 length + 1]
+  ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
+    ListNode dummy;
+    ListNode* prev = &dummy;
+
+    ListNode* l1 = list1;
+    ListNode* l2 = list2;
+
+    while (l1 != list2) {
+      takeNode(prev, l1);
+      takeNode(prev, l2);
+    }
+
+    // handle odd number of nodes
+    if (l2 != nullptr) {
+      takeNode(prev, l2);
+    }
+
+    return dummy.next;
+  }
+
+  void takeNode(ListNode*& prev, ListNode*& curr) {
+    prev->next = curr;
+    prev = prev->next;
+    curr = curr->next;
+  }
+};

cpp/167-Two-Sum-II.cpp

@@ -0,0 +1,20 @@
+// Window Method
+
+class Solution {
+private:
+
+public:
+    vector<int> twoSum(vector<int>& arr, int target) {
+        int i = 0, j = arr.size()-1;
+        
+        while(i < j){
+            if(arr[i] + arr[j] == target) return {i+1,j+1};
+            if(arr[i] + arr[j] > target) {
+                j--;
+            }
+            else {i++;}
+        }
+        return {};
+    }
+    
+};

cpp/20-Valid-Parentheses.cpp

@@ -0,0 +1,19 @@
+class Solution {
+public:
+    bool isValid(string s) {
+        stack<char> stk;
+        for(auto a: s) {
+            if (a=='(' || a=='{' || a=='[') {
+                stk.push(a);
+            }
+            else {
+                if(stk.empty()) return false;
+                if( (stk.top() == '(' && a==')') || (stk.top() == '{' && a=='}') || (stk.top() == '[' && a==']') )
+                    stk.pop();
+                else return false;
+            }
+        }
+        
+        return stk.empty(); 
+    }
+};

cpp/206-Reverse-Linked-List.cpp

@@ -0,0 +1,26 @@
+/**
+ * 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* reverseList(ListNode* head) {
+        ListNode* rev = new ListNode(0);
+        ListNode* ptr = head;
+        
+        while(ptr) {
+            auto temp = ptr;
+            ptr=ptr->next;
+            temp-> next = rev->next;
+            rev->next = temp;
+        }
+        
+        return rev->next;
+    }
+};

cpp/21-Merge-Two-Sorted-Lists.cpp

@@ -0,0 +1,46 @@
+/**
+ * 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* mergeTwoLists(ListNode* list1, ListNode* list2) {
+        ListNode* res = new ListNode(0);
+        auto ptr = res;
+        
+        auto ptr1 = list1;
+        auto ptr2 = list2;
+        
+        while (ptr1 && ptr2) {
+            if (ptr1->val < ptr2->val) {
+                res->next = ptr1;
+                ptr1 = ptr1->next;
+                res = res->next;
+            }
+            else {
+                res->next = ptr2;
+                ptr2 = ptr2->next;
+                res = res->next;
+            }
+        }
+        
+        while (ptr1) {
+            res->next = ptr1;
+            res = res->next;
+            ptr1 = ptr1->next;
+        }
+        while (ptr2) {
+            res->next = ptr2;
+            res = res->next;
+            ptr2 = ptr2->next;
+        }
+        
+        return ptr->next;
+    }
+};