Question

我正在从LeetCode那里提问。我发现了一些对我没有多大意义的东西。

问题：

给定一个链表，交换每两个相邻节点并返回它   头。

例如，给定1-> 2-> 3-> 4，您应该将列表返回为   2→1→4-＆GT; 3

您的算法应该只使用恒定空间。你可能不会修改   列表中的值，只能更改节点本身。

我的解决方案：

class ListNode(object):
    def __init__(self, x):
        self.val = x
        self.next = None

class Solution(object):
    def swapPairs(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """

        dummy = ListNode(0)
        dummy.next = head
        curr = dummy

        while curr.next and curr.next.next:
            a = curr.next
            b = curr.next.next

            curr.next = b
            a.next = b.next
            b.next = a
            curr = a

        return dummy.next

困惑：

当我执行curr = dummy时，似乎虚拟通过引用传递并且变异curr变异dummy。但是返回语句return dummy.next与return curr.next的值不同？从curr = dummy开始，在循环结束时，curr位于列表的末尾，所以dummy也不应该在列表的末尾？但是，dummy仍位于列表的最前面，dummy.next是传递给函数的列表的开头，但是以正确的方式进行了变更。

另外，当我这样做时：

        if curr is dummy:
            print("BEGIN")

        while curr.next and curr.next.next:
            a = curr.next
            b = curr.next.next

            curr.next = b
            a.next = b.next
            b.next = a
            curr = a

        if curr is dummy:
            print("END")

BEGIN会被打印，但END没有。

有人可以为我清除混乱吗？

Answer 1

当您执行作业var = x时，您var指向x。在此之后，它不会使其他变量指向同一个对象指向x。

考虑这个例子：

>>> a = {'p': 2}
>>> b = a
>>> b
{'p': 2}
>>> b['p'] = 4
>>> a
{'p': 4}
>>> b = {'q': 3}
>>> a
{'p': 4}
>>> b
{'q': 3}

或者这个：

>>> class Node:
...     def __init__(self, nxt):
...         self.nxt = nxt
...     def __repr__(self):
...         return '(Node => %s)' % self.nxt
... 
>>> a = Node(Node(2))
>>> a
(Node => (Node => 2))
>>> b = a
>>> b
(Node => (Node => 2))
>>> a.nxt = Node(4)
>>> a
(Node => (Node => 4))
>>> b
(Node => (Node => 4))
>>> b = b.nxt
>>> a
(Node => (Node => 4))
>>> b
(Node => 4)

通过Python

1 个答案: