重新排列 LinkedList，产生无穷无尽的端点

Question

我现在正在处理重新排列链接列表的问题。代码的逻辑感觉是对的，但是遇到重复链表的无穷无尽的点。我不知道为什么，但感觉更可能是链表的定义有问题。问题是：

给定一个单链表的头部，写一个方法来修改 LinkedList 使得来自 LinkedList 后半部分的节点 从前半部分反向交替插入节点 命令。所以如果 LinkedList 有节点 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> null，你的方法应该返回 1 -> 6 -> 2 -> 5 -> 3 -> 4 -> null。

您的算法不应使用任何额外的空间和输入 LinkedList 应该就地修改。

示例 1：

输入：2 -> 4 -> 6 -> 8 -> 10 -> 12 -> null 输出：2 -> 12 -> 4 -> 10 -> 6 -> 8 -> 空

示例 2：

输入：2 -> 4 -> 6 -> 8 -> 10 -> null 输出：2 -> 10 -> 4 -> 8 -> 6 -> 空

我的做法是：

def rearrange_linkedlist(head):
    # find the middle as the separating point
    middle = middle_linkedlist(head)
    # reverse the second part
    second_head = reverse_linkedlist(middle)
    while head and second_head:
        following_1 = head.next 
        following_2 = second_head.next 
        head.next = second_head
        second_head.next = following_1
        head = following_1
        second_head = following_2

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

def reserve_linkedlist(head):
    current = head 
    previous = None
    while current:
        following = current.next
        current.next = previous
        previous = current 
        current = following 
    return previous

链表的设置：

from __future__ import print_function

class node:
    def __init__(self, value, next=None):
        self.value = value
        self.next = next 
    
    def print_list(self):
        temp = self
        while temp:
            print(str(temp.value) + ' ', end='')
            temp = temp.next 
        print()

def main():
    head = node(2)
    head.next = node(4)
    head.next.next = node(6)
    head.next.next.next = node(8)
    head.next.next.next.next = node(10)
    head.next.next.next.next.next = node(12)
    rearrange_linkedlist(head)
    head.print_list()
    
main()

结果是：

2 12 4 10 6 8 8 8 

重复 8。我不确定它有什么问题。提前感谢您的帮助。

Answer 1

将所有三个步骤拆分为不同的辅助函数可能会有所帮助。即，目前，您只有一个帮助函数来查找中间和反转列表。您可能还应该有一个用于合并两个列表（这是您当前代码中的问题所在）：

def rearrange_linkedlist(head):
    middle = find_middle(head)
    reversed_second_half = reverse_list(middle)
    merge_two_lists_inplace(head, reversed_second_half)


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


def reverse_list(head):
    prev, curr = None, head
    while curr:
        curr.next, prev, curr = prev, curr, curr.next  
    return prev


def merge_two_lists_inplace(l1, l2):
    while l1 and l2 and l2.next:
        l1.next, l1 = l2, l1.next
        l2.next, l2 = l1, l2.next

您的代码的问题是链表前半部分的末尾指向反向后半部分的末尾。在合并循环的最后一次迭代中，列表如下所示：

2 -> 12 -> 4 -> 10 -> 6 -> 8 -> null
                      ^    ^
                     head  second_head

当您分配second_head.next = following_1 时，您实际上是在分配最终节点指向它自己。在循环条件中检查 second_head.next 会在循环处于上述状态时终止循环。