位置ADT实施-使用双链表

如何解决位置ADT实施-使用双链表

大家好，这是位置列表ADT的实现：

class PositionalList(_DoublyLinkedBase):
    """ A sequential container of elements allowing positional access """

    # --------------------------- nested Position class -------------------------
    class Position:
        """ An abstraction representing the location of a single element """

        def __init__(self,container,node):
            """ Constructor should not be invoked by user """

            self._container = container
            self._node = node

        def element(self):
            """ Return element stored at this position """
            return self._node._element

        def __eq__(self,other):
            """ Return True if other is a Position representing the same location """
            return type(other) is type(self) and other._node is self._node

        def __ne__(self,other):
            """ Return True if other does not represent the same location """
            return not (self == other)

    # --------------------------- utility method -------------------------------
    def _validate(self,p):
        """ Return position's node,or raise appropriate error if invalid """
        if not isinstance(p,self.Position):
            raise TypeError("p must be proper position type")
        if p._container is not self:
            raise ValueError("p does not belong to this container")
        if p._node._next is None:  # convention for deprecated nodes
            raise ValueError("p is no longer valid")
        return p._node

    # ---------------------------- utility method -------------------------------
    def _make_position(self,node):
        """ Return Position instance for given node(or None if sentinel node) """
        if node is self._header or node is self._trailer:
            return None
        else:
            return self.Position(self,node)

    # ----------------------------- accessors ------------------------------------
    def first(self):
        """ Return the first Position in the list(or None if list is empty) """
        return self._make_position(self._header._next)

    def last(self):
        """ Return the last Position in the list(or None if list is empty) """
        return self._make_position(self._trailer._prev)

    def before(self,p):
        """ Return position before specified position p (or None if p is first)"""

        node = self._validate(p)
        return self._make_position(node._prev)

    def after(self,p):
        """ Return position after specified position p (or None if p is last)"""

        node = self._validate(p)
        return self._make_position(node._next)

    def __iter__(self):
        """ Generate a forward iteration of the element of the list """

        cursor = self.first()
        while cursor is not None:
            yield cursor.element()
            cursor = self.after(cursor)

    # -------------------------------- mutators -----------------------------------
    # override inherited version to return Position,rather than Node
    def _insert_between(self,e,predecessor,successor):
        node = super()._insert_between(e,successor)
        return self._make_position(node)

    def add_first(self,e):
        """ Insert element e at the front of the list and return new Position """
        return self._insert_between(e,self._header,self._header._next)

    def add_last(self,e):
        """ Insert element e at the end of the list and return new Position """
        return self._insert_between(e,self._trailer._prev,self._trailer)

    def add_before(self,p,e):
        """ Insert element e into list before Position p and return new position """
        original = self._validate(p)
        return self._insert_between(e,original._prev,original)

    def add_after(self,e):
        """ Insert element e into list after Position p and return new position """
        original = self._validate(p)
        return self._insert_between(e,original,original._next)

    def delete(self,p):
        """ Remove and return the element at Position p """
        original = self._validate(p)
        return self._delete_node(original)

    def replace(self,e):
        """ Replace element at Position p with e

        Return element formerly at Position p
        """

        original = self._validate(p)
        old_value = original._element
        original._element = e
        return old_value

    def __str__(self):
        l = []
        for e in self:
            l.append(e)
        return f"{l}"

与此相关的我的问题是，我们如何知道我们在此列表中所处的位置。我们显然可以在O（N）的时间内遍历此列表，但是如果我想移至列表中的任意位置并在该任意位置之前添加一个节点引用到该位置，那么我要遍历该节点引用的位置以获得返回值值，然后将该位置作为参数传递给我的add_before方法？

有没有更简单的方法来返回某种实际位置属性并将其用作更新列表的参考？除了遍历数据结构中的特定位置实例对象外，我似乎还不直觉，除非通过遍历，否则我不知道头顶每个节点所指的位置。

我很困惑，因为如果我仅有的只是一个位置实例对象，而不是一个定义列表本身中引用的位置位置和节点的属性，这是否会破坏O（1）插入/删除的目的？ / p>

此外，我了解_make_position方法正在实例化列表中包含节点引用的位置，但是它不返回我正在讨论的特定位置属性，而只是返回内存中的某些对象签名，这在直观上无济于事尝试在列表中间的前后任意添加/删除或访问节点。

任何指导将不胜感激