【Python】python实现双向链表

一、定义与结构

双向链表（Doubly Linked List）是一种链式数据结构，每个节点（Node）包含三个部分：一个数据域（data），一个指向前驱节点的指针（prev），以及一个指向后继节点的指针（next）。双向链表的每个节点都链接到前一个节点和后一个节点，从而允许在两个方向上进行遍历。
双向链表的结构

+------+-----+------+       +------+-----+------+       +------+-----+------+
| prev |     | next | ----> | prev |     | next | ----> | prev |     | next |
+------+-----+------+       +------+-----+------+       +------+-----+------+

prev：指向前一个节点的指针。如果是头节点（head），则 prev 为 nil 或 None。
data：存储的数据。
next：指向下一个节点的指针。如果是尾节点（tail），则 next 为 nil 或 None。

二、特点与场景

特点
双向遍历：可以从头到尾遍历，也可以从尾到头遍历。
插入和删除操作：在已知位置进行插入和删除操作的时间复杂度为 O(1)，因为不需要像数组那样进行大量元素的移动。
优点
相比单向链表，双向链表可以方便地进行反向遍历和操作。
插入和删除操作较为高效。
缺点
每个节点需要额外的空间来存储两个指针（prev 和 next）。
操作时需要维护两个指针，逻辑稍复杂。
使用场景
需要频繁插入和删除操作的场景。
需要在链表中从任意位置进行高效的前向和后向遍历的场景。

三、Python代码实现

定义节点结构

class Node:

    def __init__(self, data=None):
        self.data = data
        self.next = None
        self.prev = None

定义链表与方法

class DLinkedList:

    def __init__(self):
        self.head = None
    
    def append(self, data):
        if not self.head:
            self.head = Node(data)
        else:
            new_node = Node(data)
            current = self.head
            while current.next:
                current = current.next
            current.next = new_node
            new_node.prev = current

    def prepend(self, data):
        new_node = Node(data)
        if not self.head:
            self.head = new_node
        else:
            new_node.next = self.head
            self.head.prev = new_node
            self.head = new_node

    def move_to_front(self, key):
        ## 将元素移到头（为了实现lru算法而实现的方法）
        if not self.head:
            return
        current = self.head
        while current:
            if current.data == key:
                if current.prev is None:
                    return
                
                if current.prev:
                    current.prev.next = current.next

                if current.next:
                    current.next.prev = current.prev

                current.next = self.head
                current.prev = None
                self.head.prev = current
                self.head = current
                return
            current = current.next

    def back(self):
        # 删除最后一个元素
        if not self.head:
            return
        if self.head.next is None:
            self.head = None
            return
        current = self.head
        while current:
            current = current.next
        if current.prev:
            current.prev = None
        return current
        
    def display(self):
        data = []
        if self.head:
            current = self.head
            while current:
                data.append(current.data)
                current = current.next

        print(data)

测试

dl = DLinkedList()
dl.append(1)
dl.display()
dl.prepend(2)
dl.display()
dl.append(3)
dl.display()
dl.prepend(4)
dl.display()
dl.move_to_front(1)
dl.display()

结果

[1]
[2, 1]
[2, 1, 3]
[4, 2, 1, 3]
[1, 4, 2, 3]