solutions for leetcode

Author: andy2git

Binary_Tree_Level_Order_Traversal.cpp

@@ -0,0 +1,38 @@
+/**
+ * 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<vector<int>> levelOrder(TreeNode *root) {
+        if(root == nullptr) return vector<vector<int>>();
+        
+        vector<vector<int>> result;
+        queue<TreeNode *> p, q;
+        p.push(root);
+        
+        vector<int> layer;
+        TreeNode *t = nullptr;
+        while(!p.empty()){
+            t = p.front();
+            
+            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.push_back(layer);
+                layer.clear();
+            }
+        }
+        
+        return result;
+    }
+};

Binary_Tree_Level_Order_Traversal_2.cpp

@@ -0,0 +1,38 @@
+/**
+ * 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<vector<int>> levelOrderBottom(TreeNode *root) {
+        if(root == nullptr) return vector<vector<int>>();
+        
+        vector<vector<int>> result;
+        queue<TreeNode *> p, q;
+        p.push(root);
+        
+        vector<int> layer;
+        TreeNode *t = nullptr;
+        while(!p.empty()){
+            t = p.front();
+            
+            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);
+                layer.clear();
+            }
+        }
+        
+        return result;
+    }
+};

Binary_Tree_Zigzag_Order_Traversal.cpp

@@ -0,0 +1,46 @@
+/**
+ * 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<vector<int> > zigzagLevelOrder(TreeNode *root) {
+        if(root == nullptr) return vector<vector<int>>();
+        
+        vector<vector<int>> result;
+        queue<TreeNode *> p, q;
+        p.push(root);
+        
+        vector<int> layer;
+        bool flag = true;
+        TreeNode *t = nullptr;
+        while(!p.empty()){
+            t = p.front();
+            
+            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);
+                if(flag){
+                    result.push_back(layer);
+                    flag = false;
+                }else{
+                    reverse(layer.begin(), layer.end());
+                    result.push_back(layer);
+                    flag = true;
+                }
+                layer.clear();
+            }
+        }
+        
+        return result;
+    }
+};

Construct_Binary_Tree_from_Inorder_and_Postorder_Traversal.cpp

@@ -0,0 +1,33 @@
+/**
+ * Definition for binary tree
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    TreeNode *buildTree(vector<int> &inorder, vector<int> &postorder) {
+        if(inorder.empty() || postorder.empty()) return nullptr;
+        if(inorder.size() == 1 && postorder.size() == 1) return new TreeNode(inorder[0]);
+        
+        unordered_map<int, int> map;
+        for(int i = 0; i < inorder.size(); i++){
+            map[inorder[i]] = i;
+        }
+        return build_tree_helper(inorder, 0, inorder.size()-1, postorder, 0, postorder.size()-1, map);
+    }
+private:
+    TreeNode *build_tree_helper(vector<int> &A, int l, int h, vector<int> &B, int s, int e, unordered_map<int, int> &map){
+        if(l > h || s > e) return nullptr;
+        
+        int k = map[B[e]] - l;
+        TreeNode *root = new TreeNode(B[e]);
+        root->left = build_tree_helper(A, l, l+k-1, B, s, s+k-1, map);
+        root->right = build_tree_helper(A, l+k+1, h, B, s+k, e-1, map);
+        
+        return root;
+    }
+};

Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.cpp

@@ -0,0 +1,35 @@
+/**
+ * Definition for binary tree
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder) {
+        if(preorder.empty() || inorder.empty()) return nullptr;
+        if(preorder.size() == 1 && inorder.size() == 1) return new TreeNode(preorder[0]);
+        
+        unordered_map<int, int> map;
+        for(int i = 0; i <inorder.size(); i++){
+            map[inorder[i]] = i;
+        }
+        
+        return tree_helper(preorder, 0, preorder.size()-1, inorder, 0, inorder.size()-1, map);
+    }
+private:
+    TreeNode *tree_helper(vector<int> &A, int l, int h, vector<int> &B, int s, int e, unordered_map<int, int> &map){
+        if(l > h || s > e) return nullptr;
+        
+        int k = map[A[l]]-s;
+        
+        TreeNode *root = new TreeNode(A[l]);
+        root->left = tree_helper(A, l+1, l+k, B, s, s+k-1, map);
+        root->right = tree_helper(A, l+k+1, h, B, s+k+1, e, map);
+        
+        return root;
+    }
+};

Convert_Sorted_Array_to_Binary_Search_Tree.cpp

@@ -0,0 +1,29 @@
+/**
+ * Definition for binary tree
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    TreeNode *sortedArrayToBST(vector<int> &num) {
+        if(num.empty()) return nullptr;
+        if(num.size() == 1) return new TreeNode(num[0]);
+        
+        return bst_helper(num, 0, num.size()-1);
+    }
+ private:   
+    TreeNode *bst_helper(vector<int> &A, int l, int h){
+        if(l > h) return nullptr;
+        
+        int m = l + (h-l)/2;
+        TreeNode *root = new TreeNode(A[m]);
+        root->left = bst_helper(A, l, m-1);
+        root->right = bst_helper(A, m+1, h);
+        
+        return root;
+    }
+};

Convert_Sorted_List_to_Binary_Search_Tree.cpp

@@ -0,0 +1,43 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+/**
+ * Definition for binary tree
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    TreeNode *sortedListToBST(ListNode *head) {
+        if(head == nullptr) return nullptr;
+        if(head->next == nullptr) return new TreeNode(head->val);
+        
+        ListNode *p = head;
+        ListNode *q = head->next->next;
+        
+        while(q){
+            if(q->next) q= q->next->next;
+            else break;
+            
+            p = p->next;
+        }
+        
+        q = p->next;
+        p->next = nullptr;
+        
+        TreeNode *root = new TreeNode(q->val);
+        root->left = sortedListToBST(head);
+        root->right = sortedListToBST(q->next);
+        
+        return root;
+    }
+};

linked_list_cycle.cpp

@@ -0,0 +1,27 @@
+/**
+ * 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) {
+        if(head == nullptr) return false;
+        if(head->next == nullptr) return false;
+        
+        ListNode *p = head;
+        ListNode *q = head->next->next;
+        
+        while(q && p != q){
+            p = p->next;
+            if(q->next) q = q->next->next;
+            else break;
+        }
+        
+        if(p == q) return true;
+        else return false;
+    }
+};

linked_list_cycle_2.cpp

@@ -0,0 +1,37 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode *detectCycle(ListNode *head) {
+        if(head == nullptr) return nullptr;
+        if(head->next == nullptr) return nullptr;
+        
+        // p and q has to start from the same point
+        ListNode *p = head;
+        ListNode *q = head;
+        
+        while(q){
+            p = p->next;
+            if(q->next) {
+                q = q->next->next;
+            }else break;
+            
+            if(p == q) break;
+        }
+        
+        if(p != q) return nullptr;
+        
+        q = head;
+        while(q != p){
+            p = p->next;
+            q = q->next;
+        }
+        return p;
+    }
+};

sort_list.cpp

@@ -0,0 +1,52 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode *sortList(ListNode *head) {
+        if(head == nullptr) return nullptr;
+        if(head->next == nullptr) return head;
+        
+        ListNode *p = head;
+        ListNode *q = head->next->next;
+        
+        while(q){
+            if(q->next) q = q->next->next;
+            else break;
+            p = p->next;
+        }
+        q = p->next;
+        p->next = nullptr;
+        
+        ListNode *left = sortList(head);
+        ListNode *right = sortList(q);
+        return merge_list(left, right);
+    }
+private:
+    ListNode *merge_list(ListNode *left, ListNode *right){
+        ListNode dummy(0);
+        ListNode *d = &dummy;
+        
+        while(left && right){
+            if(left->val < right->val){
+                d->next = left;
+                left = left->next;
+                d = d->next;
+            }else{
+                d->next = right;
+                right = right->next;
+                d = d->next;
+            }
+        }
+        
+        if(left) d->next = left;
+        if(right) d->next = right;
+        
+        return dummy.next;
+    }
+};