LRU and New using usage

Signed-off-by: xuyuanhui <xuyuanhui@huayun.com>

Author: xuyuanhui

Language/C_plus/LRU/LruCache.cpp

@@ -0,0 +1,144 @@
+#include <iostream>
+#include <map>
+
+using namespace std;
+
+class Node {
+  public:
+  int key, value;
+  Node *prev, *next;
+  Node(int k, int v): key(k), value(v), prev(NULL), next(NULL) {}
+};
+
+class DoublyLinkedList {
+  Node *front, *rear;
+
+  bool isEmpty() {
+      return rear == NULL;
+  }
+
+  public:
+  DoublyLinkedList(): front(NULL), rear(NULL) {}
+
+  Node* add_page_to_head(int key, int value) {
+      Node *page = new Node(key, value);
+      if(!front && !rear) {
+          front = rear = page;
+      }
+      else {
+          page->next = front;
+          front->prev = page;
+          front = page;
+      }
+      return page;
+  }
+
+  void move_page_to_head(Node *page) {
+      if(page==front) {
+          return;
+      }
+      if(page == rear) {
+          rear = rear->prev;
+          rear->next = NULL;
+      }
+      else {
+          page->prev->next = page->next;
+          page->next->prev = page->prev;
+      }
+
+      page->next = front;
+      page->prev = NULL;
+      front->prev = page;
+      front = page;
+  }
+
+  void remove_rear_page() {
+      if(isEmpty()) {
+          return;
+      }
+      if(front == rear) {
+          delete rear;
+          front = rear = NULL;
+      }
+      else {
+          Node *temp = rear;
+          rear = rear->prev;
+          rear->next = NULL;
+          delete temp;
+      }
+  }
+  Node* get_rear_page() {
+      return rear;
+  }
+
+};
+
+class LRUCache{
+  int capacity, size;
+  DoublyLinkedList *pageList;
+  map<int, Node*> pageMap;
+
+  public:
+    LRUCache(int capacity) {
+      this->capacity = capacity;
+      size = 0;
+        pageList = new DoublyLinkedList();
+        pageMap = map<int, Node*>();
+    }
+
+    int get(int key) {
+        if(pageMap.find(key)==pageMap.end()) {
+          return -1;
+        }
+        int val = pageMap[key]->value;
+
+        // move the page to front
+        pageList->move_page_to_head(pageMap[key]);
+        return val;
+    }
+
+    void put(int key, int value) {
+      if(pageMap.find(key)!=pageMap.end()) {
+          // if key already present, update value and move page to head
+          pageMap[key]->value = value;
+          pageList->move_page_to_head(pageMap[key]);
+          return;
+      }
+
+        if(size == capacity) {
+          // remove rear page
+          int k = pageList->get_rear_page()->key;
+          pageMap.erase(k);
+          pageList->remove_rear_page();
+          size--;
+        }
+
+        // add new page to head to Queue
+        Node *page = pageList->add_page_to_head(key, value);
+        size++;
+        pageMap[key] = page;
+    }
+
+    ~LRUCache() {
+      map<int, Node*>::iterator i1;
+      for(i1=pageMap.begin();i1!=pageMap.end();i1++) {
+          delete i1->second;
+      }
+      delete pageList;
+    }
+};
+
+int main() {
+  LRUCache cache(2);  // cache capacity 2
+  cache.put(2,2);
+  cout << cache.get(2) << endl;
+  cout << cache.get(1) << endl;
+  cache.put(1,1);
+  cache.put(1,5);
+  cout << cache.get(1) << endl;
+  cout << cache.get(2) << endl;
+  cache.put(8,8);
+  cout << cache.get(1) << endl;
+  cout << cache.get(8) << endl;
+}
+

Language/C_plus/Using/UsingUsage.cpp

@@ -0,0 +1,76 @@
+#include <iostream>
+#include <vector>
+#include <map>
+using namespace std;
+
+class Base
+{
+public:
+    void menfcn()
+    {
+        cout << "Base function" << endl;
+    }
+    void menfcn(int n)
+    {
+        cout << "Base function with int" << endl;
+    }
+};
+
+class Derived : public Base
+{
+public:
+    using Base::menfcn;
+    int menfcn(int num)
+    {
+        cout << "Derived functin with int: " << num << endl;
+        return num;
+    }
+
+};
+
+using IntVec = std::vector<int>;
+
+void testUsing()
+{
+    IntVec vec = {1, 2, 3, 4, 5};
+    vec.push_back(123);
+    for (int num : vec)
+        cout << "vec num " << num << endl;
+    cout << is_same < std::vector<int>, IntVec>::value << endl;
+}
+
+template <typename T>
+using MapStr = std::map<T, std::string>;
+void testUsing2()
+{
+    MapStr<int> intStrMap;
+    intStrMap.insert(make_pair(123, "aaa"));
+    intStrMap.insert(make_pair(456, "bbb"));
+    MapStr<int>::iterator iter;
+
+    for (iter = intStrMap.begin(); iter != intStrMap.end(); iter++)
+        cout << iter->first << " " << iter->second << endl;
+
+    MapStr<std::string> strStrMap;
+    strStrMap.insert(make_pair("ccc", "ddd"));
+    strStrMap.insert(make_pair("eee", "fff"));
+    MapStr<std::string>::iterator striter;
+
+    for (striter = strStrMap.begin(); striter != strStrMap.end(); striter++)
+        cout << striter->first << " " << striter->second << endl;
+}
+
+int main()
+{
+    Base b;
+    Derived d;
+    b.menfcn();
+    d.menfcn();
+    d.menfcn(123);
+
+    testUsing();
+    testUsing2();
+
+    return 0;
+}
+