Python实现对双向链表类的封装(添加节点、删除节点、弹出头部节点、往头部插入节点)
Python实现对双向链表类的封装(添加节点、删除节点、弹出头部节点、往头部插入节点)
# 节点类的封装
class Node(object):
def __init__(self,key,val):
self.key = key
self.val=val
self.pre=None
self.next=None
def __str__(self):
value = '{%d: %d}'%(self.key,self.val)
return value
def __repr__(self):
value = '{%d: %d}' % (self.key, self.val)
return value
# 双向链表类的封装
class DoubleLinkList(object):
def __init__(self, capacity = 0xffff):
self.capacity = capacity
self.head = None
self.tail = None #尾部节点
self.size = 0
# 从头部添加节点 （私有）
def __add_head(self, node):
if not self.head: #如果当前节点为空
self.head = node #链表头部节点为node
self.tail = node #链表的尾部节点为node
self.head.next = None #链表头节点的下一个节点为空
self.head.pre = None #链表头节点的前一个节点为空
else:
node.next = self.head #插入节点的下一个节点为head
self.head.pre = node #head的上一个节点为node
self.head = node #当前链表的头节点更改为node
self.head.pre = None #当前链表的头节点的上一个节点为空
self.size += 1
return node
# 从尾部添加节点 （私有）
def __add_tail(self, node):
if not self.tail: #如果当前节点为空
self.tail = node #链表尾部节点为node
self.head = node #链表的头部节点为node
self.tail.next = None #链表尾节点的下一个节点为空
self.tail.pre = None #链表尾节点的前一个节点为空
else:
self.tail.next = node # tail的下一个节点为node
node.pre = self.tail #插入节点的上一个节点为tail
self.tail= node #当前链表的尾节点更改为node
self.tail.next = None #当前链表的位节点的下一个节点为空
self.size += 1
return node
# 从尾部删除节点 （私有）
def __del_tail(self):
if not self.tail:
return
node = self.tail
if node.pre:
self.tail = node.pre
self.tail.next = None
else:
self.tail = self.head = None
self.size -= 1
return node
# 删除头部节点 （私有）
def __del_head(self):
if not self.head:
return
node = self.head
if node.next:
self.head = node.next
self.head.pre = None
else:
self.tail = self.head = None
self.size -= 1
return node
# 删除任意节点 （私有）
def __remove(self, node):
# 如果node为None，默认删除尾结点
if not node:
node=self.tail
if node == self.tail:
self.__del_tail()
elif node == self.head:
self.__del_head()
else:
node.pre.next = node.next
node.next.pre=node.pre
self.size -=1
return node
# 弹出头部节点 (公有)
def pop(self):
return self.__del_head()
# 添加节点 (公有)
def append(self, node):
return self.__add_tail(node)
# 往头部添加节点 (公有)
def append_front(self,node):
return self.__add_head(node)
# 删除节点 (公有)
def remove(self, node=None):
return self.__remove(node)
def print(self):
p = self.head
line = ''
while p:
line +='%s' %p
p=p.next
if p:
line += '=>'
print(line)
if __name__ == '__main__':
l = DoubleLinkList(10)
nodes = []
for i in range(10):
node = Node(i, i) #创建10个节点
nodes.append(node)
#添加一个0节点
l.append(nodes[0])
l.print()
#往尾部添加节点1
l.append(nodes[1])
#弹出首节点
l.pop()
l.print()
#添加节点2
l.append(nodes[2])
l.print()
#往头部添加节点3
l.append_front(nodes[3])
l.print()
#添加节点4
l.append(nodes[4])
l.print()
#移除节点2
l.remove(nodes[2])
l.print()
#运行结果
{0: 0}
{1: 1}
{1: 1}=>{2: 2}
{3: 3}=>{1: 1}=>{2: 2}
{3: 3}=>{1: 1}=>{2: 2}=>{4: 4}
{3: 3}=>{1: 1}=>{4: 4}接下来通过双链表实现计算机高速缓存置换算法FIFO算法
#导入双链表类
from PythonBasic.Lesson09.DoubleLinkList import DoubleLinkList ,Node
class FIFOCache(object):
def __init__(self,capacity):
self.capacity=capacity #确定缓存区的大小
self.size = 0
self.map = {} #记录当前缓存中的key
self.list = DoubleLinkList(self.capacity)
# 获取缓存中关键码为key的值
def get(self, key):
if key not in self.map:
return -1
else:
node = self.map.get(key)
return node.val
# 往缓存中添加内容
def put(self,key,val):
if self.capacity==0:
return
if key in self.map: #如果当前的key已经存在缓存中
node=self.map.get(key)
self.list.remove(node) #移除当前的节点
node.val = val #将新的值赋给节点
self.list.append(node)
else:
if self.size ==self.capacity: #如果当前缓存已经满了
node= self.list.pop()
del self.map[node.key]
self.size -= 1
node = Node(key,val)
self.list.append(node)
self.map[key]=node
self.size +=1
# 打印当前缓存中的节点
def print(self):
self.list.print()if __name__=='__main__':
cache=FIFOCache(2)
# 向缓存区1中添加1
cache.put(1,1)
cache.print()
#向缓存区2中添加2
cache.put(2,2)
cache.print()
#获取缓存区1的值
print(cache.get(1))
# 向缓存区3中添加3
cache.put(3,3)
cache.print()
print(cache.get(2))
cache.print()
cache.put(4,4)
cache.print()
print(cache.get(1))#运行结果
{1: 1}
{1: 1}=>{2: 2}
1
{2: 2}=>{3: 3}
2
{2: 2}=>{3: 3}
{3: 3}=>{4: 4}
-1