python数据结构学习笔记-4-链表

链表

本章内容易懂，书上有图解说明和完整代码，记录下来供参考就好了。

单链表实现堆栈

class Empty(Exception):    passclass LinkedStack:    """LIFO Stack implementation using a singly linked list for storage."""    class _Node:        """Lightweight nonpublic class for storing a singly linked node."""        __slots__ = '_element', '_next'                 #streamline memory usage        def __init__(self, element, next):                #initialize node's fields            self._element = element                       #reference to user's element            self._next = next                             #reference to next node    def __init__(self):        """Create an empty stack."""        self._head = None                          #reference to the head node        self._size = 0                             #number of stack elements    def __len__(self):        """Return the number of elements in the stack."""        return self._size    def is_empty(self):        """Return True if the stack is empty."""        return self._size == 0    def push(self,e):        """Add element e to the top of the stack."""        self._head = self._Node(e,self._head)          #create and linked a new node        self._size += 1    def top(self):        """Return (but do not remove) the element at the top of the stack.        Raise Empty exception if the stack is empty.        """        if self.is_empty():            raise Empty('Stack is empty')        return self._head._element    def pop(self):        """Remove and return the element from the top of the stack(i.e., LIFO).        Raise Empty exception if the stack is empty.        """        if self.is_empty():            raise Empty('Stack is empty')        answer = self._head._element        self._head = self._head._next                        #bypass the fromer top node        self._size -= 1        return answer

单链表实现队列

class LinkedQueue:    """FIFO queue implementation using a singly linked list for storage."""    class _Node:        """Lightweight, nonpublic class for storing a singly lined node."""        __slots__ = '_element', '_next'                 #streamline memory usage        def __init__(self, element, next):                #initialize node's fields            self._element = element                       #reference to user's element            self._next = next                             #reference to next node    def __init__(self):        """Create an empty queue."""        self._head = None        self._tail = None        self._size = 0                                #number of queue elements    def __len__(self):        """Return the number of elements in the queue."""        return self._size    def is_empty(self):        """Return True if the queue is empty."""        return self._size == 0    def first(self):        """Return (but do not remove) the element at the front of the queue."""        if self.is_empty():            raise Empty('Queue is empty')        return self._head._element                 #front aligned with head of list    def dequeue(self):        """Remove and return the first element of the queue(i.e.,FIFO).            Raise Empty exception if the queue is empty.        """        if self.is_empty():            raise Empty('Queue is empty')        anwser = self._head._element        self._head = self._head._next        self._size -= 1        if self.is_empty():                             #special case as queue is empty            self._tail = None                           #removed head had been the tail        return answer    def enqueue(self,e):        """Add an element to the back of queue."""        newest = self._Node(e,None)                    #node will be new tail node        if self.is_empty():            self._head = newest                        #special case: previously empty        else:            self._tail._next = newest        self._tail = newest                           #updater reference to tail node        self._size += 1

循环队列（首尾相连）

class CircularQueue:    """Queue implementation using circularly linked list for storage."""    class _Node:        """Lightweight, nonpublic class for storing a singly lined node."""        __slots__ = '_element', '_next'                 #streamline memory usage        def __init__(self, element, next):                #initialize node's fields            self._element = element                       #reference to user's element            self._next = next                             #reference to next node    def __init__(self):        """Create an empty queue."""        self._tail = None                                #will represent tail of queue        self._size = 0                                   #number of queue elements    def __len__(self):        """Return the number of elements in the queue."""        return self._size    def is_empty(self):        """Return True if the queue is empty."""        return self._size == 0    def first(self):        """Return (but do not remove) the element at the front of the queue.        Raise Empty exception if the queue is empty.        """        if self.is_empty():            raise Empty('Queue is empty')        head = self._tail._next        return head._element    def dequeue(self):        """Remove and return the first element of the queue(i.e., FIFO).        Raise Empty exception if the queue is empty.        """        if self.is_empty():            raise Empty('Queue is empty')        oldhead = self._tail._next        if self._size == 1:                                     #removing only element            self._tail = None                                   #queue becomes empty        else:            self._tail._next = oldhead._next                    #bypass the old head        self._size -= 1        return oldhead._element    def enqueue(self, e):        """Add an element to the back of queue."""        newest = self._Node(e, None)             # node will be new tail node        if self.is_empty():            newest. next = newest                 # initialize circularly        else:            newest._next = self._tail._next      # new node points to head        self. tail. next = newest                # old tail points to new node        self._tail = newest                            # new node becomes the tail        self._size += 1    def rotate(self):        """Rotate front element to the back of the queue."""        if self._size > 0:            self._tail = self._tail._next               #old head becomes new tail

双向链表

基类：_DoublyLinkedBase

class _DoublyLinkedBase:    """A base class providing a doubly linked list representation."""    class _Node:        """Lightweight, nonpublic class for storing a doubly linked node."""        slots = _element , _prev , _next            # streamline memory        def __init__(self, element, prev, next):   # initialize node's fields            self._element = element                #user's element            self._prev = prev                      # previous node reference            self._next = next                      # next node reference    def __init__(self):        """Create an empty list."""        self._header = self._Node(None, None, None)        self._trailer = self._Node(None, None, None)        self._header._next = self._trailer           # trailer is after header        self._trailer. prev = self._header           # header is before trailer        self._size = 0                               # number of elements    def __len__(self):        """Return the number of elements in the list."""        return self._size    def is_empty(self):        """Return True if list is empty."""        return self._size == 0    def _insert_between(self, e, predecessor, successor):        """Add element e between two existing nodes and return new node."""        newest = self._Node(e, predecessor, successor) # linked to neighbors        predecessor._next = newest        successor._prev = newest        self._size += 1        return newest    def _delete_node(self, node):        """Delete nonsentinel node from the list and return its element."""        predecessor = node._prev        successor = node._next        predecessor._next = successor        successor._prev = predecessor        self._size −= 1        element = node._element                                 # record deleted element        node._prev = node._next = node._element = None          # deprecate node        return element                                          # return deleted element    class LinkedDeque(_DoublyLinkedBase):                           #note the use of inheritance    """Double-ended queue implementation based on a doubly linked list."""        def first(self):        """Return (but do not remove) the element at the front of the deque."""        if self.is_empty():            raise Empty("Deque is empty")        return self._header._next._element        #real item just after header        def last(self):        """Retrun (but do not remove) the element at the back of the deque."""        if self.is_empty():            raise Empty("Deque is empty")        return self._trailer._prev._element       #real item just before trailer        def insert_first(self,e):        """Add an element to the front of the deque."""        self._insert_between(e, self._header, self._header._next)  #after header            def insert_last(self,e):        """Add an element to the back of the deque.        Raise Empty exception if the deque is empty.        """                if self.is_empty():            rasie Empty("Deque is empty")        return self._delete_node(self._trailer._prev)   #use inherited method        class PosintionalList(_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 elemnt(self):            """Return the element stored at this Positiong."""            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 is other does not represent the same location."""            return not (self == other)   #opposite of __eq__                #---------- utility method ------------------        def _validate(self,p):            """Return position's node, or raise approriate error if invalid."""            if not isinstace(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                def _make_position(self, node):            """Return Position instance for given node(or None if sentinel)."""            if node if self._header or node is self._trailer:                return None                           #boundary violation            else:                return self.Position(self, node)      #legitimate position                #----------- accessors ----------------------        def first(self):            """Return the first Position in the list(or None if list ie 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_postion(self.trailer._prev)                def before(self,p):            """Return the Position just before Position p (or None if p is first)."""            node == self._validate(p)            return self._make_position(node._prev)                def after(self, p):            """Return the Position just after 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 elements 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):            """Add element between existing nodes and return new Position."""            node = super()._insert_between(e, predecessor, successor)            return self._make_positiong(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 back 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, origiane._next)                def delete(self, p):            """Remove and return the element at Position p."""            original = self._validate(p)            return self._delete_node(original) #inherited method returns element                def replace(self,p,e):            """Replace the element at Position p with e.            Return the element formerly at Positin p.            """            original = self._validate(p)            old_value = original._element      #temporary store old element            original._element = e              #replace with new element            return old_value                   #return the old element value