update

Author: anson627

AddTwoNumbers/AddTwoNumbers.cpp

@@ -23,10 +23,23 @@ struct ListNode {
     ListNode(int x) : val(x), next(NULL) {}
 };
 
+ListNode * pushDummy(ListNode * head) {
+    ListNode * newNode = new ListNode(-1);
+    newNode->next = head;
+    return newNode;
+}
+
+ListNode * popDummy(ListNode * head) {
+    ListNode * delNode = head;
+    head = head->next;
+    delete delNode;
+    return head;
+}
+
 class Solution {
 public:
     ListNode *addTwoNumbers(ListNode *l1, ListNode *l2) {
-        ListNode * l3 = new ListNode(-1), *cur = l3;
+        ListNode * l3 = pushDummy(NULL), *cur = l3;
         int sum = 0;
         while (l1 != NULL || l2 != NULL) {
             if (l1 != NULL) sum += l1->val, l1 = l1->next;
@@ -35,15 +48,8 @@ class Solution {
             cur = cur->next;
             sum /= 10;
         }
-        if (sum != 0) cur->next = new ListNode(sum);
-        return deleteNode(l3);
-    }
-
-    ListNode* deleteNode(ListNode * cur) {
-        ListNode *toDel = cur;
-        cur = cur->next;
-        delete toDel;
-        return cur;
+        if (sum > 0) cur->next = new ListNode(sum);
+        return popDummy(l3);
     }
 };
 

GrayCode/GrayCode.cpp

@@ -24,6 +24,10 @@ using namespace std;
 class Solution {
 public:
     vector<int> grayCode(int n) {
+        return grayCode1(n);
+    }
+
+    vector<int> grayCode1(int n) {
         vector<int> res;
         res.reserve(1 << n);
         res.push_back(0);
@@ -35,6 +39,12 @@ class Solution {
         }
         return res;
     }
+
+    vector<int> grayCode2(int n) {
+        vector<int> res;
+        for (int i = 0; i < (1 << n); i++) res.push_back(i ^ (i >> 1));
+        return res;
+    }
 };
 
 int main() {

LRUCache/LRUCache.cpp

@@ -18,6 +18,12 @@
 
 using namespace std;
 
+struct CacheNode {
+    int key;
+    int value;
+    CacheNode(int k, int v) : key(k), value(v) {};
+};
+
 class LRUCache{
 public:
     LRUCache(int capacity) {
@@ -26,25 +32,36 @@ class LRUCache{
 
     int get(int key) {
         if (!_map.count(key)) return -1;
-        auto it = _map[key];
-        _list.push_front(*it);
-        _list.erase(it);
-        it = _list.begin();
-        _map[key] = it;
-        return it->second;
+        move(key);
+        return _map[key]->value;
     }
 
     void set(int key, int value) {
-        if (_map.count(key)) _list.erase(_map[key]), _map.erase(key);
-        else if (_map.size() == _cap) _map.erase(_list.back().first), _list.pop_back();
-        _list.push_front(make_pair(key, value));
-        _map[key] = _list.begin();
+        if (_map.count(key)) {
+            _map[key]->value = value;
+            move(key);
+        }
+        else {
+            if (_cap == _map.size()) {
+                _map.erase(_list.back().key);
+                _list.pop_back();
+            }
+            _list.push_front(CacheNode(key, value));
+            _map[key] = _list.begin();
+        }
     }
 
 private:
+    void move(int key) {
+        auto it = _map[key];
+        _list.push_front(*it);
+        _list.erase(it);
+        _map[key] = _list.begin();
+    }
+
     int _cap;
-    list<pair<int, int> > _list;
-    unordered_map<int, list<pair<int, int> >::iterator> _map;
+    list<CacheNode> _list;
+    unordered_map<int, list<CacheNode>::iterator> _map;
 };
 
 int main() {

MergeIntervals/MergeIntervals.cpp

@@ -6,7 +6,7 @@
 // return [1,6],[8,10],[15,18].
 //
 // Complexity:
-// O(n)
+// O(nlog(n))
 //============================================================================
 
 #include <iostream>

RemoveDuplicatesfromSortedList/RemoveDuplicatesfromSortedList.cpp

@@ -26,19 +26,17 @@ struct ListNode {
 class Solution {
 public:
     ListNode *deleteDuplicates(ListNode *head) {
-        ListNode * cur = head;
-        while (cur != NULL && cur->next != NULL) {
-            if (cur->val == cur->next->val) cur->next = deleteNode(cur->next);
-            else cur = cur->next;
+        if (head == NULL || head->next == NULL) return head;
+        ListNode * curNode = head;
+        while (curNode != NULL && curNode->next != NULL) {
+            if (curNode->val == curNode->next->val) {
+                ListNode * nextNode = curNode->next;
+                curNode->next = nextNode->next;
+                delete nextNode;
+            }
+            else curNode = curNode->next;
         }
-        return head;
-    }
-
-    ListNode* deleteNode(ListNode * cur) {
-        ListNode *toDel = cur;
-        cur = cur->next;
-        delete toDel;
-        return cur;
+        return  head;
     }
 };
 

RemoveDuplicatesfromSortedListII/RemoveDuplicatesfromSortedListII.cpp

@@ -23,36 +23,40 @@ struct ListNode {
     ListNode(int x) : val(x), next(NULL) {}
 };
 
+
+ListNode * pushHead(ListNode * head) {
+    ListNode * newNode = new ListNode(-1);
+    newNode->next = head;
+    return newNode;
+}
+
+ListNode * popHead(ListNode * head) {
+    ListNode * delNode = head;
+    head = head->next;
+    delete delNode;
+    return head;
+}
+
 class Solution {
 public:
     ListNode *deleteDuplicates(ListNode *head) {
-        ListNode * newNode = new ListNode(-1);
-        newNode->next = head;
-        head = newNode;
+        if (head == NULL || head->next == NULL) return head;
+        head = pushHead(head);
         ListNode * preNode = head, *curNode = head->next;
         while (curNode != NULL) {
             ListNode * nextNode = curNode->next;
-            while (nextNode != NULL && nextNode->val == curNode->val) nextNode = nextNode->next;
-            if (curNode->next == nextNode) {
-                preNode = curNode;
-                curNode = nextNode;
-            }
+            while (nextNode != NULL && curNode->val == nextNode->val) nextNode = nextNode->next;
+            if (curNode->next == nextNode) preNode = curNode, curNode = nextNode;
             else {
                 preNode->next = nextNode;
-                while (curNode != nextNode) curNode = deleteNode(curNode);
+                while (curNode != nextNode) curNode = popHead(curNode);
             }
         }
-        return deleteNode(head);
-    }
-
-    ListNode* deleteNode(ListNode * cur) {
-        ListNode *toDel = cur;
-        cur = cur->next;
-        delete toDel;
-        return cur;
+        return popHead(head);
     }
 };
 
+
 int main() {
     Solution sol;
 

RemoveNthNodeFromEndofList/RemoveNthNodeFromEndofList.cpp

@@ -29,26 +29,30 @@ struct ListNode {
     ListNode(int x) : val(x), next(NULL) {};
 };
 
+ListNode * pushHead(ListNode * head) {
+    ListNode * newNode = new ListNode(-1);
+    newNode->next = head;
+    return newNode;
+}
+
+ListNode * popHead(ListNode * head) {
+    ListNode * delNode = head;
+    head = head->next;
+    delete delNode;
+    return head;
+}
+
 class Solution {
 public:
     ListNode *removeNthFromEnd(ListNode *head, int n) {
-        if (head == NULL || n < 1) return head;
-        ListNode * newNode = new ListNode(-1);
-        newNode->next = head;
-        head = newNode;
-        ListNode * slow = head, *fast = head;
-        while (n > 0 && fast->next != NULL) fast = fast->next, n--;
-        if (n > 0) return deleteNode(head);
-        while (fast->next != NULL) fast = fast->next, slow = slow->next;
-        slow->next = deleteNode(slow->next);
-        return deleteNode(head);
-    }
-
-    ListNode* deleteNode(ListNode * cur) {
-        ListNode *toDel = cur;
-        cur = cur->next;
-        delete toDel;
-        return cur;
+        head = pushHead(head);
+        ListNode * fastNode = head;
+        for (; n > 0 && fastNode != NULL; n--) fastNode = fastNode->next;
+        if (fastNode == NULL) return popHead(head);
+        ListNode * slowNode = head;
+        for (; fastNode->next != NULL; fastNode = fastNode->next) slowNode = slowNode->next;
+        slowNode->next = popHead(slowNode->next)
+        return popHead(head);
     }
 };
 

ReverseLinkedListII/ReverseLinkedListII.cpp

@@ -23,31 +23,36 @@ struct ListNode {
     ListNode(int x) : val(x), next(NULL) {}
 };
 
+ListNode * pushDummy(ListNode * head) {
+    ListNode * newNode = new ListNode(-1);
+    newNode->next = head;
+    return newNode;
+}
+
+ListNode * popDummy(ListNode * head) {
+    ListNode * delNode = head;
+    head = head->next;
+    delete delNode;
+    return head;
+}
+
 class Solution {
 public:
     ListNode *reverseBetween(ListNode *head, int m, int n) {
-        ListNode * newHead = new ListNode(-1);
-        newHead->next = head;
-        ListNode * preNode = NULL, * curNode = newHead;
-        for (int i = 0; i < m; i++) preNode = curNode, curNode = curNode->next;
-        ListNode * preTail = preNode;
-        preNode = NULL;
-        for (int i = 0; i <= n-m; i++) {
+        if (head == NULL || m < 1 || n < 1 || m > n) return head;
+        head = pushDummy(head);
+        ListNode * curNode = head, *lastNode = NULL;
+        for (; m > 0; m--, n--) lastNode = curNode, curNode = curNode->next;
+        ListNode *preNode = NULL;
+        for (; n >= 0; n--) {
             ListNode * nextNode = curNode->next;
             curNode->next = preNode;
             preNode = curNode;
             curNode = nextNode;
         }
-        preTail->next->next = curNode;
-        preTail->next = preNode;
-        return deleteNode(newHead);
-    }
-
-    ListNode * deleteNode(ListNode * curNode) {
-        ListNode * toDel = curNode;
-        curNode = curNode->next;
-        delete toDel;
-        return curNode;
+        lastNode->next->next = curNode;
+        lastNode->next = preNode;
+        return popDummy(head);
     }
 };