简单链表队列

Question

所以在第一个代码中，我正在制作 a.next=b。这意味着 a.next 和 b 都作为对 Node6 的引用。所以当我制作 b=None.. 为什么 a.next 仍然指向 Node6，

在第二个代码中，当我使用 c=a 时，c 和 a 都是对节点 5 的引用。现在我正在创建 c.next=None，但是这种更改也反映到了 a。甚至 a.next 都变成了 None。

两个代码我都做了相同的步骤，为什么更改只反映在代码 2 中？

class Node:

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

a=Node(5)
b=Node(6)
a.next=b
b=None
while a is not None:
    print(a.val)
    a=a.next

代码 2

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

a=Node(5)
b=Node(6)
a.next=b
c=a
c.next=None
while a is not None:
    print(a.val)
    a=a.next

Answer 1

让我用图解表示来解释：

情况1：链表a有两个节点5和6。 但是在情况 2 中：列表 a 和 c 在链表中有一个节点 5。 b 指向的另一个链表只有 6 个。

希望这能澄清您的疑问。

注意： - 因为 a,b,c 是存储地址的指针。当你执行c.next=None时，c所指向的地址（也被a所指向）的next at address的值变为None。

Answer 2

你有一个班级Node。当您创建该类的对象并将其分配给诸如a 或b 之类的变量时，您正在动态分配足够大的内存以容纳对象的内容，然后分配地址该内存的变量。所以 CODE 1 真的看起来更像：

addr1 = storage address for Node(5) // Statement 1
a = addr1 // Statement 2
addr2 = storage address for Node(6) // Statement 3
b = addr2 // Statement 4
a.next = b // Statement 5
b = None // Statement 6

语句 5 将在语句 1 中分配的节点的next 属性更新为b，即addr2。在语句 6 中，我们为b 分配了一个新值，但这不会改变存储在a 引用的实际对象中的内容。考虑以下带有整数的示例：

x = 5
y = 7
x = y
y = 0

设置y = 0 不会影响x = y 的先前分配，即x 仍将具有y 的先前值7。在您的示例中唯一的区别是我们处理的不是整数而是地址。

现在我们认识到a 和b 确实是对保存实际对象的内存位置（即地址）的引用，当您说c=a 时，c 和a 现在都引用同一个对象并且可以可以互换使用。因此，c.next 和 a.next 引用相同的属性。

Answer 3

在第一种情况下，您将b 存储在a.next 中，因此在将头节点作为a 迭代链表时，您将遍历所有节点。

但在第二种情况下，c 和 a 具有相同的引用，而c.next 是None，所以每当您遍历带有c 头部的链表时，您只能到达一个节点。正如while a is not None 条件不允许移动到下一个节点。

以下代码按预期工作。

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


a = Node(5)
b = Node(6)
c = a
c.next = b #this line changed
while a is not None:
    print(a.val)
    a = a.next