链表算法的八大法宝：掌握链表，稳定如磐石

2023-12-10 23:01:35

理解链表：数据结构的基础

数据结构在计算机科学中扮演着至关重要的角色，它们决定了应用程序如何存储和组织数据，以优化内存利用和处理效率。其中，链表以其灵活性、动态内存分配和操作简单性而著称，成为广泛应用于各种编程任务的数据结构。

链表算法：从基础到高级

掌握链表算法是成为一名优秀程序员的关键，它为解决广泛的问题提供了坚实的基础。本文将深入探讨八道经典链表算法题，涵盖链表操作中的常见任务和技术，帮助您提升链表编程技能。

1. 反转链表

反转链表是一种常见的操作，它涉及将链表中节点的顺序颠倒。例如，链表 [1, 2, 3, 4, 5] 在反转后变为 [5, 4, 3, 2, 1]。迭代法是一个常用的反转算法，它通过遍历链表并调整每个节点的指针来完成。

def reverse_linked_list(head):
    prev = None
    current = head

    while current:
        next_node = current.next
        current.next = prev
        prev = current
        current = next_node

    return prev

2. 链表的中间结点

查找链表的中间结点对于将链表分成相等的部分或从中获取元素很有用。快慢指针法是一种高效的算法，它使用快指针以两倍于慢指针的速度前进，从而快速找到中间结点。

def find_middle_of_linked_list(head):
    slow_ptr = head
    fast_ptr = head

    while fast_ptr and fast_ptr.next:
        slow_ptr = slow_ptr.next
        fast_ptr = fast_ptr.next.next

    return slow_ptr

3. 回文链表

回文链表是指从头到尾读取与从尾到头读取相同的链表。判断链表是否回文的方法之一是将其反转，然后比较原链表和反转后的链表。

def is_palindrome_linked_list(head):
    reversed_head = reverse_linked_list(head)

    while head and reversed_head:
        if head.val != reversed_head.val:
            return False
        head = head.next
        reversed_head = reversed_head.next

    return True

4. 移除链表元素

移除链表中特定值的元素是一项常见的任务。算法需要处理特殊情况，例如元素位于链表开头。

def remove_element_from_linked_list(head, val):
    if head.val == val:
        return head.next

    prev = None
    current = head

    while current:
        if current.val == val:
            if prev:
                prev.next = current.next
            else:
                head = current.next
            break
        prev = current
        current = current.next

    return head

5. 合并两个有序链表

合并两个有序链表涉及将两个已排序的链表合并为一个新的有序链表。分治法是一种常用的算法，它使用递归将问题分解为较小的子问题，逐一解决。

def merge_two_sorted_linked_lists(head1, head2):
    if not head1:
        return head2
    if not head2:
        return head1

    if head1.val < head2.val:
        head = head1
        head.next = merge_two_sorted_linked_lists(head1.next, head2)
    else:
        head = head2
        head.next = merge_two_sorted_linked_lists(head1, head2.next)

    return head

6. 检测链表是否有环

检测链表中是否有环非常重要，因为有环的链表会造成无限循环。弗洛伊德循环检测算法使用两个指针，快指针和慢指针，来检测是否有环。

def has_cycle_in_linked_list(head):
    slow_ptr = head
    fast_ptr = head

    while fast_ptr and fast_ptr.next:
        slow_ptr = slow_ptr.next
        fast_ptr = fast_ptr.next.next

        if slow_ptr == fast_ptr:
            return True

    return False

7. 相交链表

寻找两个链表的相交点是一个棘手的问题。双指针法是一种常用的算法，它将两个指针移动到两个链表的末尾，然后将第一个链表的指针移到第二个链表的开头，反之亦然。

def find_intersection_of_linked_lists(head1, head2):
    len1 = get_length_of_linked_list(head1)
    len2 = get_length_of_linked_list(head2)

    if len1 > len2:
        head1 = advance_pointer(head1, len1 - len2)
    else:
        head2 = advance_pointer(head2, len2 - len1)

    while head1 and head2:
        if head1 == head2:
            return head1
        head1 = head1.next
        head2 = head2.next

    return None

8. LRU 缓存

LRU（最近最少使用）缓存是一种优化数据访问的算法。它维护一个固定大小的缓存，其中包含最近使用的数据项。当缓存已满时，最久未使用的项将被移除。

class LRUCache:
    def __init__(self, capacity):
        self.capacity = capacity
        self.cache = {}
        self.head = None
        self.tail = None

    def get(self, key):
        if key in self.cache:
            node = self.cache[key]
            self.remove_node(node)
            self.add_node_to_head(node)
            return node.value
        else:
            return None

    def put(self, key, value):
        if key in self.cache:
            node = self.cache[key]
            node.value = value
            self.remove_node(node)
            self.add_node_to_head(node)
        else:
            node = Node(key, value)
            self.cache[key] = node
            self.add_node_to_head(node)

            if len(self.cache) > self.capacity:
                node = self.tail
                self.remove_node(node)
                del self.cache[node.key]