使用python语言写个双向链表

### 回答1：
好的，下面是一个简单的双向链表示例：

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

class DoublyLinkedList:
    def __init__(self):
        self.head = None

    def append(self, data):
        new_node = Node(data)
        if self.head is None:
            self.head = new_node
            return
        curr_node = self.head
        while curr_node.next:
            curr_node = curr_node.next
        curr_node.next = new_node
        new_node.prev = curr_node

    def prepend(self, data):
        new_node = Node(data)
        if self.head is None:
            self.head = new_node
            return
        self.head.prev = new_node
        new_node.next = self.head
        self.head = new_node

    def print_list(self):
        curr_node = self.head
        while curr_node:
            print(curr_node.data)
            curr_node = curr_node.next

dl_list = DoublyLinkedList()
dl_list.append(1)
dl_list.append(2)
dl_list.prepend(0)
dl_list.print_list()

输出：

0
1
2

这是一个简单的双向链表，它具有在末尾添加元素、在开头添加元素和打印链表的功能。

### 回答2：
双向链表是一种常用的数据结构，在Python语言中可以使用类来实现。以下是一个使用Python语言编写的双向链表的示例：

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

class DoublyLinkedList:
    def __init__(self):
        self.head = None

    def append(self, data):
        new_node = Node(data)
        if self.head is None:
            self.head = new_node
        else:
            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 self.head is None:
            self.head = new_node
        else:
            new_node.next = self.head
            self.head.prev = new_node
            self.head = new_node

    def insert_after(self, prev_node, data):
        if prev_node is None:
            return
        new_node = Node(data)
        new_node.next = prev_node.next
        new_node.prev = prev_node
        if prev_node.next:
            prev_node.next.prev = new_node
        prev_node.next = new_node

    def delete(self, data):
        current = self.head
        while current:
            if current.data == data:
                if current.prev:
                    current.prev.next = current.next
                else:
                    self.head = current.next
                if current.next:
                    current.next.prev = current.prev
                return
            current = current.next

    def display(self):
        current = self.head
        while current:
            print(current.data, end=" ")
            current = current.next

# 示例用法
dll = DoublyLinkedList()
dll.append(1)
dll.append(2)
dll.append(3)
dll.prepend(0)
dll.insert_after(dll.head.next, 1.5)
dll.display()  # 输出：0 1 1.5 2 3
dll.delete(1)
dll.display()  # 输出：0 1.5 2 3

在上述代码中，我们定义了`Node`类来表示链表中的每个节点，其中包含了数据、指向前一个节点的`prev`和指向后一个节点的`next`指针。双向链表的头部由`DoublyLinkedList`类的`head`指针来标识。我们实现了`append`方法向链表尾部添加节点，`prepend`方法向链表头部添加节点，`insert_after`方法在指定节点之后插入新节点，`delete`方法删除指定值的节点，并实现了`display`方法来按顺序输出链表中的节点数据。

以上就是一个用Python语言编写的双向链表的示例代码，通过实例化`DoublyLinkedList`类并调用其方法，可以进行相应的链表操作。

### 回答3：
双向链表（Doubly Linked List）是一种数据结构，每个节点都包含指向前节点和后节点的指针。以下是使用Python语言实现双向链表的代码：

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

class DoublyLinkedList:
    def __init__(self):
        self.head = None

    # 在链表末尾添加节点
    def append(self, data):
        new_node = Node(data)
        # 若链表为空，则直接将新节点设置为头节点
        if self.head is None:
            self.head = new_node
        else:
            current_node = self.head
            # 遍历链表，找到最后一个节点
            while current_node.next:
                current_node = current_node.next
            # 将新节点添加到最后一个节点之后
            current_node.next = new_node
            new_node.prev = current_node

    # 在链表头部插入节点
    def prepend(self, data):
        new_node = Node(data)
        if self.head is None:
            self.head = new_node
        else:
            self.head.prev = new_node
            new_node.next = self.head
            self.head = new_node

    # 删除指定节点
    def delete(self, data):
        current_node = self.head
        while current_node:
            if current_node.data == data:
                # 如果待删除节点是头节点
                if current_node.prev is None:
                    self.head = current_node.next
                    if self.head:
                        self.head.prev = None
                else:
                    current_node.prev.next = current_node.next
                    if current_node.next:
                        current_node.next.prev = current_node.prev
                return  # 删除成功，结束循环
            current_node = current_node.next

    # 打印链表
    def print_list(self):
        current_node = self.head
        while current_node:
            print(current_node.data, end=' ')
            current_node = current_node.next
        print()

使用上述代码，我们可以创建一个双向链表对象并使用其提供的方法操作链表：

# 创建双向链表
linked_list = DoublyLinkedList()

# 向链表末尾添加节点
linked_list.append(1)
linked_list.append(2)
linked_list.append(3)

# 在链表头部插入节点
linked_list.prepend(0)

# 删除指定节点
linked_list.delete(2)

# 打印链表
linked_list.print_list()

输出结果：0 1 3