LeetCode first

Author: gitgou

.vscode/settings.json

@@ -0,0 +1,68 @@
+{
+    "files.associations": {
+        "__bit_reference": "cpp",
+        "__config": "cpp",
+        "__debug": "cpp",
+        "__errc": "cpp",
+        "__functional_base": "cpp",
+        "__hash_table": "cpp",
+        "__locale": "cpp",
+        "__mutex_base": "cpp",
+        "__node_handle": "cpp",
+        "__nullptr": "cpp",
+        "__split_buffer": "cpp",
+        "__string": "cpp",
+        "__threading_support": "cpp",
+        "__tuple": "cpp",
+        "algorithm": "cpp",
+        "array": "cpp",
+        "atomic": "cpp",
+        "bit": "cpp",
+        "bitset": "cpp",
+        "cctype": "cpp",
+        "chrono": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "complex": "cpp",
+        "cstdarg": "cpp",
+        "cstddef": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "deque": "cpp",
+        "exception": "cpp",
+        "functional": "cpp",
+        "initializer_list": "cpp",
+        "ios": "cpp",
+        "iosfwd": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "iterator": "cpp",
+        "limits": "cpp",
+        "locale": "cpp",
+        "memory": "cpp",
+        "mutex": "cpp",
+        "new": "cpp",
+        "optional": "cpp",
+        "ostream": "cpp",
+        "ratio": "cpp",
+        "sstream": "cpp",
+        "stack": "cpp",
+        "stdexcept": "cpp",
+        "streambuf": "cpp",
+        "string": "cpp",
+        "string_view": "cpp",
+        "system_error": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "typeinfo": "cpp",
+        "unordered_map": "cpp",
+        "utility": "cpp",
+        "vector": "cpp",
+        "list": "cpp"
+    }
+}

FooBar.cpp

@@ -0,0 +1,47 @@
+#include<iostream>
+#include<semaphore.h>
+using namespace std;
+
+class FooBar {
+private:
+    int n;
+    sem_t sem_foo, sem_bar;
+
+public:
+    FooBar(int n) {
+        this->n = n;
+        sem_init(&sem_foo, 0, 0);
+        sem_init(&sem_bar, 0, 1);
+    }
+
+    ~FooBar()
+    {
+        sem_destroy(&sem_foo);
+        sem_destroy(&sem_bar);
+    }
+
+    void foo(function<void()> printFoo) {
+        
+        for (int i = 0; i < n; i++) {
+            sem_wait(&sem_bar);
+        	// printFoo() outputs "foo". Do not change or remove this line.
+        	printFoo();
+            sem_post(&sem_foo);
+        }
+    }
+
+    void bar(function<void()> printBar) {
+        
+        for (int i = 0; i < n; i++) {
+            sem_wait(&sem_foo);
+        	// printBar() outputs "bar". Do not change or remove this line.
+        	printBar();
+            sem_post(&sem_bar);
+        }
+    }
+};
+
+int main()
+{
+
+}

KthLargest.cpp

@@ -0,0 +1,65 @@
+#include<iostream>
+#include<vector>
+#include<queue>
+#include<functional>
+using namespace std;
+
+//如果使用排序，每次插入的复杂度最小为o(n), 插入查找时查找可以实现o(log(n))，但是移动元素依然需要o(n)。
+//而使用大小顶堆进行插入，调整堆的时间复杂度为o(log(n)),所以最好选用大小顶堆来做选择最大或者最小值。
+//因为返回之后不会删除所有返回的数，使用add操作时会导堆膨胀，所以应该维护一个大小为k的。
+
+class KthLargest {
+public:
+    KthLargest(int k, vector<int>& nums) 
+    :_k(k)
+    {
+        //建堆
+        for(auto & i : nums)
+        {
+            add(i);
+        }
+    }
+
+    int add(int val)
+    {
+        _data.push(val);
+        if(_data.size() > _k)
+        {
+            _data.pop();
+        }
+
+        return _data.top();
+    }
+
+    /* 使用vector排序, 时间复杂度高 
+    int add(int val)
+    {
+        _data.push_back(val);
+        sort(_data.begin(), _data.end(), std::greater<int>());
+        if(_data.size() > _k)
+        {
+            _data.pop_back();
+        }
+            
+        return _data.back();   
+    }
+    */
+
+private:
+    int _k;
+    //优先级队列，建立一个小顶堆， 底层使用堆排序实现
+    priority_queue<int, vector<int>, std::greater<int> > _data;
+};
+
+
+int main()
+{
+    vector<int> vec = {4,5,8,2};
+    KthLargest* k = new KthLargest(3, vec);
+    cout <<  k->add(3) << endl;
+    cout <<  k->add(5) << endl;
+    cout <<  k->add(10) << endl;
+    cout <<  k->add(9) << endl;
+    cout <<  k->add(4) << endl;
+    return 0;
+}

LRUCache.cpp

@@ -0,0 +1,101 @@
+//146. LRU 缓存机制
+#include<iostream>
+#include<list>
+#include<unordered_map>
+
+using namespace std;
+//原理：
+//  LRU: 最近最少使用算法，在cache中，如果cache中容量已满，首先删除元素是在最近时间内，最不经常使用的元素。
+//       注意和最少使用法的区别。
+// 1:使用双向链表list存储数据: pair<int, int> (key, value), LRU; 
+//   选择list 因为 头部、中间插入元素，或者删除尾部元素时间复杂度均为o(1),无需移动元素;
+//   最近使用的元素放在链表的最前面。
+// 2: 选择unordered_map<int, list<pair<int, int>>::iterator> 做哈希表，unordered_map利用哈希表实现， 元素间无序，查找和插入的时间复杂度均为o(1);
+//    所以通过key完成查找节点的时间复杂度o(1)。
+
+//输出双向链表
+std::ostream& operator<<(std::ostream& ostr, const std::list<pair<int, int> >& list)
+{
+    for (auto i : list) {
+        ostr << i.first << ", " << i.second << "; ";
+    }
+    return ostr;
+}
+
+class LRUCache {
+public:
+    using ListIter = list<pair<int, int> >::iterator;
+    using UnorderMapIter = unordered_map<int, ListIter>::iterator; 
+    LRUCache(int capacity) 
+    :_capacity(capacity)
+    {
+        
+    }
+    
+    int get(int key)
+    {
+        UnorderMapIter ite = _cache.find(key); 
+        //
+        //查找时未找到， 直接返回 -1
+        if(ite == _cache.end())
+        {
+            return -1;
+        }
+
+        //如果存在，因为最近一次使用到该元素，所以需将该key的数据移动到链表最前面;
+        _data.splice(_data.begin(), _data, ite->second);
+        //_cache[key] = _data.begin();
+        return ite->second->second;
+    }
+    
+    void put(int key, int value)
+    {
+        UnorderMapIter ite = _cache.find(key); 
+        if(ite == _cache.end())
+        {
+            //如果该元素没在cache中， 需要添加到cache中，首先判断cache是否已满，如果满了，将链表最后一个元素移除
+            if(_data.size() == _capacity)
+            {
+                _cache.erase(_data.back().first);
+                _data.pop_back();
+            }
+
+            _data.push_front(make_pair(key, value));
+            _cache.insert(make_pair(key, _data.begin()));
+        }
+        else
+        {
+            //如果元素已经存在cache中，更新该key的value值，并且将该元素移到链表最前面。
+            ite->second->second = value;
+            _data.splice(_data.begin(), _data, ite->second);
+            _cache[key] = _data.begin();
+        }
+    }
+    //打印链表
+    void print()
+    {
+        cout << _data << endl;
+    }
+private:
+
+    int _capacity; 
+    list<pair<int, int> > _data;
+    unordered_map<int, ListIter> _cache;  
+};
+
+int main()
+{ 
+    LRUCache lru(2);
+    lru.put(1,1);
+    lru.put(2,2);
+    lru.print();
+    lru.put(3,3);
+    lru.print();
+    lru.get(1);
+    lru.print();
+    cout << "get2 " << lru.get(2) << endl;;
+    lru.print();
+    lru.put(2, 3);
+    lru.print();
+    return 0;
+}

addBinary.cpp

@@ -0,0 +1,61 @@
+#include<iostream>
+#include<string>
+
+using namespace std;
+string addBinary(string a, string b)
+{
+    string result;
+    int carry = 0;
+    int index_a = a.size() - 1, index_b = b.size() - 1;
+    while(index_a >= 0 && index_b >= 0)
+    {
+        int i = a[index_a] - 48;
+        int j = b[index_b] - 48;
+        char c = (i + j + carry) % 2 + 48;
+        carry = (i + j + carry) / 2;
+        result.push_back(c);
+        --index_a; --index_b;
+    }
+    cout << "reverse s1 : " << result << endl;
+    //单层遍历
+    while(index_a >= 0)
+    {
+        int i = a[index_a] - 48;
+        char c = (i + carry) % 2 + 48;
+        carry = (i + carry) / 2;
+        result.push_back(c);
+        --index_a;
+    }
+
+    while(index_b >= 0)
+    {
+        int i = b[index_b] - 48;
+        char c = (i + carry) % 2 + 48;
+        carry = (i + carry) / 2;
+        result.push_back(c);
+        --index_b;
+    }
+
+    if(carry == 1)
+    {
+        result.push_back((char)carry + 48);
+    }
+    
+    cout << "result : " << result << endl;
+
+    string s;
+    for(int i = result.size() - 1; i >= 0; --i)
+    {
+        s.push_back(result[i]);
+    }
+
+    return s;
+}
+
+int main()
+{
+    string a = "101";
+    string b = "101";
+    cout << addBinary(a, b) << endl;
+    return 0;
+}