add Day7

Jongeun/Day7/141_LinkedListCycle.cpp

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

Jongeun/Day7/146_LRUCache.cpp

@@ -0,0 +1,104 @@
+dclass LRUCache
+{
+public:
+    struct Node
+    {
+        int val;
+        int key;
+        Node *next;
+        Node *pre;
+
+        Node(int k, int value)
+        {
+            key = k;
+            val = value;
+            next = nullptr;
+            pre = nullptr;
+        }
+    };
+
+    LRUCache(int capacity)
+        : cap{capacity}
+    {
+        left = new Node(0, 0);
+        right = new Node(0, 0);
+        left->next = right;
+        right->pre = left;
+    }
+
+    int get(int key)
+    {
+        if (m.find(key) != m.end())
+        {
+            Remove(m[key]);
+            Insert(m[key]);
+            return m[key]->val;
+        }
+        else
+        {
+            return -1;
+        }
+    }
+
+    void put(int key, int value)
+    {
+
+        if (m.find(key) != m.end())
+        { // update the value
+            Node *update = m[key];
+            Remove(update);
+            Insert(update);
+            update->val = value;
+        }
+        else
+        { // Insert new node
+            if (m.size() >= cap)
+            { // remove LRU
+                Node *LRU = left->next;
+                Remove(LRU);
+                m.erase(LRU->key);
+                delete LRU;
+
+                m[key] = new Node(key, value);
+                Insert(m[key]);
+            }
+            else
+            {
+                Node *n = new Node(key, value);
+                m[key] = n;
+                Insert(n);
+            }
+        }
+    }
+
+private:
+    int cap;
+    unordered_map<int, Node *> m;
+    Node *left;
+    Node *right;
+
+    void Remove(Node * node)
+    {
+        Node *pre = node->pre;
+        Node *next = node->next;
+
+        pre->next = next;
+        next->pre = pre;
+    }
+
+    void Insert(Node * node)
+    {
+        Node *pre = right->pre;
+        node->next = right;
+        right->pre = node;
+        pre->next = node;
+        node->pre = pre;
+    }
+};
+
+/**
+ * Your LRUCache object will be instantiated and called as such:
+ * LRUCache* obj = new LRUCache(capacity);
+ * int param_1 = obj->get(key);
+ * obj->put(key,value);
+ */

Jongeun/Day7/287_FindtheDuplicateNumber.cpp

@@ -0,0 +1,37 @@
+#include <iostream>
+#include <vector>
+using namespace std;
+
+class Solution
+{
+public:
+    int findDuplicate(vector<int> &nums)
+    {
+        int slow = nums[0];
+        int fast = nums[nums[0]];
+
+        while (slow != fast)
+        {
+            slow = nums[slow];
+            fast = nums[nums[fast]];
+        }
+
+        slow = nums[0];
+
+        while (slow != fast)
+        {
+            slow = nums[slow];
+            fast = nums[fast];
+        }
+
+        return fast;
+    }
+};
+
+int main()
+{
+    Solution obj;
+    vector<int> nums = {1, 3, 4, 2, 2};
+    cout << obj.findDuplicate(nums) << endl;
+    return 0;
+}