2.数据结构 - 链表-CSDN博客

本文链接：https://blog.csdn.net/mj256115/article/details/139333781

数据结构 - 链表（Linked List）

链表是一种线性的数据结构，其中元素以节点的形式存在。每个节点包含两部分：数据部分和指向下一个节点的指针（或引用）。链表与数组不同，它不要求存储空间连续，因此提供了更高的灵活性。

链表的主要类型：

单向链表（Singly Linked List）：每个节点包含一个指向下一个节点的指针。
双向链表（Doubly Linked List）：每个节点包含两个指针，一个指向前一个节点，一个指向下一个节点。
循环链表（Circular Linked List）：最后一个节点的指针指向链表的第一个节点（单向循环链表）或最后一个节点（双向循环链表）。

链表的特点：

动态大小：链表的大小可以在运行时动态改变。
插入和删除操作：可以在O(1)时间复杂度内完成，只要提供了适当的指针。
随机访问：不支持，因为元素不是连续存储的，访问特定元素需要从头开始遍历链表。

优点：

可以快速地在任意位置插入和删除节点。
内存分配可以更加灵活。

缺点：

需要额外的内存空间来存储指针。
访问特定元素的时间复杂度为O(n)。
不能像数组那样随机访问。

单向链表（Singly Linked List）

特点:

每个节点包含数据和指向下一个节点的指针。
插入和删除操作通常需要从头开始遍历。
不支持随机访问，访问特定元素需要从头节点开始遍历。

操作代码示例（Python）:

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

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

    def append(self, data):
        """在链表末尾添加新节点"""
        new_node = Node(data)
        if not self.head:
            self.head = new_node
            return
        last_node = self.head
        while last_node.next:
            last_node = last_node.next
        last_node.next = new_node

    def insert_after_node(self, prev_node, data):
        """在指定节点之后插入新节点"""
        if not prev_node:
            print("Previous node is not in the list")
            return
        new_node = Node(data)
        new_node.next = prev_node.next
        prev_node.next = new_node

    def delete_node(self, key):
        """删除具有特定值的节点"""
        curr = self.head
        if curr and curr.data == key:
            self.head = curr.next
            return
        prev = curr
        while prev.next and prev.next.data != key:
            prev = prev.next
        if prev.next is None:
            return
        prev.next = prev.next.next

    def print_list(self):
        """打印链表"""
        curr = self.head
        while curr:
            print(curr.data, end=" -> ")
            curr = curr.next
        print("None")

# 示例
sll = SinglyLinkedList()
sll.append(1)
sll.append(2)
sll.append(3)
sll.print_list()  # 输出: 1 -> 2 -> 3 -> None
sll.delete_node(2)
sll.print_list()  # 输出: 1 -> 3 -> None

双向链表（Doubly Linked List）

特点:

每个节点包含数据和两个指针，分别指向前一个节点和下一个节点。
可以轻松地从任一节点向前或向后遍历。
插入和删除操作更加灵活。

操作代码示例（Python）:

class NodeDoubly:
    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 = NodeDoubly(data)
        if not self.head:
            self.head = new_node
            return
        last_node = self.head
        while last_node.next:
            last_node = last_node.next
        last_node.next = new_node
        new_node.prev = last_node

    def print_list(self):
        """打印链表"""
        curr = self.head
        while curr:
            print(curr.data, end=" <-> ")
            curr = curr.next
        print("None")

    def insert_after_node(self, prev_node, data):
        """在指定节点之后插入新节点"""
        if not prev_node:
            print("Previous node is not in the list")
            return
        new_node = NodeDoubly(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_node(self, node):
        """删除指定节点"""
        if node.next:
            node.next.prev = node.prev
        if node.prev:
            node.prev.next = node.next
        if node == self.head:
            self.head = node.next

# 示例
dll = DoublyLinkedList()
dll.append(1)
dll.append(2)
dll.append(3)
dll.print_list()  # 输出: 1 <-> 2 <-> 3 <-> None
dll.insert_after_node(dll.head.next, 1.5)
dll.print_list()  # 输出: 1 <-> 2 <-> 1.5 <-> 3 <-> None
dll.delete_node(dll.head.next)
dll.print_list()  # 输出: 1 <-> 1.5 <-> 3 <-> None

循环链表（Circular Linked List）

特点:

单向循环链表的最后一个节点指向第一个节点。
双向循环链表的每个节点的prev指向前一个节点，next指向下一个节点。
可以从头尾任意位置开始遍历整个链表。

操作代码示例（Python）:

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

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

    def append(self, data):
        """在循环链表末尾添加新节点"""
        new_node = NodeCircular(data)
        if not self.head:
            self.head = new_node
            new_node.next = self.head
            return
        last_node = self.head
        while last_node.next != self.head:
            last_node = last_node.next
        last_node.next = new_node
        new_node.next = self.head

    def print_list(self):
        """打印循环链表"""
        curr = self.head
        if curr is None:
            print("List is empty")
            return
        while True:
            print(curr.data, end=" -> ")
            curr = curr.next
            if curr == self.head:
                break
        print("(head)")

# 示例
cll = CircularLinkedList()
cll.append(1)
cll.append(2)
cll.append(3)
cll.print_list()  # 输出: 1 -> 2 -> 3 -> (head)

以上代码示例展示了三种链表的基本操作，包括插入、删除和访问。每种链表类型都有其特定的用例和优势，选择使用哪种链表取决于具体的应用场景和需求。

链表的高级应用

链表除了基本的增删查操作外，还有许多高级应用，这些应用在解决特定问题时非常有用。

1. 链表反转

链表反转是面试中常见的问题，它要求将链表中的节点反向连接。

单向链表反转示例：

class SinglyLinkedList:
    # ...（之前的代码）

    def reverse(self):
        prev = None
        curr = self.head
        while curr:
            next_temp = curr.next
            curr.next = prev  # Reverse the link
            prev = curr
            curr = next_temp
        self.head = prev

# 示例
sll = SinglyLinkedList()
sll.append(1)
sll.append(2)
sll.append(3)
sll.print_list()  # 输出: 1 -> 2 -> 3 -> None
sll.reverse()
sll.print_list()  # 输出: 3 -> 2 -> 1 -> None

2. 合并两个有序链表

将两个有序的链表合并为一个新的有序链表。

合并两个有序链表示例：

class SinglyLinkedList:
    # ...（之前的代码）

    def merge(self, other_list):
        dummy = Node(0)  # 创建哑节点作为合并后链表的头
        tail = dummy
        curr1, curr2 = self.head, other_list.head

        while curr1 and curr2:
            if curr1.data < curr2.data:
                tail.next = curr1
                curr1 = curr1.next
            else:
                tail.next = curr2
                curr2 = curr2.next
            tail = tail.next

        # 连接剩余的节点
        tail.next = curr1 if not curr2 else curr2

        return dummy.next

# 示例
sll1 = SinglyLinkedList()
sll1.append(1)
sll1.append(3)
sll1.append(5)

sll2 = SinglyLinkedList()
sll2.append(2)
sll2.append(4)
sll2.append(6)

merged_list = sll1.merge(sll2)
merged_list.print_list()  # 输出: 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> None

3. 检测链表中的环

使用快慢指针（Floyd’s Cycle-Finding Algorithm）检测链表中是否存在环。

检测链表中的环示例：

class SinglyLinkedList:
    # ...（之前的代码）

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

# 示例
sll = SinglyLinkedList()
# 创建一个有环的链表
node1 = sll.append(1)
node2 = sll.append(2)
node3 = sll.append(3)
node4 = sll.append(4)
node3.next = node2  # 创建环

print(sll.has_cycle())  # 输出: True

4. 删除链表中的重复元素

在一个有序链表中删除所有重复的元素。

删除重复元素示例：

class SinglyLinkedList:
    # ...（之前的代码）

    def delete_duplicates(self):
        if not self.head:
            return
        curr = self.head
        while curr.next:
            if curr.data == curr.next.data:
                curr.next = curr.next.next
            else:
                curr = curr.next

# 示例
sll = SinglyLinkedList()
sll.append(1)
sll.append(1)
sll.append(2)
sll.append(3)
sll.append(3)

sll.delete_duplicates()
sll.print_list()  # 输出: 1 -> 2 -> None

5. 链表的中间节点

找到链表的中间节点。

找到中间节点示例：

class SinglyLinkedList:
    # ...（之前的代码）

    def find_middle(self):
        slow, fast = self.head, self.head
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
        return slow

# 示例
sll = SinglyLinkedList()
for i in range(1, 6):
    sll.append(i)

middle_node = sll.find_middle()
print(middle_node.data)  # 输出: 3

总结

链表是一种基础且强大的数据结构，它提供了不同于数组的灵活性和优势。链表的高级应用包括但不限于反转链表、合并有序链表、检测环、删除重复元素和找到中间节点等。掌握链表的高级操作对于解决复杂的算法问题和开发高效的数据结构至关重要。

链表的高级用法通常涉及到一些复杂的数据结构和算法，这些用法可以解决特定的问题，提高性能，或者简化实现。以下是一些链表的高级用法示例：

1. 链表作为LRU缓存

LRU（Least Recently Used）缓存是一种常用于操作系统和网络应用的缓存淘汰策略。可以使用双向链表来实现高效的LRU缓存。

高级用法示例：

class LRUCache:
    def __init__(self, capacity):
        self.capacity = capacity
        self.hash_map = {}
        self.head, self.tail = Node(0), Node(0)
        self.head.next, self.tail.prev = self.tail, self.head

    def get(self, key):
        if key not in self.hash_map:
            return -1
        node = self.hash_map[key]
        self._remove(node)
        self._add(node)
        return node.val

    def put(self, key, value):
        if key in self.hash_map:
            self._remove(self.hash_map[key])
        elif len(self.hash_map) == self.capacity:
            # Remove the least recently used item
            lru = self.tail.prev
            self._remove(lru)
            del self.hash_map[lru.val]
        node = Node(value)
        self._add(node)
        self.hash_map[key] = node

    def _remove(self, node):
        p, n = node.prev, node.next
        p.next, n.prev = n, p

    def _add(self, node):
        p, n = self.head, self.head.next
        p.next, n.prev, node.prev, node.next = node, node, p, n

# Helper class for Node
class Node:
    def __init__(self, val):
        self.val = val
        self.prev = None
        self.next = None

2. 链表实现的栈和队列

链表因为其动态的特性，非常适合用来实现栈（后进先出）和队列（先进先出）。

栈的实现示例：

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

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

    def pop(self):
        if self.head is None:
            raise IndexError("pop from an empty stack")
        removed = self.head
        self.head = self.head.next
        return removed.data

    def peek(self):
        if self.head is None:
            return None
        return self.head.data

队列的实现示例：

class Queue:
    def __init__(self):
        self.head = None
        self.tail = None

    def enqueue(self, data):
        new_node = Node(data)
        if self.tail:
            self.tail.next = new_node
        self.tail = new_node
        if not self.head:
            self.head = new_node

    def dequeue(self):
        if self.head is None:
            raise IndexError("dequeue from an empty queue")
        removed = self.head
        self.head = self.head.next
        if not self.head:
            self.tail = None
        return removed.data

3. 用链表实现的哈希表

哈希表是一种通过哈希函数将键映射到表中一个位置的数据结构，链表可以用来解决哈希冲突。

哈希表的简单实现：

class HashTable:
    def __init__(self, size):
        self.size = size
        self.table = [LinkedList() for _ in range(size)]

    def hash(self, key):
        return hash(key) % self.size

    def set(self, key, value):
        index = self.hash(key)
        for node in self.table[index].node_list:
            if node.key == key:
                node.value = value
                return
        self.table[index].append({key: value})

    def get(self, key):
        index = self.hash(key)
        for node in self.table[index].node_list:
            if node.key == key:
                return node.value
        return None

4. 链表在图算法中的应用

链表可以用来表示图的邻接表，特别是在处理稀疏图时，链表可以节省空间。

图的邻接表表示：

class Graph:
    def __init__(self, vertices):
        self.vertices = vertices
        self.adj_list = [LinkedList() for _ in range(vertices)]

    def add_edge(self, src, dest):
        self.adj_list[src].append(dest)

    def print_graph(self):
        for i in range(self.vertices):
            print(f"Vertex {i} has neighbours: ", end="")
            for neighbour in self.adj_list[i]:
                print(neighbour, end=" ")
            print()

5. 递归遍历链表

递归可以用于遍历链表，包括查找特定元素、反转链表等。

递归反转链表：

class SinglyLinkedList:
    # ...（之前的代码）

    def reverse_recursive(self, curr, prev=None):
        if curr is None:
            return prev
        next_node = curr.next
        curr.next = prev
        return self.reverse_recursive(next_node, curr)

    def reverse_list(self):
        if self.head is None:
            return
        self.head = self.reverse_recursive(self.head)

这些高级用法展示了链表在不同场景下的应用，从缓存实现到图算法，链表提供了一种灵活且强大的方式来处理数据。
继续介绍链表的高级用法：

6. 链表的随机访问变体：跳表（Skip List）

跳表是一种包含多个层级的链表，每一层都是一个更粗略的原链表的表示，通过在每一层设置“跳转”节点，可以加速查找操作，实现类似二分查找的效率。

跳表的简单实现：

import random

class Node:
    def __init__(self, data):
        self.data = data
        self.down = None  # pointer to the next level

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

class SkipList:
    def __init__(self):
        self.levels = []
        self.head = SkipListNode(None)  # header node

    def insert(self, data):
        # Code to insert data into the skip list
        pass

    def search(self, data):
        # Code to search for data in the skip list
        pass

    def random_level(self):
        # Determine the level for a new node
        level = 1
        while random.random() < 0.5:
            level += 1
        return level

7. 链表在数据库中的应用：版本链表

在数据库中，为了处理事务的并发控制和恢复，可以使用链表来维护数据项的不同版本。

版本链表的简单示例：

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

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

    def update(self, new_data, timestamp):
        new_version = DataVersion(new_data, timestamp)
        new_version.next = self.head
        self.head = new_version

    def rollback(self, timestamp):
        # Code to rollback to a specific version based on timestamp
        pass

8. 链表在编译器中的应用：符号表

符号表是一种用于存储和管理编译过程中变量、常量、类型等信息的数据结构，链表可以作为符号表的实现之一。

符号表的简单实现：

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

    def add_symbol(self, symbol, info):
        # Create a new node with symbol and info and add to the list
        pass

    def find_symbol(self, symbol):
        # Search for a symbol in the symbol table
        pass

9. 链表在操作系统中的应用：页置换算法

操作系统中的内存管理可以使用链表来实现页置换算法，如最近最少使用（LRU）算法。

页置换算法的简单实现：

class Page:
    def __init__(self, page_number):
        self.page_number = page_number
        self.next = None
        self.prev = None

class PageReplacement:
    def __init__(self, capacity):
        self.capacity = capacity
        self.pages = None

    def access_page(self, page_number):
        # Code to handle page access and replacement
        pass

10. 链表的并行处理

在多核处理器上，可以并行地对链表进行操作，如并行搜索、排序等。

并行搜索的简单示例：

from multiprocessing import Pool

def parallel_search(node, target):
    # Dummy function to represent searching a node for a target value
    return node.data == target

def search_in_parallel(head, target, num_workers):
    with Pool(processes=num_workers) as pool:
        result = pool.map(parallel_search, nodes, [target] * len(nodes))
    return any(result)

这些高级用法展示了链表不仅是一种基础数据结构，还可以作为实现更复杂算法和系统的基础组件。链表的灵活性使其成为许多高级编程场景的理想选择。
继续探讨链表的高级用法：

11. 链表在实现调度算法中的应用

在操作系统中，调度算法需要高效地管理进程或线程的执行顺序。链表因其动态特性，非常适合实现如轮转（Round-Robin）等调度算法。

轮转调度的简单实现：

class Process:
    def __init__(self, pid, burst_time):
        self.pid = pid
        self.burst_time = burst_time
        self.next = None

class Scheduler:
    def __init__(self):
        self.ready_queue = None

    def enqueue(self, process):
        if not self.ready_queue:
            self.ready_queue = process
            process.next = process
            return
        process.next = self.ready_queue.next
        self.ready_queue.next = process
        process.next.prev = process
        process.prev = self.ready_queue

    def dequeue(self):
        if not self.ready_queue or self.ready_queue == self.ready_queue.next:
            return None
        p = self.ready_queue.next
        self.ready_queue.next = p.next
        return p

    def schedule(self):
        # Implement Round-Robin scheduling logic
        pass

12. 链表在实现表达式树中的应用

在编译原理中，表达式树是用于表示数学表达式的一种树形数据结构。链表可以用于构建这种树的节点。

表达式树节点的简单实现：

class ExpressionTreeNode:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None

# Example usage:
# Creating a simple expression tree for the expression (a + b) * c
root = ExpressionTreeNode('*')
root.left = ExpressionTreeNode('+')
root.left.left = ExpressionTreeNode('a')
root.left.right = ExpressionTreeNode('b')
root.right = ExpressionTreeNode('c')

13. 链表在实现区间树中的应用

区间树是一种用于管理区间的数据结构，它可以快速确定哪些区间与给定区间相交。链表可以用于存储和管理这些区间。

区间树节点的简单实现：

class Interval:
    def __init__(self, start, end):
        self.start = start
        self.end = end

class IntervalTreeNode:
    def __init__(self, interval):
        self.interval = interval
        self.left = None
        self.right = None

class IntervalTree:
    def __init__(self):
        self.root = None

    def insert(self, interval):
        # Code to insert an interval into the tree
        pass

    def search(self, interval):
        # Code to search for intersecting intervals
        pass

14. 链表在实现文本编辑器中的应用

文本编辑器需要一种数据结构来存储文本数据，同时支持插入、删除和随机访问操作。链表（特别是双向链表）非常适合这种应用。

文本编辑器的简单实现：

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

    def insert(self, position, text):
        # Code to insert text at a given position
        pass

    def delete(self, start_pos, end_pos):
        # Code to delete text between start and end positions
        pass

    def get_text(self):
        # Code to retrieve the text from the editor
        pass

15. 链表在实现序列化和反序列化中的应用

链表的序列化是将链表结构转换为可以存储或传输的格式，反序列化则是将序列化后的格式还原为链表结构。

链表序列化和反序列化的简单实现：

class SinglyLinkedList:
    # ...（之前的代码）

    def serialize(self):
        # Convert the linked list to a string representation
        pass

    def deserialize(self, data):
        # Convert the string representation back to a linked list
        pass

链表的高级用法涵盖了从操作系统、数据库、编译器到文本编辑器等多个领域。链表的灵活性和动态特性使其成为实现这些高级应用的理想选择。通过这些高级用法，我们可以看到链表不仅仅是一个基础的数据结构，它在现代计算机科学和软件工程中扮演着重要的角色。

链表作为一种基础数据结构，在软件开发中有着广泛的应用。以下是一些链表在实战项目中的应用示例：

1. 实时数据流处理系统

在实时数据流处理系统中，链表可以用来存储和处理实时数据流。例如，使用链表实现一个环形缓冲区，可以高效地处理数据流并实现流量控制。

代码示例：

class CircularBuffer:
    def __init__(self, capacity):
        self.capacity = capacity
        self.buffer = [None] * capacity
        self.head = 0
        self.tail = 0

    def is_full(self):
        return (self.tail + 1) % self.capacity == self.head

    def is_empty(self):
        return self.head == self.tail

    def add(self, item):
        if self.is_full():
            raise BufferError("Buffer is full")
        self.buffer[self.tail] = item
        self.tail = (self.tail + 1) % self.capacity

    def remove(self):
        if self.is_empty():
            raise BufferError("Buffer is empty")
        item = self.buffer[self.head]
        self.head = (self.head + 1) % self.capacity
        return item

# 实时数据流处理
stream_processor = CircularBuffer(1024)
for data in real_time_data_stream:
    stream_processor.add(data)
    processed_data = stream_processor.remove()
    # 处理数据

2. 音乐播放器的播放列表管理

在音乐播放器中，链表可以用于管理播放列表，支持歌曲的随机插入、删除和重复播放。

代码示例：

class Song:
    def __init__(self, title, artist, duration):
        self.title = title
        self.artist = artist
        self.duration = duration

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

    def add_song(self, song):
        new_node = Node(Song)
        new_node.next = self.head
        self.head = new_node

    def remove_song(self, song_title):
        curr = self.head
        prev = None
        while curr and curr.song.title != song_title:
            prev = curr
            curr = curr.next
        if curr:
            if not prev:
                self.head = curr.next
            else:
                prev.next = curr.next

    def play(self):
        curr = self.head
        while curr:
            print(f"Playing {curr.song.title} by {curr.song.artist}")
            curr = curr.next

# 管理播放列表
my_playlist = Playlist()
my_playlist.add_song(Song("Song1", "Artist1", 210))
my_playlist.play()

3. 浏览器的页面历史管理

浏览器的前进/后退功能可以通过链表实现，其中每个节点代表一个页面历史记录。

代码示例：

class BrowserHistory:
    def __init__(self):
        self.head = None  # represents the current page
        self.tail = None  # represents the oldest page

    def visit(self, url):
        new_page = Node(url)
        if not self.head:
            self.head = self.tail = new_page
        else:
            new_page.next = self.head
            self.head.prev = new_page
            self.head = new_page

    def back(self):
        if self.head and self.head.prev:
            self.head = self.head.prev

    def forward(self):
        if self.head and self.head.next:
            self.head = self.head.next

    def show_current_page(self):
        if self.head:
            print(f"Current Page: {self.head.data}")

# 浏览器页面历史管理
browser_history = BrowserHistory()
browser_history.visit("http://example.com/page1")
browser_history.visit("http://example.com/page2")
browser_history.back()
browser_history.show_current_page()  # Show Page1

4. 内存管理模拟器

链表可以用于模拟操作系统中的内存管理，如伙伴系统或链表式内存分配。

代码示例：

class MemoryBlock:
    def __init__(self, size, is_free=True):
        self.size = size
        self.is_free = is_free
        self.next = None

class MemoryManager:
    def __init__(self):
        self.memory_list = None

    def allocate(self, size):
        # Find a suitable free block and allocate memory
        pass

    def deallocate(self, block):
        # Free the memory block
        pass

    def merge_free_blocks(self):
        # Merge adjacent free blocks to avoid fragmentation
        pass

# 内存管理
memory_manager = MemoryManager()
memory_manager.allocate(1024)  # Allocate 1KB
memory_manager.deallocate(some_block)
memory_manager.merge_free_blocks()

这些示例展示了链表在不同项目中的应用，从系统级应用到用户界面，链表都发挥着重要作用。链表的动态性和灵活性使其成为解决实际问题的理想选择。

链表在实际项目中的应用非常广泛，接下来我将提供一些更具体的实战项目示例，以及它们如何利用链表的特性来解决问题。

5. 社交媒体的时间线功能

社交媒体平台通常需要实现用户的时间线功能，展示用户关注的人的动态。链表可以用于实现这样的数据流，特别是当动态数据频繁更新时。

代码示例：

class Post:
    def __init__(self, author, content):
        self.author = author
        self.content = content
        self.next = None

class Timeline:
    def __init__(self):
        self.head = None  # 最新动态

    def add_post(self, post):
        post.next = self.head
        self.head = post

    def display_posts(self):
        post = self.head
        while post:
            print(f"{post.author}: {post.content}")
            post = post.next

# 用户的时间线
user_timeline = Timeline()
user_timeline.add_post(Post("User1", "Hello World!"))
user_timeline.add_post(Post("User2", "Learning linked lists!"))
user_timeline.display_posts()

6. 网络路由器的URL重定向

网络路由器或代理服务器经常需要对URL进行重定向。使用链表可以高效地管理重定向规则。

代码示例：

class RedirectRule:
    def __init__(self, original, redirect):
        self.original = original
        self.redirect = redirect
        self.next = None

class Router:
    def __init__(self):
        self.rules = None

    def add_rule(self, original, redirect):
        new_rule = RedirectRule(original, redirect)
        new_rule.next = self.rules
        self.rules = new_rule

    def apply_redirect(self, url):
        rule = self.rules
        while rule:
            if url == rule.original:
                return rule.redirect
            rule = rule.next
        return url

# 使用链表管理重定向规则
router = Router()
router.add_rule("http://oldsite.com", "http://newsite.com")
new_url = router.apply_redirect("http://oldsite.com")
print(new_url)  # 输出: http://newsite.com

7. 任务调度系统

在任务调度系统中，链表可以用于管理任务队列，支持任务的动态添加和执行。

代码示例：

class Task:
    def __init__(self, task_id, priority):
        self.task_id = task_id
        self.priority = priority
        self.next = None

class TaskScheduler:
    def __init__(self):
        self.tasks = None

    def add_task(self, task):
        if not self.tasks or task.priority > self.tasks.priority:
            task.next = self.tasks
            self.tasks = task
        else:
            current = self.tasks
            while current.next and current.next.priority >= task.priority:
                current = current.next
            task.next = current.next
            current.next = task

    def execute_tasks(self):
        current = self.tasks
        while current:
            # 执行任务逻辑
            print(f"Executing Task {current.task_id}")
            current = current.next

# 任务调度
scheduler = TaskScheduler()
scheduler.add_task(Task(1, 1))
scheduler.add_task(Task(2, 2))
scheduler.execute_tasks()

8. 数据库的事务日志

数据库的事务日志功能可以利用链表来记录每个事务的操作，便于进行事务恢复或回滚。

代码示例：

class TransactionLog:
    def __init__(self, transaction_id, operation):
        self.transaction_id = transaction_id
        self.operation = operation
        self.next = None

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

    def add_log(self, transaction_id, operation):
        log = TransactionLog(transaction_id, operation)
        log.next = self.head
        self.head = log

    def replay_logs(self):
        log = self.head
        while log:
            # 重放事务操作
            print(f"Transaction {log.transaction_id}: {log.operation}")
            log = log.next

# 数据库事务日志
db_logs = DatabaseLogSystem()
db_logs.add_log(1, "INSERT INTO table VALUES (...)")
db_logs.add_log(2, "UPDATE table SET ... WHERE ...")
db_logs.replay_logs()

9. 缓存系统的实现

缓存系统可以使用链表来管理缓存条目，特别是当需要实现如LRU（最近最少使用）这样的缓存淘汰策略时。

代码示例：

class CacheNode:
    def __init__(self, key, value):
        self.key = key
        self.value = value
        self.prev = None
        self.next = None

class LRUCache:
    def __init__(self, capacity):
        self.capacity = capacity
        self.cache = {}
        self.head = CacheNode(0, 0)  # Dummy head
        self.tail = CacheNode(0, 0)  # Dummy tail
        self.head.next = self.tail
        self.tail.prev = self.head

    def get(self, key):
        if key in self.cache:
            node = self.cache[key]
            self._move_to_head(node)
            return node.value
        return -1

    def put(self, key, value):
        if key in self.cache:
            self._move_to_head(self.cache[key])
        elif len(self.cache) >= self.capacity:
            tail = self.tail.prev
            self._remove(tail)
            del self.cache[tail.key]
        node = CacheNode(key, value)
        self._add_to_head(node)
        self.cache[key] = node

    def _move_to_head(self, node):
        self._remove(node)
        self._add_to_head(node)

    def _remove(self, node):
        prev, next = node.prev, node.next
        prev.next, next.prev = next, prev

    def _add_to_head(self, node):
        node.prev, node.next = self.head, self.head.next
        self.head.next.prev, self.head.next = node, node

# 使用LRU缓存
lru_cache = LRUCache(2)
lru_cache.put(1, 1)
lru_cache.put(2, 2)
print(lru_cache.get(1))  # 输出: 1
lru_cache.put(3, 3)      # 淘汰键2
print(lru_cache.get(2))  # 输出: -1