Add C++ implementation

begeekmyfriend · begeekmyfriend · commit b9dc8acd06ce · 2020-09-08T16:00:17.000+08:00
Signed-off-by: begeekmyfriend &lt;begeekmyfriend@gmail.com&gt;
diff --git a/040_combination_sum_ii/combination_sum.cc b/040_combination_sum_ii/combination_sum.cc
@@ -19,7 +19,7 @@ class Solution {
         } else if (target == 0) {
             res.push_back(stack);
         } else {
-            int last = -1;
+            int last = INT_MIN;
             for (int i = start; i < candidates.size(); i++) {
                 if (last != candidates[i]) {
                     /* No duplicate combinations in different order */
diff --git a/046_permutations/permutations.cc b/046_permutations/permutations.cc
@@ -17,8 +17,10 @@ class Solution {
         if (stack.size() == nums.size()) {
             res.push_back(stack);
         } else {
+            // Reverse order is allowed in different levels, always starts from [0]
             for (int i = 0; i < nums.size(); i++) {
                 if (!used[i]) {
+                    // Used marks only allows remaining elements in DFS levels
                     used[i] = true;
                     stack.push_back(nums[i]);
                     dfs(nums, used, stack, res);
diff --git a/047_permutations_ii/permutations.cc b/047_permutations_ii/permutations.cc
@@ -19,10 +19,10 @@ class Solution {
             res.push_back(stack);
         } else {
             for (int i = 0; i < nums.size(); i++) {
+                // Used marks only allows remaining elements in DFS levels
                 if (!used[i]) {
                     if (i > 0 && !used[i - 1] && nums[i - 1] == nums[i]) {
-                        /* In case that duplicate permutation with same elemements */
-                        /* Used marks allow same elements in different DFS levels */
+                        // In case that duplicate permutation with same elemements but in different postions
                         continue;
                     }
                     used[i] = true;
diff --git a/098_validate_binary_search_tree/valid_bst.cc b/098_validate_binary_search_tree/valid_bst.cc
@@ -0,0 +1,39 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+/**
+ * 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 isValidBST(TreeNode* root) {
+        stack<TreeNode*> stk;
+        int prev = INT_MIN;
+        bool first = true;
+        while (!stk.empty() || root != nullptr) {
+            if (root != nullptr) {
+                stk.push(root);
+                root = root->left;
+            } else {
+                root = stk.top();
+                stk.pop();
+                if (!first && prev >= root->val) {
+                    return false;
+                }
+                first = false;
+                prev = root->val;
+                root = root->right;
+            }
+        }
+        return true;
+    }
+};
diff --git a/100_same_tree/same_tree.cc b/100_same_tree/same_tree.cc
@@ -0,0 +1,30 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+/**
+ * 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 == nullptr && q == nullptr) {
+            return true;
+        }
+        if (p == nullptr || q == nullptr) {
+            return false;
+        }
+        if (p->val != q->val) {
+            return false;
+        }
+        return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
+    }
+};
diff --git a/101_symmetric_tree/symmetric_tree.cc b/101_symmetric_tree/symmetric_tree.cc
@@ -0,0 +1,38 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+/**
+ * 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 isSymmetric(TreeNode* root) {
+        if (root == nullptr) {
+            return true;
+        }
+        return dfs(root->left, root->right);
+    }
+
+private:
+    bool dfs(TreeNode *l, TreeNode *r) {
+        if (l == nullptr && r == nullptr) {
+            return true;
+        }
+        if (l == nullptr || r == nullptr) {
+            return false;
+        }
+        if (l->val != r->val) {
+            return false;
+        }
+        return dfs(l->left, r->right) && dfs(l->right, r->left);
+    }
+};
diff --git a/102_binary_tree_level_order_traversal/bst_bfs.cc b/102_binary_tree_level_order_traversal/bst_bfs.cc
@@ -0,0 +1,45 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+/**
+ * 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<vector<int>> levelOrder(TreeNode* root) {
+        vector<vector<int>> res;
+        if (root == nullptr) {
+            return res;
+        }
+
+        queue<TreeNode*> q;
+        q.push(root);
+        while (!q.empty()) {
+            vector<int> level;
+            int size = q.size(); 
+            for (int i = 0; i < size; i++) {
+                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);
+        }
+
+        return res;
+    }
+};
diff --git a/104_maximum_depth_of_binary_tree/bst_depth.cc b/104_maximum_depth_of_binary_tree/bst_depth.cc
@@ -0,0 +1,24 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+/**
+ * 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:
+    int maxDepth(TreeNode* root) {
+        if (root == nullptr) {
+            return 0;
+        }
+        return 1 + max(maxDepth(root->left), maxDepth(root->right));
+    }
+};
diff --git a/107_binary_tree_level_order_traversal_ii/bst_bfs.cc b/107_binary_tree_level_order_traversal_ii/bst_bfs.cc
@@ -0,0 +1,46 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+/**
+ * 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<vector<int>> levelOrderBottom(TreeNode* root) {
+        vector<vector<int>> res;
+        if (root == nullptr) {
+            return res;
+        }
+
+        queue<TreeNode *> q;
+        q.push(root);
+        while (!q.empty()) {
+            int size = q.size();
+            vector<int> level;
+            for (int i = 0; i < size; i++) {
+                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);
+        }
+
+        reverse(res.begin(), res.end());
+        return res;
+    }
+};
diff --git a/138_copy_list_with_random_pointer/copy_list.cc b/138_copy_list_with_random_pointer/copy_list.cc
@@ -0,0 +1,52 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+/*
+// Definition for a Node.
+class Node {
+public:
+    int val;
+    Node* next;
+    Node* random;
+    
+    Node(int _val) {
+        val = _val;
+        next = nullptr;
+        random = nullptr;
+    }
+};
+*/
+
+class Solution {
+public:
+    Node* copyRandomList(Node* head) {
+        Node *p, *q;
+        // Insert interleavingly
+        for (p = head; p != nullptr; p = q->next) {
+            q = Node(p->val);
+            q->next = p->next;
+            p->next = q;
+        }
+
+        // Clone random pointers
+        for (p = head; p != nullptr; p = q->next) {
+            q = p->next;
+            q->random = p->random != nullptr ? p->random->next : nullptr;
+        }
+
+        // Separate q list
+        Node dummy;
+        Node *prev = &dummy;
+        prev->next = head;
+        for (p = head; p != nullptr; p = q->next) {
+            q = p->next;
+            p->next = q->next; // restore p->next
+            prev->next = q;
+            prev = q;
+        }
+        /* q->next == nullptr */
+
+        return dummy.next;
+    }
+};
diff --git a/141_linked_list_cycle/list_cycle.cc b/141_linked_list_cycle/list_cycle.cc
@@ -7,7 +7,7 @@ using namespace std;
  * struct ListNode {
  *     int val;
  *     ListNode *next;
- *     ListNode(int x) : val(x), next(NULL) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
  * };
  */
 class Solution {
diff --git a/142_linked_list_cycle_ii/list_cycle.cc b/142_linked_list_cycle_ii/list_cycle.cc
@@ -7,7 +7,7 @@ using namespace std;
  * struct ListNode {
  *     int val;
  *     ListNode *next;
- *     ListNode(int x) : val(x), next(NULL) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
  * };
  */
 class Solution {
diff --git a/146_lru_cache/lru_cache.cc b/146_lru_cache/lru_cache.cc
@@ -20,7 +20,7 @@ class LRUCache {
         }
 
         int value = ht_[key]->second;
-        if (li_.front().second != value) {
+        if (li_.front().first != key) {
             li_.erase(ht_[key]);
             li_.push_front(make_pair(key, value));
             ht_[key] = li_.begin(); // iterator failure
@@ -46,5 +46,5 @@ class LRUCache {
 private:
     int capacity_;
     list<pair<int, int>> li_;
-    unordered_map<int, pair<int, int>::iterator> ht_;
+    unordered_map<int, list<pair<int, int>>::iterator> ht_;
 };
diff --git a/226_invert_binary_tree/invert_binary_tree.cc b/226_invert_binary_tree/invert_binary_tree.cc
@@ -16,8 +16,8 @@ using namespace std;
 class Solution {
 public:
     TreeNode* invertTree(TreeNode* root) {
-        if (root == NULL) {
-            return NULL;
+        if (root == nullptr) {
+            return nullptr;
         }
         
         TreeNode* l = invertTree(root->left);
diff --git a/230_kth_smallest_element_in_a_bst/kth_bst.cc b/230_kth_smallest_element_in_a_bst/kth_bst.cc
@@ -17,8 +17,8 @@ class Solution {
 public:
     int kthSmallest(TreeNode* root, int k) {
         stack<TreeNode*> stk;
-        while (!stk.empty() || root != NULL) {
-            if (root != NULL) {
+        while (!stk.empty() || root != nullptr) {
+            if (root != nullptr) {
                 /* Store the parent node */
                 stk.push(root);
                 root = root->left;
