More solutions

Author: andy2git

Binary_Tree_Level_Order_Traversal_2.cpp

@@ -12,20 +12,21 @@ class Solution {
     vector<vector<int>> levelOrderBottom(TreeNode *root) {
         if(root == nullptr) return vector<vector<int>>();
 
-        vector<vector<int>> result;
         queue<TreeNode *> p, q;
         p.push(root);
 
+        vector<vector<int>> result;
         vector<int> layer;
         TreeNode *t = nullptr;
+        
         while(!p.empty()){
             t = p.front();
-            
+            p.pop();
             layer.push_back(t->val);
+            
             if(t->left) q.push(t->left);
             if(t->right) q.push(t->right);
 
-            p.pop();
             if(p.empty()){
                 swap(p, q);
                 result.insert(result.begin(), layer);

Binary_Tree_Postorder_Traversal.cpp

@@ -0,0 +1,40 @@
+/**
+ * Definition for binary tree
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    vector<int> postorderTraversal(TreeNode *root) {
+        // IMPORTANT: Please reset any member data you declared, as
+        // the same Solution instance will be reused for each test case.
+        if(root == nullptr) return {};
+        
+        stack<TreeNode *> p, q;
+        p.push(root);
+        
+        TreeNode *t = nullptr;
+        while(!p.empty()){
+            t = p.top();
+            p.pop();
+            
+            if(t->left) p.push(t->left);
+            if(t->right) p.push(t->right);
+            q.push(t);
+        }
+       
+        vector<int> result;
+        while(!q.empty()){
+            t = q.top();
+            q.pop();
+            result.push_back(t->val);
+        }
+        
+        return result;
+    }
+};
+    

Container_With_Most_Water.cpp

@@ -0,0 +1,46 @@
+class Solution {
+public:
+    int maxArea(vector<int> &height) {
+        if(height.empty()) return 0;
+        
+        int i = 0;
+        int j = (int)height.size()-1;
+        int max_area = min(height[i], height[j])*(j-i);
+        
+        while(i < j){
+            if(height[i] < height[j]){
+                i = next_forward(height, i);
+                if(i < 0) break;
+            }else{
+                j = next_backward(height, j);
+                if(j < 0) break;
+            }
+            
+            int t = min(height[i], height[j])*(j-i);
+            if(t > max_area){
+                max_area = t;
+            }
+        }
+        
+        return max_area;
+    }
+    
+private:
+    // (s, ---)
+    int next_forward(vector<int> &A, int s){
+        for(int i = s+1; i < A.size(); i++){
+            if(A[i] > A[s]) return i;
+        }
+        
+        return -1;
+    }
+    
+    int next_backward(vector<int> &A, int e){
+        for(int i = e-1; i >= 0; i--){
+            if(A[i] > A[e]) return i;
+        }
+        
+        return -1;
+    }
+    
+};

Generate_Parentheses.cpp

@@ -0,0 +1,24 @@
+class Solution {
+public:
+    vector<string> generateParenthesis(int n) {
+        if(n == 1) return {"()"};
+        
+        vector<string> result;
+        string sofar = "(";
+        
+        parenthesis_helper(result, sofar, 1, 1, 0, 2*n);
+        return result;
+    }
+private:
+    void parenthesis_helper(vector<string> &result, string sofar, int k, int l, int r, int m){
+        if(k == m){
+            result.push_back(sofar);
+            return;
+        }
+        
+        if(r > l) return;
+        
+        if(l < m/2) parenthesis_helper(result, sofar + "(", k+1, l+1, r, m);
+        if(r < m/2) parenthesis_helper(result, sofar + ")", k+1, l, r+1, m);
+    }
+};

Gray_Code.cpp

@@ -0,0 +1,22 @@
+class Solution {
+public:
+    vector<int> grayCode(int n) {
+        if(n == 0) return {0};
+        
+        vector<int> result = {0, 1};
+        int k = 1;
+        int add = 1;
+        int t;
+        
+        while(k < n){
+            t = result.size();
+            add *= 2;
+            for(int i = t-1; i >= 0; i--){
+                result.push_back(result[i]+add);
+            }
+            k++;
+        }
+        
+        return result;
+    }
+};

Length_of_Last_Word.cpp

@@ -0,0 +1,20 @@
+class Solution {
+public:
+    int lengthOfLastWord(const char *s) {
+        int cnt = 0;
+        
+        while(*s){
+            while(*s && *s == ' ') s++;
+            
+            if(*s) cnt = 0;
+            else return cnt;
+            
+            while(*s && isalpha(*s)){
+                s++;
+                cnt++;
+            }
+        }
+        
+        return cnt;
+    }
+};

Maximum_Depth_of_Binary_Tree.cpp

@@ -0,0 +1,19 @@
+/**
+ * Definition for binary tree
+ * 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 == nullptr) return 0;
+        if(root->left == nullptr && root->right == nullptr) return 1;
+        
+        return max(maxDepth(root->left), maxDepth(root->right))+1;
+    }
+};
+

Pascal_Triangle.cpp

@@ -0,0 +1,28 @@
+class Solution {
+public:
+    vector<vector<int> > generate(int numRows) {
+        if(numRows <= 0) return vector<vector<int>>();
+
+        vector<vector<int>> result = {{1}};
+        vector<int> layer;
+        int k = 2;
+        int t;
+        
+        while(k <= numRows){
+            layer.clear();
+            for(int i = 0; i < k; i++){
+                
+                if(i > 0) t = result[k-2][i-1];
+                else t = 0;
+                
+                if(i < k-1) t += result[k-2][i];
+                else t += 0;
+                layer.push_back(t);
+            }
+            result.push_back(layer);
+            k++;
+        }
+        
+        return result;
+    }
+};

Plus_One.cpp

@@ -0,0 +1,25 @@
+class Solution {
+public:
+    vector<int> plusOne(vector<int> &digits) {
+        int cbit = 1;
+        vector<int> result(digits);
+        
+        for(int i = digits.size()-1; i >= 0; i--){
+            if(digits[i] == 9){
+                if(cbit == 1){
+                    cbit = 1;
+                    result[i] = 0;
+                }
+            }else{
+                if(cbit == 1){
+                    cbit = 0;
+                    result[i]++;
+                }
+            }
+        }
+        
+        if(cbit == 1) result.insert(result.begin(), 1);
+        
+        return result;
+    }
+};

Rotate_Image.cpp

@@ -0,0 +1,39 @@
+class Solution {
+public:
+    void rotate(vector<vector<int> > &matrix) {
+        if(matrix.empty()) return;
+        
+        fold_dig(matrix);
+        fold_horiz(matrix);
+        
+    }
+    
+private:
+    void fold_dig(vector<vector<int>> &M){
+        int n = (int)M.size();
+        
+        for(int i = 0; i < n; i++){
+            for(int j = i+1; j < n; j++){
+                swap(M[i][j], M[j][i]);
+            }
+        }
+    }
+    
+    void fold_horiz(vector<vector<int>> &M){
+        int i = 0;
+        int j = (int)M.size()-1;
+        
+        while(i < j){
+            swap_col(M, i, j);    
+            i++;
+            j--;
+        }
+    }
+    
+    void swap_col(vector<vector<int>> &M, int i, int j){
+        for(int k = 0; k < M.size(); k++){
+            swap(M[k][i], M[k][j]);
+        }
+    }
+    
+};