python中如何建立一个链表

在Python中，建立一个链表有多种方法，其中最常见的是通过创建一个类来表示链表节点。链表由节点组成，每个节点包含数据和指向下一个节点的引用、链表可以是单链表或双链表、链表适用于动态数据结构和内存管理。链表在动态数据结构和内存管理方面具有优势，特别适合频繁插入和删除操作。

一、单链表的实现

1、定义节点类

首先，我们需要定义一个节点类。节点类包含两个属性：数据和指向下一个节点的引用。

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

这个类非常简单，__init__方法初始化节点的数据和下一个节点的引用。

2、定义链表类

接下来，我们定义链表类。链表类包含一个头节点和一些基本操作方法，比如插入、删除和遍历。

class LinkedList:
    def __init__(self):
        self.head = None
    def append(self, data):
        new_node = Node(data)
        if not self.head:
            self.head = new_node
            return
        last = self.head
        while last.next:
            last = last.next
        last.next = new_node
    def delete_node(self, key):
        temp = self.head
        if temp and temp.data == key:
            self.head = temp.next
            temp = None
            return
        prev = None
        while temp and temp.data != key:
            prev = temp
            temp = temp.next
        if temp is None:
            return
        prev.next = temp.next
        temp = None
    def print_list(self):
        temp = self.head
        while temp:
            print(temp.data, end=" ")
            temp = temp.next
        print()

在这个链表类中，__init__方法初始化头节点，append方法在链表末尾添加新节点，delete_node方法删除指定数据的节点，print_list方法遍历并打印链表中的所有节点。

二、双链表的实现

双链表的节点包含三个属性：数据、指向下一个节点的引用和指向前一个节点的引用。

1、定义双链表节点类

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

2、定义双链表类

class DoublyLinkedList:
    def __init__(self):
        self.head = None
    def append(self, data):
        new_node = DNode(data)
        if not self.head:
            self.head = new_node
            return
        last = self.head
        while last.next:
            last = last.next
        last.next = new_node
        new_node.prev = last
    def delete_node(self, key):
        temp = self.head
        while temp and temp.data != key:
            temp = temp.next
        if temp is None:
            return
        if temp.prev:
            temp.prev.next = temp.next
        if temp.next:
            temp.next.prev = temp.prev
        if temp == self.head:
            self.head = temp.next
        temp = None
    def print_list(self):
        temp = self.head
        while temp:
            print(temp.data, end=" ")
            temp = temp.next
        print()

在这个双链表类中，__init__方法初始化头节点，append方法在链表末尾添加新节点，delete_node方法删除指定数据的节点，print_list方法遍历并打印链表中的所有节点。

三、链表的常见操作

1、插入操作

链表的插入操作可以在头部、中间或尾部插入。以下是三种插入操作的示例：

def insert_at_head(self, data):
    new_node = Node(data)
    new_node.next = self.head
    self.head = new_node
def insert_after(self, prev_node, data):
    if not prev_node:
        print("Previous node must be in the LinkedList.")
        return
    new_node = Node(data)
    new_node.next = prev_node.next
    prev_node.next = new_node
def insert_at_tail(self, data):
    new_node = Node(data)
    if not self.head:
        self.head = new_node
        return
    last = self.head
    while last.next:
        last = last.next
    last.next = new_node

2、删除操作

链表的删除操作可以删除头部、中间或尾部节点。以下是三种删除操作的示例：

def delete_head(self):
    if self.head:
        temp = self.head
        self.head = self.head.next
        temp = None
def delete_node(self, key):
    temp = self.head
    if temp and temp.data == key:
        self.head = temp.next
        temp = None
        return
    prev = None
    while temp and temp.data != key:
        prev = temp
        temp = temp.next
    if temp is None:
        return
    prev.next = temp.next
    temp = None
def delete_tail(self):
    if not self.head:
        return
    if not self.head.next:
        self.head = None
        return
    second_last = self.head
    while second_last.next.next:
        second_last = second_last.next
    second_last.next = None

3、查找操作

链表的查找操作可以查找特定数据的节点。以下是查找操作的示例：

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

四、链表的优缺点

1、优点

动态大小：链表的大小可以动态调整，不受预分配内存的限制。
便于插入和删除：插入和删除操作非常简单，不需要移动元素，只需改变指针。

2、缺点

占用空间大：链表需要额外的存储空间来保存指针。
访问时间长：链表的访问时间较长，因为需要从头开始遍历。

五、链表的应用

链表在以下场景中有广泛应用：

实现栈和队列：链表可以用来实现栈和队列数据结构。
实现图的邻接表：链表可以用来表示图的邻接表。
内存管理：链表可以用来管理动态内存分配。

六、链表的扩展

1、循环链表

循环链表是一种特殊的单链表或双链表，其中最后一个节点指向第一个节点。以下是循环链表的实现：

class CircularLinkedList:
    def __init__(self):
        self.head = None
    def append(self, data):
        new_node = Node(data)
        if not self.head:
            self.head = new_node
            new_node.next = self.head
            return
        temp = self.head
        while temp.next != self.head:
            temp = temp.next
        temp.next = new_node
        new_node.next = self.head
    def print_list(self):
        temp = self.head
        if not self.head:
            return
        while True:
            print(temp.data, end=" ")
            temp = temp.next
            if temp == self.head:
                break
        print()

2、双向循环链表

双向循环链表是双链表的扩展，其中最后一个节点指向第一个节点，第一个节点的前一个节点指向最后一个节点。以下是双向循环链表的实现：

class CircularDoublyLinkedList:
    def __init__(self):
        self.head = None
    def append(self, data):
        new_node = DNode(data)
        if not self.head:
            self.head = new_node
            new_node.next = self.head
            new_node.prev = self.head
            return
        temp = self.head
        while temp.next != self.head:
            temp = temp.next
        temp.next = new_node
        new_node.prev = temp
        new_node.next = self.head
        self.head.prev = new_node
    def print_list(self):
        temp = self.head
        if not self.head:
            return
        while True:
            print(temp.data, end=" ")
            temp = temp.next
            if temp == self.head:
                break
        print()

七、总结

链表是一种重要的数据结构，广泛应用于各种编程场景中。通过了解链表的基本概念、实现方法和常见操作，可以帮助我们更好地使用链表解决实际问题。链表的扩展形式，如循环链表和双向循环链表，也为我们提供了更多的选择和灵活性。在实际应用中，选择合适的数据结构和算法非常重要，链表作为一种基础数据结构，值得我们深入学习和掌握。