掌握链表二相关算法技巧，在数据结构和算法领域大显身手

2023-10-27 16:35:53

在数据结构和算法的学习中，掌握链表相关算法无疑是重要的一步。链表作为一种动态的数据结构，以其灵活性、易用性而备受青睐。然而，由于链表的存储方式，它在某些操作上的效率不如数组。因此，为了有效处理链表相关问题，我们必须掌握相应的算法技巧。

在本文中，我们将接着上一篇文章《数据结构与算法--链表一》的内容，深入探讨六道链表算法难题。这些难题囊括了链表处理的各个方面，从基本操作到复杂算法，旨在全面提升您的链表算法能力。

1. K个一组翻转链表

K个一组翻转链表是指将链表中的节点每K个一组进行翻转。例如，对于链表1->2->3->4->5->6，当K=2时，翻转后的链表为2->1->4->3->6->5。

算法步骤：

将链表划分为K个一组，如果链表长度不足K，则保持原样。
对每一组链表进行翻转，可以使用双指针法。
将翻转后的组连接起来，形成新的链表。

def reverse_k_group(head, k):
    if not head or k == 1:
        return head

    dummy = ListNode(0)
    dummy.next = head

    prev = dummy
    curr = head
    next = None

    while curr:
        count = 0
        while curr and count < k:
            next = curr.next
            curr.next = prev
            prev = curr
            curr = next
            count += 1

        if count == k:
            head.next = curr
            head = prev

        prev = head
        curr = curr.next

    return dummy.next

2. 旋转链表

旋转链表是指将链表中的所有节点向右旋转K个位置。例如，对于链表1->2->3->4->5，当K=2时，旋转后的链表为4->5->1->2->3。

算法步骤：

找到链表的最后一个节点。
将最后一个节点连接到链表的头部。
将K个节点从链表头部断开，形成新的链表头。
将旧的链表头连接到新链表的尾部。

def rotate_list(head, k):
    if not head or k == 0:
        return head

    # 找到链表的最后一个节点
    last = head
    while last.next:
        last = last.next

    # 将最后一个节点连接到链表的头部
    last.next = head

    # 将K个节点从链表头部断开，形成新的链表头
    new_head = head
    for i in range(k-1):
        new_head = new_head.next

    # 将旧的链表头连接到新链表的尾部
    old_head = new_head.next
    new_head.next = None
    head = old_head

    return head

3. 两两交换链表中的节点

两两交换链表中的节点是指将链表中的相邻两个节点交换位置。例如，对于链表1->2->3->4->5，交换后的链表为2->1->4->3->5。

算法步骤：

设置两个指针，分别指向当前节点和下一个节点。
将当前节点的next指针指向下一个节点的next指针。
将下一个节点的next指针指向当前节点。
将当前节点的next指针指向下一个节点。
重复步骤1-4，直到到达链表尾部。

def swap_pairs(head):
    if not head or not head.next:
        return head

    dummy = ListNode(0)
    dummy.next = head

    prev = dummy
    curr = head
    next = head.next

    while curr and next:
        # 交换两个节点的next指针
        curr.next = next.next
        next.next = curr

        # 将prev节点的next指针指向交换后的节点
        prev.next = next

        # 更新prev、curr和next指针
        prev = curr
        curr = curr.next
        if curr:
            next = curr.next

    return dummy.next

4. 删除链表中的节点

删除链表中的节点是指从链表中删除给定的节点。

算法步骤：

如果要删除的节点是头节点，则直接返回头节点的next指针。
如果要删除的节点不是头节点，则找到要删除节点的前一个节点。
将要删除节点的前一个节点的next指针指向要删除节点的next指针。

def delete_node(node):
    if not node:
        return

    if node.next:
        node.val = node.next.val
        node.next = node.next.next
    else:
        node = None

5. 反转链表

反转链表是指将链表中的所有节点顺序颠倒。例如，对于链表1->2->3->4->5，反转后的链表为5->4->3->2->1。

算法步骤：

设置两个指针，分别指向当前节点和前一个节点。
将当前节点的next指针指向前一个节点。
将前一个节点更新为当前节点。
重复步骤1-3，直到到达链表尾部。

def reverse_list(head):
    if not head or not head.next:
        return head

    prev = None
    curr = head

    while curr:
        next = curr.next
        curr.next = prev
        prev = curr
        curr = next

    return prev