Question

我在python中有一个基本的链表实现。每个Cell都有一些与之关联的数据和一个下一个对象，用于包含链表的其余部分（如果在构造函数中只给出了第一个数据参数，则为null）。

我想将两个列表复制并连接在一起，以便最终产品保留订单并独立于两个原始列表。

以下是我所拥有的：

def list_concat_copy(A, B):
        C = Cell(A)
        while A.next != None:
                A = A.next
                C = Cell(A,C)
        C = Cell(B,C)
        while B.next != None:
                B = B.next
                C = Cell(B,C)
        return C

我遇到的问题是这会颠倒顺序：

A = Cell(8,Cell(9,Cell(10)))
B = Cell(11,Cell(12,Cell(13)))
C = list_concat_copy(A,B)

现在如果我walk_and_print(C)我得到13 12 11 10 9 8

有什么想法吗？

Answer 1

你做了一些奇怪的事情：

A = Cell(8,Cell(9,Cell(10)))

建议您的Cell类似

class Cell(object):
    def __init__(self, val, nxt=None):
        self.val = val
        self.next = nxt

但正在做

C = Cell(A)

永远不会复制任何东西，它只是创建一个新的Cell，其中A与值相同。

所以，让我们从一个可以实际复制自己的Cell开始：

class Cell(object):
    def __init__(self, val, nxt=None):
        self.val = val
        self.next = nxt

    def copy(self):
        if self.next is None:
            return Cell(self.value)
        else:
            return Cell(self.value, self.next.copy())

现在你的结论很简单：

def concat_copy(a, b):
        new = a.copy()

        # find the end of the copy
        last = new
        while last.next is not None:
            last = last.next
        # append a copy of the other list
        last.next = b.copy()

为了完整起见，这是您尝试做的事情：

def copy( cells ):
    new = Cell(cells.value)
    current = new
    old = cells

    while old.next is not None:
        # copy the current cell
        ccopy = Cell(old.value)

        # add it
        current.next = ccopy

        # prepare for the next round
        current = ccopy
        old = old.next

    return new

我认为这有助于理解你是如何不小心颠倒了你的单元格的：你向前走过了列表，但是C = Cell(A,C)在新的C之前放置了一个新的Cell，以便从最后构建新的列表

Answer 2

列表向后打印，因为您正在将OUTER元素打包到新列表中。当您继续打开A时，您将向C添加包装。

复制这些列表的最简洁方法可能是执行A和B的deepcopy（我们称之为C和D），然后在C中设置最深的元素（通过遍历直到C. next == None）引用D.

Answer 3

我觉得在没有看到Cell的定义的情况下回答这个问题有点困难 - 但我认为我看到了错误。将列表视为一组图层。循环以C的最内值开始。每次在循环中调用Cell时，它会使用下一个值Cell“包装”该值。最外面的Cell具有最后一个值。

换句话说，

C = Cell(8)
D = Cell(9, C)
E = Cell(10, D)

相当于

E = Cell(10, Cell(9, Cell(8)))

这是清楚的吗？

编辑：

为了完整起见，这是另一种方法：

class Cell(object):
    def __init__(self, data, n = None):
        self.data = data
        self.next = n

def list_concat_copy(A, B):
        head = Cell(A.data)
        C = head
        while A.next != None:
                A = A.next
                C.next = Cell(A.data)
                C = C.next
        C.next = Cell(B.data)
        C = C.next
        while B.next != None:
                B = B.next
                C.next = Cell(B.data)
                C = C.next
        return head


A = Cell(8, Cell(9, Cell(10)))
B = Cell(11, Cell(12, Cell(13)))
C = list_concat_copy(A, B)

Answer 4

试试这个：

def list_concat(x,y):
    if x.next is None:
        return Cell(x.data,y)
    else:
        return Cell(x.data,list_concat(x.next,y))

Python复制并连接链表，保留顺序

4 个答案: