python实现双向链表并完成相关操作

python实现双向链表并完成相关操作

实现节点类，双向链表类，并实现增删操作

"""
    @File  : node1.py
    @Author: Gareth
    @Date  : 2020/5/10 15:51
    @Desc  : 
"""


import random


# 定义一个Node类
class Node:
    def __init__(self, key, value):
        self.pre = None
        self.next = None
        self.value = value
        self.key = key

    def __str__(self):
        return "{%s: %s}" % (self.key, self.value)

    def __repr__(self):
        return "{%s: %s}" % (self.key, self.value)


# 再来一个双向链表
class DoubleLinkedList:
    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
            self.tail = node
            self.head.pre = None
            self.head.next = None
        else:
            node.next = self.head
            self.head.pre = node
            self.head = node
            self.head.pre = None
        self.size += 1
        return node

    # 从尾部添加
    def __add_tail(self, node):
        if not self.tail:
            self.tail = node
            self.head = node
            self.tail.pre = None
            self.tail.next = None
        else:
            node.pre = self.tail
            self.tail.next = node
            self.tail = node
            self.tail.next = None
        self.size += 1
        return node

    # 节点删除
    def __remove(self, node):
        # 如果没有node，默认删除尾部节点
        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 __del_tail(self):
        if not self.tail:
            return
        node = self.tail
        if node.pre:
            node.pre.next = None
            self.tail = node.pre
        else:
            self.tail = None
            self.head = None
        self.size -= 1
        return node

    def __del_head(self):
        if not self.head:
            return
        node = self.head
        if node.next:
            node.next.pre = None
            self.head = node.next
        else:
            self.head = None
            self.tail = None
        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 += "{}".format(p)
            p = p.next
            if p:
                line += "<=>"
        print(line)


if __name__ == '__main__':
    l = DoubleLinkedList(10)
    nodes = []
    # 添加节点
    for i in range(10):
        node = Node(i, random.randint(0, 10))
        nodes.append(node)
    print(nodes)

	# 测验一下
    l.append(nodes[0])
    l.print()
    l.append(nodes[1])
    l.print()
    l.pop()
    l.print()
    l.append(nodes[2])
    l.print()
    l.append_front(nodes[3])
    l.print()
    l.append(nodes[4])
    l.print()
    l.remove(nodes[2])
    l.print()
    l.remove()
    l.print()

这是实现结果

[{0: 4}, {1: 8}, {2: 2}, {3: 9}, {4: 9}, {5: 9}, {6: 4}, {7: 2}, {8: 7}, {9: 4}]
{0: 4}
{0: 4}<=>{1: 8}
{1: 8}
{1: 8}<=>{2: 2}
{3: 9}<=>{1: 8}<=>{2: 2}
{3: 9}<=>{1: 8}<=>{2: 2}<=>{4: 9}
{3: 9}<=>{1: 8}<=>{4: 9}
{3: 9}<=>{1: 8}