LRU 的實現 雙向鍊錶和字典 python

最近最久未使用 ，這裡的最久是通過隱式體現的 ，是給乙個序列，使用一次，就放前面，沒使用就不動。這樣的話越久沒使用的就越在後面可以想象看

這裡的使用一次 指的是 訪問一次，更新一次。

注意控制大小，並且在插入元素 ，刪除元素的時候 快取體積也變一下

**如下 ： 可以直接執行 看著多， 其實不難， get, put 裡面是邏輯，node_list 裡有雙向鍊錶的方法。

# coding=utf8

# __author__ = 'kc'
# @file    : lru.py
# @software: pycharm
class
node
(object):
def__init__
(self, val, l, r, k)
:        self.parent = l
self._next = r
self.val = val
self.k = k
class
nodelist
(object):
"""雙向鍊錶"""
def__init__
(self)
:        self.tail =
none
self.head = node("",
none
,none,""
)def
del_item
(self, node)
:"""
從鍊錶中刪除對應的node
:param node: node 型別
:return:
"""parent = node.parent
_next = node._next
parent._next = _next
if _next:
_next.parent = parent
# 最後乙個元素
if node._next ==
none
:            self.tail = parent
# print self.tail.val
node._next =
none
node.parent =
none
return node
definsert_head
(self, node)
:"""
在頭部新增
:param item: 插入到頭部
:return:
"""# 更新tail
if self.head._next ==
none
:            self.tail = node
_tmp = self.head._next
if _tmp:
_tmp.parent = node
node._next = _tmp
node.parent = self.head
self.head._next = node
return node
defdel_tail
(self)
:        tail = self.del_item(self.tail)
return tail
def__str__
(self)
:        r =
_head = self.head._next
while _head:
str(_head.val)
)            _head = _head._next
return
", "
.join(r)
class
lrucache
(object):
def__init__
(self, capacity)
:"""
:type capacity: int
"""self.capacity = capacity
self.size =
0        self.data =
self.nl = nodelist(
)def
get(self, key)
:"""
:type key: int
:rtype: int
"""# print self.nl
node = self.data.get(key)
if node:
node = self.nl.del_item(node)
self.nl.insert_head(node)
return node.val
else
:return-1
defput
(self, key, value)
:"""
:type key: int
:type value: int
:rtype: none
"""# node = self.data.get(key)
# if node:
#     node = self.nl.del_item(node)
#     self.size -= 1
# if self.get(key) != -1:
#     self.nl.del_head()
node = self.data.get(key)
if node:
self.nl.del_item(node)
self.size -=
1            self.data.pop(key)
node = self.nl.insert_head(node(value,
none
,none
, key)
)        self.data[key]
= node
self.size +=
1if self.size > self.capacity:
tail = self.nl.del_tail(
)            self.data.pop(tail.k)
self.size -=
1# print self.nl
print
"下面是鍊錶的值， 每次操作都會列印"
print
"--"*20
lru = lrucache(2)
print
"這裡是快取的值:"
, lru.nl
lru.put(2,
2)print
"這裡是快取的值:"
, lru.nl
lru.put(1,
4)print
"這裡是快取的值:"
, lru.nl
lru.get(2)
print
"這裡是快取的值:"
, lru.nl
lru.put(3,
5)print
"這裡是快取的值:"
, lru.nl
lru.put(2,
3)print
"這裡是快取的值:"
, lru.nl
lru.put(1,
1)print
"這裡是快取的值:"
, lru.nl

golang使用雙向鍊錶實現LRU演算法

使用雙向鍊錶實現的lru演算法 type lrucache struct 鍊錶節點 type dbnode struct 雙向鍊錶 type dblist struct 往鍊錶頭部插入資料 if node nil d.mutex.rlock defer d.mutex.runlock if d.si...

LRU 雙向鍊錶 雜湊表 python

通過雙向鍊錶和雜湊表的結合實現lru class node def init self,key 0,value 0 self.key key self.value value self.next none self.pre none class solution def init self,max ...

雙向鍊錶和雙向迴圈鍊錶

和單向鍊錶相比，多了乙個前驅結點。如果他為空，那麼next和prior都指向自己。而對於雙迴圈鍊錶，只需要最後乙個元素的next指向head next，head next的prior指向最後乙個節點即可。新節點s插入鍊錶，s next給p結點，s prior給p prior，然後，p prior n...