Question

我在leetcode上看到了一个问题，如：

Given 1->2->3->4->5->NULL,
return 1->3->5->2->4->NULL.

我写道：

class Solution(object):
    def oddEvenList(self, head):
        oddhead = head
        evenhead = head.next
        even = evenhead
        while evenhead and evenhead.next :
            oddhead.next = evenhead.next
            oddhead.next = oddhead
            evenhead.next = oddhead.next
            evenhead.next = evenhead
        oddhead.next = even
        return head

但它说time limit exceed.

我看到了某人的解决方案，如：

class Solution(object):
def oddEvenList(self, head):
    odd, p= head, head and head.next 
    while p and p.next:
        odd.next, p.next.next, p.next = p.next, odd.next, p.next.next #insert 
        odd, p = odd.next, p.next 
    return head

任何人都可以解释为什么我的代码在时间限制方面失败了吗？

对于解决方案，任何人都可以指出该代码如何在特定的情况下工作？我真的不太明白。

提前致谢！

Answer 1

任何人都可以解释为什么我的代码在时间限制方面失败了吗？

在while循环中，您永远不会修改evenhead，因此evenhead永远停留在节点2，循环永远不会终止。当然你打算进行作业

            oddhead.next = oddhead
            …
            evenhead.next = evenhead

反过来说：

            oddhead = oddhead.next
            …
            evenhead = evenhead.next

- 这样你的代码就可以了。

对于解决方案，任何人都可以指出该代码是如何工作的具体？

该解决方案与您的解决方案基本相同 - odd等同于您的oddhead，p等同于evenhead，列表分配

        odd.next, … p.next = p.next, … p.next.next #insert

等同于你（如上所述更正）

            oddhead.next = evenhead.next
            oddhead = oddhead.next
            evenhead.next = oddhead.next

和列表分配

        odd, p = odd.next, p.next

等同于你（如上所述更正）

            oddhead = oddhead.next
            …
            evenhead = evenhead.next

- 一个区别在于分配

        … p.next.next… = … odd.next… #insert

在循环中

，而你有

        even = evenhead
        …
        oddhead.next = even

分别在循环之后;这相当于在每个循环传递中将临时最后奇数节点链接到第一个偶数节点，而在循环之后仅将最后找到的最后一个奇数节点链接到第一个偶数节点，后者似乎效率更高。

其他解决方案的唯一优势在于，由于额外的测试Solution().oddEvenList(None)，它会优雅地处理空列表（head and head.next）。

奇数连链表

1 个答案: