python如何创建动态链表

在Python中创建动态链表需要理解链表的基本结构和操作。链表是一种线性数据结构，其中元素是存储在节点中，每个节点包含数据以及指向下一个节点的引用。创建动态链表的核心步骤包括定义节点类、定义链表类、实现基本操作（如插入、删除、搜索等）。

让我们详细探讨这些步骤中的定义节点类。节点类是链表的基础，每个节点包含数据和指向下一个节点的指针。在Python中，可以使用类来定义节点。下面是一个简单的节点类的定义：

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

一、定义节点类

节点是链表的基本构建块。每个节点包含数据和指向下一个节点的指针。下面是如何定义节点类的详细描述：

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

这段代码定义了一个名为Node的类。__init__方法是初始化方法，它接受一个参数data，并将其赋值给节点的data属性，同时将next属性设置为None，表示这个节点默认没有指向下一个节点。

二、定义链表类

链表类负责管理所有节点以及链表的操作。下面是链表类的基本结构：

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

在__init__方法中，链表对象初始化时，head属性被设置为None，表示链表为空。

三、插入节点

链表最基本的操作之一是插入节点。可以在链表的头部插入，也可以在尾部插入。下面是这两种方法的实现：

插入到头部

def insert_at_head(self, data):
    new_node = Node(data)
    new_node.next = self.head
    self.head = new_node

在此方法中，我们首先创建一个新节点，将其next属性指向当前的头节点，然后将链表的头节点更新为新节点。

插入到尾部

def insert_at_tail(self, data):
    new_node = Node(data)
    if not self.head:
        self.head = new_node
        return
    current = self.head
    while current.next:
        current = current.next
    current.next = new_node

在此方法中，我们首先创建一个新节点。如果链表为空，我们直接将头节点设置为新节点。否则，我们遍历链表直到找到最后一个节点，然后将最后一个节点的next属性设置为新节点。

四、删除节点

删除节点也是链表的基本操作之一。可以删除头节点，也可以删除特定值的节点。

删除头节点

def delete_at_head(self):
    if self.head:
        self.head = self.head.next

在此方法中，如果链表不为空，我们将头节点更新为当前头节点的下一个节点。

删除特定值的节点

def delete_node(self, key):
    current = self.head
    previous = None
    while current and current.data != key:
        previous = current
        current = current.next
    if current:
        if previous:
            previous.next = current.next
        else:
            self.head = current.next

在此方法中，我们遍历链表寻找具有特定值的节点。如果找到了，我们根据其位置更新前一个节点的next属性或者头节点。

五、查找节点

查找节点是确定链表中是否包含特定值的操作。

def search(self, key):
    current = self.head
    while current:
        if current.data == key:
            return True
        current = current.next
    return False

在此方法中，我们遍历链表，检查每个节点的数据属性是否等于特定值。如果找到了，返回True，否则继续查找，直到遍历完整个链表。

六、打印链表

为了调试和展示链表的内容，我们需要一个方法来打印链表。

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

在此方法中，我们遍历链表并打印每个节点的数据，直到到达链表的末尾。

七、链表的应用

链表在各种应用场景中都有使用。以下是一些常见的应用：

实现栈

栈是一种后进先出（LIFO）的数据结构，可以使用链表实现。

class Stack:
    def __init__(self):
        self.stack = LinkedList()
    def push(self, data):
        self.stack.insert_at_head(data)
    def pop(self):
        if self.stack.head:
            value = self.stack.head.data
            self.stack.delete_at_head()
            return value
        else:
            return None
    def is_empty(self):
        return self.stack.head is None

实现队列

队列是一种先进先出（FIFO）的数据结构，也可以使用链表实现。

class Queue:
    def __init__(self):
        self.queue = LinkedList()
    def enqueue(self, data):
        self.queue.insert_at_tail(data)
    def dequeue(self):
        if self.queue.head:
            value = self.queue.head.data
            self.queue.delete_at_head()
            return value
        else:
            return None
    def is_empty(self):
        return self.queue.head is None

八、双向链表

双向链表是链表的一种，每个节点包含两个指针，一个指向下一个节点，一个指向前一个节点。以下是双向链表的基本实现：

class DNode:
    def __init__(self, data=None):
        self.data = data
        self.next = None
        self.prev = None
class DoublyLinkedList:
    def __init__(self):
        self.head = None
    def insert_at_head(self, data):
        new_node = DNode(data)
        if self.head:
            new_node.next = self.head
            self.head.prev = new_node
        self.head = new_node
    def insert_at_tail(self, data):
        new_node = DNode(data)
        if not self.head:
            self.head = new_node
            return
        current = self.head
        while current.next:
            current = current.next
        current.next = new_node
        new_node.prev = current
    def delete_node(self, key):
        current = self.head
        while current and current.data != key:
            current = current.next
        if current:
            if current.prev:
                current.prev.next = current.next
            if current.next:
                current.next.prev = current.prev
            if current == self.head:
                self.head = current.next
    def display(self):
        current = self.head
        while current:
            print(current.data, end=" <-> ")
            current = current.next
        print("None")

九、循环链表

循环链表是链表的一种变体，最后一个节点指向第一个节点。以下是循环链表的基本实现：

class CircularLinkedList:
    def __init__(self):
        self.head = None
    def insert_at_head(self, data):
        new_node = Node(data)
        if not self.head:
            self.head = new_node
            new_node.next = self.head
        else:
            new_node.next = self.head
            current = self.head
            while current.next != self.head:
                current = current.next
            current.next = new_node
            self.head = new_node
    def insert_at_tail(self, data):
        new_node = Node(data)
        if not self.head:
            self.head = new_node
            new_node.next = self.head
        else:
            current = self.head
            while current.next != self.head:
                current = current.next
            current.next = new_node
            new_node.next = self.head
    def display(self):
        if not self.head:
            print("List is empty")
            return
        current = self.head
        while True:
            print(current.data, end=" -> ")
            current = current.next
            if current == self.head:
                break
        print("(head)")
    def delete_node(self, key):
        if not self.head:
            return
        current = self.head
        previous = None
        while True:
            if current.data == key:
                if previous:
                    previous.next = current.next
                else:
                    while current.next != self.head:
                        current = current.next
                    current.next = self.head.next
                    self.head = self.head.next
                return
            previous = current
            current = current.next
            if current == self.head:
                break

十、链表的高级操作

链表的高级操作包括反转链表、合并两个有序链表、检测链表中的环等。

反转链表

def reverse(self):
    previous = None
    current = self.head
    while current:
        next_node = current.next
        current.next = previous
        previous = current
        current = next_node
    self.head = previous

合并两个有序链表

def merge_sorted_lists(l1, l2):
    dummy = Node()
    tail = dummy
    while l1 and l2:
        if l1.data < l2.data:
            tail.next = l1
            l1 = l1.next
        else:
            tail.next = l2
            l2 = l2.next
        tail = tail.next
    if l1:
        tail.next = l1
    if l2:
        tail.next = l2
    return dummy.next

检测链表中的环

def has_cycle(self):
    slow = self.head
    fast = self.head
    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next
        if slow == fast:
            return True
    return False