用雙向鍊錶實現記憶體置換演算法 四

這一篇是使用雙向鍊錶實現第三個記憶體置換演算法----lfu

lfu演算法分析：

最不經常使用演算法，在快取滿了的時候，先淘汰使用頻率最少的，這裡我們就需要用乙個變數來記錄資料的使用頻率。但是會有乙個情況，就是使用頻率相同的時候如何去處理，這裡我是採用map來記錄，key為使用的頻率，value是雙向鍊錶，當快取滿了的時候，找到最低頻率的value，根據fifo的規則去淘汰。

class

lfunode
(node)
:def
__init__
(self, key, value)
:        self.freq =
0super
(lfunode, self)
.__init__(key, value)

這裡直接附上**，在結尾會對一些細節進行解釋：

class

lfucache
:def
__init__
(self, capacity)
:        self.capacity = capacity
self.
map=
# key: 頻率, value: 頻率對應的雙向鍊錶
self.freq_map =
self.size =
0# 更新節點頻率的操作
def__update_freq
(self, node)
:        freq = node.freq
# 刪除
node = self.freq_map[freq]
.remove(node)
if self.freq_map[freq]
.size ==0:
del self.freq_map[freq]
# 更新
freq +=
1        node.freq = freq
if freq not
in self.freq_map:
self.freq_map[freq]
= doublelinkedlist(
)        self.freq_map[freq]
defget
(self, key)
:if key not
in self.
map:
return-1
node = self.
map.get(key)
self.__update_freq(node)
return node.value
defput(self, key, value)
:if self.capacity ==0:
return
# 快取命中
if key in self.
map:
node = self.
map.get(key)
node.value = value
self.__update_freq(node)
# 快取未命中
else
:if self.capacity == self.size:
# 最低頻率
min_freq =
min(self.freq_map)
node = self.freq_map[min_freq]
.pop(
)del self.
map[node.key]
self.size -=
1            node = lfunode(key, value)
node.freq =
1            self.
map[key]
= node
if node.freq not
in self.freq_map:
self.freq_map[node.freq]
= doublelinkedlist(
)            self.freq_map[node.freq]
self.size +=
1

用雙向鍊錶實現記憶體置換演算法（二）

fifo first in first out 這裡使用之前實現了的雙向鍊錶來實現fifo演算法。fifo演算法還是比較好理解的，如果記憶體滿了，則最先淘汰先進入的。直接上 from doublelinkedlist import doublelinkedlist,node class fifoca...

用雙向鍊錶實現記憶體置換演算法 三

這一篇是用雙向鍊錶實現lru演算法 演算法思路 假如我們的快取可以快取4個子塊 快取中不存在要放入的字塊時，把子塊放在鍊錶的頭部 如果快取中存在相同子塊，則把這一字塊移到鍊錶的頭部。快取滿了，放入新的字塊時，把尾部的字塊移除。下面附上 class lrucache def init self,cap...

用java實現雙向鍊錶

判斷指定索引是否合法 param index return public boolean islinkindex int index 根據指定索引取得具體節點 param index return public node node int index return temp else return ...