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