ALL DSA Problems

Author: alisamad1

Leetcode_Practice_Questions

@@ -0,0 +1,13 @@
+// we will be writing the code for two sum (Leetcode #1)
+vector<int> twoSum(vector<int>& nums, int target) {
+    int n = nums.size();
+    unordered_map<int,int> hashmap;
+    for(int i = 0; i<n;i++){
+        int diff = target - nums[i];
+        if(hashmap.find(diff) != hashmap.end()){
+            return {hashmap[diff],i};
+        }
+        hashmap[nums[i]] = i;
+    }
+    return{};
+}

Leetcode_Practice_Questions/LC_1.cpp

@@ -0,0 +1,18 @@
+// we will be writing the code for Same Tree (Leetcode #100)
+bool isSameTree(TreeNode* p, TreeNode* q) {
+    if(p==NULL &&  q==NULL){
+        return true;
+    }
+    else if(p ==NULL && q!= NULL){
+        return false;
+    }
+    else if (p!= NULL && q==NULL){
+        return false;
+    }
+    else if(p->val != q-> val){
+        return false;
+    }
+    else{
+        return isSameTree(p->left,q->left) && isSameTree(p->right, q->right);
+    }
+}

Leetcode_Practice_Questions/LC_100.cpp

@@ -0,0 +1,20 @@
+// we will be writing the code for Construct Binary Search Tree from Preorder Traversal (Leetcode # 1008)
+TreeNode* bstFromPreorder(vector<int>& preorder) {
+    return build_tree(preorder, 0, preorder.size() -1);
+}
+TreeNode* build_tree(vector<int>& preorder, int l, int r){
+    if(l>r){
+        return nullptr;
+    }
+    TreeNode* root = new TreeNode(preorder[l]);
+    if(l == r){
+        return root;
+    }
+    int idx = l+1;
+    while(idx <= r && preorder[idx] < preorder[l]){
+        idx++;
+    }
+    root->left = build_tree(preorder,l+1,idx-1);
+    root->right = build_tree(preorder,idx,r);
+    return root;
+}

Leetcode_Practice_Questions/LC_1008.cpp

@@ -0,0 +1,26 @@
+// we wil be writing the code for Binary Tree Level Order Traversal (LeetCode #102)
+vector<vector<int>> levelOrder(TreeNode* root) {
+    if(root == nullptr){
+        return vector<vector<int>>();
+    }
+    queue<TreeNode*>q;
+    q.push(root);
+    vector<vector<int>>result;
+    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){
+                q.push(Node->left);
+            }
+            if(Node->right){
+                q.push(Node->right);
+            }
+        }
+        result.push_back(level);
+    }
+    return result;
+}

Leetcode_Practice_Questions/LC_102.cpp

@@ -0,0 +1,25 @@
+// we will be writing the code for maximum difference between Node and Ancestor (Leetcode #1026)
+int maxi = 0;
+    pair<int,int> ok(TreeNode* root){
+        if(root == NULL) return {0,0};
+        auto l = (root->left==NULL ? make_pair(0,0): ok(root->left));
+        auto r = (root->right==NULL ? make_pair(0,0): ok(root->right));
+        if(root->left == NULL && root->right==NULL) return {root->val,root->val};
+        int curr_maxi = root->val;
+        int curr_mini = root->val;
+        if(root->left!= NULL){
+            maxi = max({maxi,abs(root->val - l.first),abs(root->val - l.second)});
+            curr_maxi = max(curr_maxi,l.second);
+            curr_mini = min(curr_mini,l.first);
+        }
+        if(root->right!=NULL){
+            maxi= max({maxi,abs(root->val - r.first), abs(root->val - r.second)});
+            curr_maxi = max(curr_maxi,r.second);
+            curr_mini = min(curr_mini,r.first);
+        }
+        return {curr_mini,curr_maxi};
+    }
+    int maxAncestorDiff(TreeNode* root) {
+        ok(root);
+        return maxi;        
+    }

Leetcode_Practice_Questions/LC_1026.cpp

@@ -0,0 +1,20 @@
+// we will be writing the code for Remove All Adjacent Duplicates in String (Leetcode #1047)
+string removeDuplicates(string s) {
+    string ans = "";
+    int i = 0;
+    while(i<s.length()){
+        if(ans.length() > 0){
+            if(ans[ans.length() - 1] == s[i]) {
+                ans.pop_back();
+            }
+            else{
+                ans.push_back(s[i]);
+            }
+        }
+        else{
+            ans.push_back(s[i]);
+        }
+        i++;
+    }
+    return ans;
+}

Leetcode_Practice_Questions/LC_1047.cpp

@@ -0,0 +1,42 @@
+// we will be writing the code for Container with Most Water(Leetcode #11)
+int maxArea(vector<int>& height) {
+    int min_height = height[0];
+    int max_height = height[height.size()-1];
+    int min_idx = 0;
+    int max_idx = height.size()-1;
+    if(max_height < min_height){
+        min_height = max_height;
+        min_idx = max_idx;
+        max_height = height[0];
+        max_idx = 0;
+    }
+    int w = height.size() - 1;
+    int max_area = min_height * w;
+    while(w > 0){
+        int idx = min_idx;
+        while(height[idx] <= min_height){
+            if(min_idx < max_idx){
+                idx++;
+            }
+            else{
+                idx--;
+            }
+            w--;
+            if(w<1){
+                break;
+            }
+        }
+        if(height[idx] > max_height){
+            min_height = max_height;
+            min_idx = max_idx;
+            max_idx = idx;
+            max_height = height[idx];
+        }
+        else{
+            min_idx = idx;
+            min_height = height[idx];
+        }
+        max_area = max(max_area, w*min_height);
+    }
+    return max_area;
+}

Leetcode_Practice_Questions/LC_11.cpp

@@ -0,0 +1,20 @@
+// we will be writing the code for Balanced Binary Tree (Leetcode #110)
+bool isBalanced(TreeNode* root) {
+    bool ans = true;
+    checkBalance(root,ans);
+    return ans;  
+  }
+  int checkBalance(TreeNode* root, bool &ans){
+      if(root==NULL){
+          return 0;
+      }
+      if(root->left == NULL && root->right== NULL){
+          return 1;
+      }
+      int left = checkBalance(root->left,ans);
+      int right = checkBalance(root->right,ans);
+      if(abs(left - right)>1){
+          ans = false;
+      }
+      return left>right ? left+1 : right + 1;
+  }

Leetcode_Practice_Questions/LC_110.cpp

@@ -0,0 +1,18 @@
+// we will be writing the code for Minimum Depth of Binary Tree (Leetcode #111)
+int minDepth(TreeNode* root) {
+    if(root == NULL){
+        return 0;
+    }
+    if(root->left == NULL && root->right == NULL){
+        return 1;
+    }
+    int left = minDepth(root->left);
+    int right = minDepth(root->right);
+    if(left == 0){
+        return right + 1;
+    }
+    if(right == 0){
+        return left + 1;
+    }
+    return left<right ? left + 1: right+1;
+}