add stack

Author: Ehco1996

docs/03_链表/double_link_list.py

@@ -45,13 +45,14 @@ def appendleft(self, value):
             raise Exception('LinkedList is Full')
         node = Node(value=value)
         if self.root.next is self.root:   # empty
-            node.next = self.root
             node.prev = self.root
+            node.next = self.root
             self.root.next = node
             self.root.prev = node
         else:
-            node.prev = self.root
             headnode = self.root.next
+
+            node.prev = self.root
             node.next = headnode
             headnode.prev = node
             self.root.next = node

ehco/link_list/lru.py

@@ -1,3 +1,6 @@
+from collections import OrderedDict
+
+
 class Node:
     def __init__(self, value=None, next=None, prev=None):
         self.value = value
@@ -32,13 +35,15 @@ def append(self, value):
 
         self.tail.next = node
         node.prev = self.tail
+        node.next = self.root
         self.root.prev = node
         self.lens += 1
 
     def append_left(self, value):
         node = Node(value)
 
         node.next = self.head
+        self.head.prev = node
         self.root.next = node
         node.prev = self.root
         self.lens += 1
@@ -58,7 +63,7 @@ def remove(self, node):
 
     def iter_item(self):
         cur = self.root.next
-        while cur:
+        while cur and cur != self.root:
             yield cur
             cur = cur.next
 
@@ -114,55 +119,68 @@ def _append(self, k, v):
         # Bind cache key
         self._link.tail.cache_key = k
 
-    def _expired(self):
+    def _expired_not_used(self):
         need_expired = self._link.head
         self._link.remove(need_expired)
-        del self._cache[need_expired.cache_key]
-
-    @property
-    def now_count(self):
-        return self._link.lens
 
     def get(self, k):
-        node = self._cache.get(k, None)
+        node = self._cache.pop(k, None)
         if not node:
             return
         self._move_to_recent(node)
         return node.value
 
-    def set(self, k, v):
-        if k in self._cache:
-            node = self._cache[k]
+    def put(self, k, v):
+        node = self._cache.pop(k, None)
+        if node:
             node.value = v
             self._move_to_recent(node)
         else:
-            if self.now_count == self.size:
-                self._expired()
+            if self._link.lens == self.size:
+                self._expired_not_used()
             self._append(k, v)
-        return True
 
     def __str__(self):
         return "->".join([f"{node.cache_key}" for node in self._link.iter_item()])
 
     __repr__ = __str__
 
 
+class OLRU:
+    def __init__(self, size=10):
+        self._cache = OrderedDict()
+        self.size = size
+
+    def get(self, k):
+        ret = self._cache.pop(k, None)
+        if ret:
+            self._cache[k] = ret
+        return ret
+
+    def put(self, k, v):
+        ret = self._cache.pop(k, None)
+        if not ret and len(self._cache) == self.size:
+            # NOTE pop last recent used item
+            self._cache.popitem(False)
+        self._cache[k] = v
+
+
 def test_lru():
     lru = LRU(size=10)
 
     for i in range(10):
-        lru.set(i, i)
+        lru.put(i, i)
 
     for i in range(10):
         assert lru.get(i) == i
 
     print(lru)
-    lru.set(11, 11)
+    lru.put(11, 11)
     assert lru.get(11) == 11
     print(lru)
 
     assert lru.get(0) == None
 
     for i in range(100):
-        lru.set(i, i)
+        lru.put(i, i)
     print(lru)

ehco/queue/dubble_ended_queue.py

@@ -0,0 +1,49 @@
+from ehco.link_list.lru import DBL
+
+
+class Dequeue:
+    def __init__(self):
+        self._double_link_list = DBL()
+
+    @property
+    def head(self):
+        return self._double_link_list.head
+
+    @property
+    def tail(self):
+        return self._double_link_list.tail
+
+    def append(self, val):
+        self._double_link_list.append(val)
+
+    def append_left(self, val):
+        self._double_link_list.append_left(val)
+
+    def pop(self):
+        node = self.tail
+        res = self._double_link_list.remove(node)
+        if res:
+            return node.value
+
+    def pop_left(self):
+        node = self.head
+        res = self._double_link_list.remove(node)
+        if res:
+            return node.value
+
+
+def test_double_ended_queue():
+    deq = Dequeue()
+
+    for i in range(10):
+        deq.append(i)
+
+    for i in range(10):
+        assert deq.pop_left() == i
+
+    for i in range(10):
+        deq.append_left(i)
+
+    for i in range(10):
+        assert deq.pop() == i
+