random

Author: prajwal714

Leetcode/Math/plus-one.cpp

@@ -0,0 +1,25 @@
+class Solution {
+public:
+    vector<int> plusOne(vector<int>& digits) {
+        
+        vector<int> res(digits.begin(), digits.end());
+        
+        reverse(res.begin(), res.end());
+        
+        int carry=1;
+        
+        for(int i=0;i<res.size();i++)
+        {
+            int temp=(res[i]+carry)/10;
+            res[i]=(res[i]+carry)%10;
+            carry=temp;
+        }
+        
+        if(carry!=0)
+            res.push_back(carry);
+        
+        reverse(res.begin(), res.end());
+        
+        return res;
+    }
+};

Leetcode/Trees/maximum-binary-tree.cpp

@@ -0,0 +1,89 @@
+/**
+ * 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) {}
+ * };
+ */
+
+//O(N^2) time complexity
+class Solution {
+public:
+    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
+        
+        
+        return helper(nums, 0, nums.size()-1);
+        
+        
+    }
+    
+    
+   TreeNode* helper(vector<int> &nums, int left, int right  )
+    {
+      if(left>right)return NULL;
+        
+        int max_index = left;
+        for(int i = left; i<=right; i++){
+            if(nums[i] > nums[max_index])max_index = i; 
+        }
+        
+        TreeNode* root = new TreeNode(nums[max_index]);
+        root->left = helper(nums, left, max_index - 1);
+        root->right = helper(nums, max_index + 1, right);
+        return root;
+    }
+    
+   
+};
+
+//======================================O(N) solution using stack
+
+/**
+ * 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:
+    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
+        
+        
+       stack<TreeNode*> s;
+        for(int num:nums)
+        {
+            TreeNode* curr=new TreeNode(num);
+            
+            while(!s.empty()&& s.top()->val<curr->val)
+            {
+                curr->left=s.top();
+                s.pop();
+            }
+            
+            if(!s.empty())
+                s.top()->right=curr;
+            
+            s.push(curr);
+        }
+        
+        while(s.size()>1)
+            s.pop();
+        
+        return s.top();
+        
+        
+    }
+    
+    
+ 
+   
+};