update leetcode

Author: taviamcboa

100_gp.cpp

@@ -0,0 +1,57 @@
+// 1. recursive
+
+
+class Solution {
+public:
+    bool isSameTree(TreeNode* p, TreeNode* q) {
+        if(p == NULL && q != NULL){
+            return false;
+        }
+        if(p != NULL && q == NULL){
+            return false;
+        }
+        if(q == NULL && p == NULL){
+            return true;
+        }
+        
+        if(p->val != q->val){
+            return false;
+        }
+        return isSameTree(p->left, q->left) && isSameTree(p->right, q->right); 
+        
+    }
+};
+
+// 2.
+class Solution {
+public:
+    bool isSameTree(TreeNode* p, TreeNode* q) {
+        // preorder traversal
+        stack<TreeNode*> stack_p;
+        stack<TreeNode*> stack_q;
+        if(p)   stack_p.push(p);
+        if(q)   stack_q.push(q);
+
+        while(!stack_p.empty() && !stack_q.empty()){
+            TreeNode* cur_p=stack_p.top();
+            TreeNode* cur_q=stack_q.top();
+
+            stack_p.pop();
+            stack_q.pop();
+
+            if(cur_p->val!=cur_q->val) return false;
+
+            if(cur_p->left) stack_p.push(cur_p->left);
+            if(cur_q->left) stack_q.push(cur_q->left);
+
+            if(stack_p.size() != stack_q.size())    return false;
+
+            if(cur_p->right) stack_p.push(cur_p->right);
+            if(cur_q->right) stack_q.push(cur_q->right);
+
+            if(stack_p.size() != stack_q.size())    return false;
+        }
+
+        return stack_p.size() == stack_q.size();
+    }
+};

101_gp.cpp

@@ -0,0 +1,66 @@
+// recursive
+class Solution {
+public:
+    bool isSymmetric(TreeNode* root) {
+        if(!root)
+            return true;
+        return helper(root->left, root->right);
+    }
+    
+    bool helper(TreeNode* node1, TreeNode* node2){
+        if(node1 == NULL && node2 == NULL){
+            return true;
+        }
+        
+        if(node1 == NULL && node2 != NULL){
+            return false; 
+        }
+        
+        if(node1 != NULL && node2 == NULL){
+            return false;
+        }
+        
+        if(node1->val != node2-> val){
+            return false; 
+        }
+        
+        return node1->val == node2-> val && helper(node1->left, node2->right) && helper(node1->right, node2->left);
+        
+    }
+};
+
+//iterative
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    bool isSymmetric(TreeNode* root) {
+        if(!root)
+            return true;
+        queue<TreeNode*> bfs;
+        bfs.push(root);
+        bfs.push(root); 
+        
+        while(bfs.size() > 0){
+            TreeNode* t1 = bfs.front();
+            bfs.pop();
+            TreeNode* t2 = bfs.front();
+            bfs.pop();
+            if (t1 == NULL && t2 == NULL) continue;
+            if (t1 == NULL || t2 == NULL) return false;
+            if (t1->val != t2->val) return false;
+            bfs.push(t1->left);
+            bfs.push(t2->right);
+            bfs.push(t1->right);
+            bfs.push(t2->left);
+        }
+        return true;
+    }
+};

104_gp.cpp

@@ -0,0 +1,56 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    int maxDepth(TreeNode* root) {
+        if(!root)
+            return 0; 
+        return max(maxDepth(root->left), maxDepth(root->right)) + 1;
+    }
+};
+
+
+// iterative 
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    int maxDepth(TreeNode* root) {
+    if(root == NULL)
+        return 0;
+    
+    int res = 0;
+    queue<TreeNode *> q;
+    q.push(root);
+    while(!q.empty())
+    {
+        ++ res;
+        for(int i = 0, n = q.size(); i < n; ++ i)
+        {
+            TreeNode *p = q.front();
+            q.pop();
+            
+            if(p -> left != NULL)
+                q.push(p -> left);
+            if(p -> right != NULL)
+                q.push(p -> right);
+        }
+    }
+    
+    return res;
+    }
+};

121_gp.cpp

@@ -0,0 +1,33 @@
+class Solution {
+public:
+    int maxProfit(vector<int>& prices) {
+        // best buying up to this point
+        vector<int> minBuy(prices.size(), 0); 
+        vector<int> maxSell(prices.size(), 0); 
+        if(prices.size() <= 1){
+            return 0; 
+        }
+        minBuy[0] = prices[0]; 
+        for(int i = 1; i < prices.size(); i++){
+            minBuy[i] = min(minBuy[i-1], prices[i]);
+        }
+        
+        maxSell[prices.size() - 1] = prices[prices.size() - 1];
+        for(int i = prices.size() - 2; i >= 0; i--){
+            maxSell[i] = max(maxSell[i+1], prices[i]);
+        }
+        
+        int result = 0; 
+        
+        for(int i = 0; i < prices.size() - 1; i++){
+            int profit = maxSell[i+1] - minBuy[i];
+            if(profit <= 0)
+                continue;
+            
+            result = max(result, profit); 
+            
+        }
+        
+        return result; 
+    }
+};

136_gp.cpp

@@ -0,0 +1,10 @@
+class Solution {
+public:
+    int singleNumber(vector<int>& nums) {
+        int a = 0;
+        for(int i = 0; i < nums.size(); i++){
+            a ^= nums[i];
+        }
+        return a;
+    }
+};

141_gp.cpp

@@ -0,0 +1,28 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    bool hasCycle(ListNode *head) {
+        ListNode* fast = head; 
+        ListNode* slow = head; 
+        
+        while(fast != NULL && fast->next != NULL){
+            
+            fast = fast->next->next; 
+            slow = slow ->next; 
+            
+            if(fast == slow){
+                return true; 
+            }
+            
+        }
+        
+        return false;
+    }
+};

155_gp.cpp

@@ -0,0 +1,54 @@
+class MinStack {
+public:
+    /** initialize your data structure here. */
+    struct ListNode{
+       int val;
+       int minval; // key record
+       ListNode* next; 
+       ListNode(int val, int minval): val(val), next(NULL), minval(minval){
+           
+       }
+    }; 
+    
+    MinStack() {
+        this->m_header = new ListNode(INT_MAX, INT_MAX); 
+    }
+    
+    ~MinStack() {
+         
+    }
+    
+    void push(int x) {
+        int newmin = this->m_header->next == NULL ? x : min(x, this->m_header->next->minval);
+        ListNode* newNode = new ListNode(x, newmin);
+        ListNode* tmp = this->m_header->next; 
+        this->m_header->next = newNode; 
+        newNode->next = tmp; 
+    }
+    
+    void pop() {
+        ListNode* tmp = this->m_header->next;
+        this->m_header->next = this->m_header->next->next;
+        delete tmp; 
+    }
+    
+    int top() {
+        return this->m_header->next->val; 
+    }
+    
+    int getMin() {
+        return this->m_header->next->minval;
+    }
+    
+private: 
+    ListNode* m_header; 
+};
+
+/**
+ * Your MinStack object will be instantiated and called as such:
+ * MinStack obj = new MinStack();
+ * obj.push(x);
+ * obj.pop();
+ * int param_3 = obj.top();
+ * int param_4 = obj.getMin();
+ */

167.cpp

@@ -0,0 +1,18 @@
+class Solution {
+public:
+    vector<int> twoSum(vector<int>& numbers, int target) {
+        
+        int left = 0; 
+        int right = numbers.size() - 1; 
+        
+        while(left < right){
+            int sum = numbers[left] + numbers[right]; 
+            if(sum > target)
+                right--; 
+            if(sum == target)
+                return vector<int>{left + 1, right + 1}; 
+            if(sum < target)
+                left++;
+        }
+    }
+};

169.cpp

@@ -0,0 +1,7 @@
+class Solution {
+public:
+    int majorityElement(vector<int>& nums) {
+        sort(nums.begin(), nums.end()); 
+        return nums[nums.size() / 2]; 
+    }
+};

172.cpp

@@ -0,0 +1,32 @@
+class Solution {
+public:
+    /*
+   Example Three
+
+By given number 4617.
+
+5^1 : 4617 ÷ 5 = 923.4, so we get 923 factors of 5
+
+5^2 : 4617 ÷ 25 = 184.68, so we get 184 additional factors of 5
+
+5^3 : 4617 ÷ 125 = 36.936, so we get 36 additional factors of 5
+
+5^4 : 4617 ÷ 625 = 7.3872, so we get 7 additional factors of 5
+
+5^5 : 4617 ÷ 3125 = 1.47744, so we get 1 more factor of 5
+
+5^6 : 4617 ÷ 15625 = 0.295488, which is less than 1, so stop here.
+
+Then 4617! has 923 + 184 + 36 + 7 + 1 = 1151 trailing zeroes.
+
+C/C++ code
+*/
+
+    int trailingZeroes(int n) {
+        int result = 0;
+        for(long long i=5; n/i>0; i*=5){
+            result += (n/i);
+        }
+        return result;
+    }
+};