LC Update

Author: Tanjim131

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

@@ -0,0 +1,22 @@
+/**
+ * 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;
+ if(root -> left == nullptr && root -> right == nullptr) return 1;
+ int left = numeric_limits<int>::min(), right = numeric_limits<int>::min();
+ if(root -> left != nullptr) left = maxDepth(root -> left);
+ if(root -> right != nullptr) right = maxDepth(root -> right);
+ return 1 + max(left, right);
+ }
+};

LeetCode/Easy/1047 - Remove All Adjacent Duplicates In String.cpp

@@ -0,0 +1,20 @@
+class Solution {
+public:
+ string removeDuplicates(string S) {
+ stack <char> st;
+ for(int i = 0 ; i < S.length() ; ++i){
+ if(!st.empty() && S[i] == st.top()){
+ while(!st.empty() && st.top() == S[i]) st.pop();
+ } else{
+ st.push(S[i]); 
+ }
+ }
+ string modified(st.size(), '0');
+ int i = modified.length() - 1;
+ while(!st.empty()){
+ modified[i--] = st.top();
+ st.pop();
+ }
+ return modified;
+ }
+};

LeetCode/Easy/111 - Minimum Depth of Binary Tree.cpp

@@ -0,0 +1,85 @@
+/**
+ * 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 minDepth(TreeNode* root) {
+ if(root == nullptr) return 0;
+ if(root -> left == nullptr && root -> right == nullptr) return 1;
+ int left = numeric_limits<int>::max(), right = numeric_limits<int>::max();
+ if(root -> left != nullptr) left = minDepth(root -> left);
+ if(root -> right != nullptr) right = minDepth(root -> right);
+ return 1 + min(left, right);
+ }
+};
+
+/*****************************************************************************************/
+
+class Solution {
+public:
+ void min_depth_util(TreeNode *root, int &min_depth, int depth = 1){
+ if(root -> left == nullptr && root -> right == nullptr){
+ min_depth = min(min_depth, depth);
+ return;
+ }
+ if(depth >= min_depth) return;
+ if(root -> left != nullptr) min_depth_util(root -> left, min_depth, depth + 1);
+ if(root -> right != nullptr) min_depth_util(root -> right, min_depth, depth + 1);
+ }
+ int minDepth(TreeNode* root) {
+ if(root == nullptr) return 0;
+ int min_depth = numeric_limits<int>::max();
+ min_depth_util(root, min_depth);
+ return min_depth;
+ }
+};
+
+/*****************************************************************************************/
+
+/**
+ * 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 minDepth(TreeNode* root) {
+ if(root == nullptr) return 0;
+ queue <TreeNode*> q;
+ map <TreeNode*, int> depths;
+ q.push(root);
+ depths[root] = 1;
+ int depth = -1;
+ while(!q.empty()){
+ TreeNode* current = q.front();
+ q.pop();
+ if(current -> left == nullptr && current -> right == nullptr){
+ depth = depths[current];
+ break;
+ }
+ if(current -> left != nullptr){
+ q.push(current -> left);
+ depths[current -> left] = depths[current] + 1;
+ }
+ if(current -> right != nullptr){
+ q.push(current -> right);
+ depths[current -> right] = depths[current] + 1;
+ }
+ }
+ return depth;
+ }
+};

LeetCode/Easy/1441 - Build an Array With Stack Operations.cpp

@@ -0,0 +1,17 @@
+class Solution {
+public:
+ vector<string> buildArray(vector<int>& target, int n) {
+ int index = 0;
+ vector <string> operations; operations.reserve(n);
+ for(int i = 1 ; index < target.size() ; ++i){
+ if(i == target[index]){
+ operations.emplace_back("Push");
+ index++;
+ } else{
+ operations.emplace_back("Push");
+ operations.emplace_back("Pop");
+ }
+ }
+ return operations;
+ }
+};

LeetCode/Easy/175 - Combine Two Tables.sql

@@ -0,0 +1,4 @@
+# Write your MySQL query statement below
+
+select FirstName, LastName, City, State
+from Person left join Address on Person.PersonId = Address.PersonId;

LeetCode/Easy/176 - Second Highest Salary.sql

@@ -0,0 +1,14 @@
+# Write your MySQL query statement below
+
+
+select MAX(salary) as SecondHighestSalary 
+from Employee
+where salary < (select MAX(salary) from Employee);
+
+-----------------------------------------------------------------------
+
+# Write your MySQL query statement below
+
+select MAX(e1.salary) as SecondHighestSalary 
+from Employee e1 join Employee e2
+where e1.salary < e2.salary;

LeetCode/Easy/844 - Backspace String Compare.cpp

@@ -0,0 +1,56 @@
+
+// O(N) Time, O(N) Space
+class Solution {
+public:
+ bool backspaceCompare(string S, string T) {
+ stack <char> s1;
+ for(int i = 0 ; i < S.length() ; ++i){
+ if(S[i] == '#' && !s1.empty()){
+ s1.pop();
+ } else if(S[i] != '#') {
+ s1.push(S[i]);
+ }
+ }
+ stack <char> s2;
+ for(int i = 0 ; i < T.length() ; ++i){
+ if(T[i] == '#' && !s2.empty()){
+ s2.pop();
+ } else if(T[i] != '#'){
+ s2.push(T[i]);
+ }
+ }
+ return s1 == s2;
+ }
+};
+
+/*********************************************************************************************/
+
+class Solution {
+public:
+ bool backspaceCompare(string S, string T) {
+ int sl = S.length();
+ for(int i = 0 ; i < sl ; ++i){
+ if(S[i] != '#'){
+ S.push_back(S[i]);
+ } else if(S.length() > sl) {
+ S.pop_back();
+ }
+ }
+ int tl = T.length();
+ for(int i = 0 ; i < tl ; ++i){
+ if(T[i] != '#'){
+ T.push_back(T[i]);
+ } else if(T.length() > tl) {
+ T.pop_back();
+ }
+ }
+ if(S.length() - sl != T.length() - tl) return false;
+ for(int i = sl, j = tl ; i < S.length() ; ++i, ++j){
+ if(S[i] != T[j]) return false;
+ }
+ return true;
+ }
+};
+
+// O(N) Time, O(1) Space
+