链表结构

定期整理点滴，完善自己，要给洋哥挣钱，让她不受苦，加油吧

class LList:
    def __init__(self):
        self._head = None

    def is_empty(self):
        return self._head is None

    def prepend(self, elem):
        self._head = LNode(elem, self._head)

    def pre_pop(self):
        if not self._head:
            raise LinkedListUnderflow("in pre pop")
        e = self._head.elem
        self._head = self._head.next
        return e

    def append(self, elem):
        if not self._head:
            self._head = LNode(elem)
            return
        p = self._head
        while p:
            p = p.next
        p.next = LNode(elem)

    def pop(self):
        if not self._head:
            raise LinkedListUnderflow("in pop")
        p = self._head
        if not p.next:
            e = p.elem
            self._head = None
            return e
        while p.next.next:
            p = p.next
        e = p.next.elem
        p.next = None
        return e

    def length(self):
        if not self._head:
            return 0
        p = self._head
        count = 1
        while p.next:
            count += 1
            p = p.next
        return count

    def reverse(self):
        p = None
        while self._head:
            q = self._head
            self._head = q.next
            q.next = p
            p = q
        self._head = p

    def print_all(self):
        if not self._head:
            return
        p = self._head
        while p:
            print(p.elem, end='')
            if p.next:
                print(', ', end='')
            p = p.next
        print('')

    def get_node(self, item):
        if not self._head:
            return
        if item > self.length() - 1:
            return -1
        p = self._head
        while item:
            p = p.next
            item -= 1
        return p

    def elements(self):
        p = self._head
        while p:
            yield p.elem
            p = p.next

    def filter(self, func):
        p = self._head
        while p:
            if func(p.elem):
                yield p.elem
            p = p.next


class WLList(LList):
    def __init__(self):
        super(WLList, self).__init__()
        self._rear = None

    def prepend(self, elem):
        if not self._head:
            self._head = LNode(elem)
            self._rear = self._head
        else:
            self._head = LNode(elem, self._head)

    def append(self, elem):
        if not self._head:
            self._head = LNode(elem)
            self._rear = self._head
        else:
            self._rear.next = LNode(elem)
            self._rear = self._rear.nex

    def pop(self):
        if not self._head:
            raise LinkedListUnderflow("in pop")
        p = self._head
        while not p.next:
            e = p.elem
            self._head = None
            return e
        while p.next.next:
            p = p.next
        e = p.next.elem
        p.next = None
        self._rear = p
        return e

    def reverse(self):
        r = self._head
        super().reverse()
        self._rear = r
        # self._rear = self.get_node(self.length() - 1)


class LCList:
    def __init__(self):
        self._rear = None

    def is_empty(self):
        return self._rear is None

    def prepend(self, elem):
        p = LNode(elem)
        if not self._rear:
            p.next = p
            self._rear = p
        else:
            p.next = self._rear.next
            self._rear.next = p

    def append(self, elem):
        self.prepend(elem)
        self._rear = self._rear.next

    def pre_pop(self):
        if not self._rear:
            raise LinkedListUnderflow("in pre pop")
        p = self._rear.next
        if self._rear is p:
            self._rear = None
        else:
            self._rear.next = p.next
        return p.elem

    def pop(self):
        if not self._rear:
            raise LinkedListUnderflow("in pop")
        p = self._rear.next
        e = self._rear.elem
        if self._rear is p:
            self._rear = None
        else:
            while p.next is not self._rear:
                p = p.next
            p.next = self._rear.next
            self._rear = p
        return e

    def length(self):
        if not self._rear:
            return 0
        p = self._rear.next
        count = 1
        while p is not self._rear:
            count += 1
            p = p.next
        return count

    def reverse(self):
        if not self._rear:
            return
        p = self._rear
        q = p.next
        rear = q
        while q is not self._rear:
            r = q.next
            q.next = p
            p = q
            q = r
        q.next = p
        self._rear = rear

    def get_node(self, item):
        if not self._rear:
            return
        if item > self.length() - 1:
            return
        p = self._rear.next
        while item:
            p = p.next
            item -= 1
        return p

    def print_all(self):
        if not self._rear:
            return
        p = self._rear.next
        while p is not self._rear:
            print(p.elem, end=', ')
            p = p.next
        print(p.elem)

    def elements(self):
        p = self._rear.next
        while p is not self._rear:
            yield p.elem
            p = p.next
        yield p.elem

    def filter(self, func):
        p = self._rear.next
        while p is not self._rear:
            if func(p.elem):
                yield p.elem
            p = p.next
        if func(p.elem):
            yield p.elem


class DLList(WLList):
    def __init__(self):
        super(DLList, self).__init__()

    def prepend(self, elem):
        p = DLNode(elem, None, self._head)
        if not self._head:
            self._rear = p
        else:
            p.next.prev = p
        self._head = p

    def append(self, elem):
        p = DLNode(elem, self._rear)
        if not self._head:
            self._head = p
        else:
            p.prev.next = p
        self._rear = p

    def pre_pop(self):
        if not self._head:
            raise LinkedListUnderflow("in pre pop")
        e = self._head.elem
        self._head = self._head.next
        if self._head:
            self._head.prev = None
        return e

    def pop(self):
        if not self._head:
            raise LinkedListUnderflow("in pop")
        e = self._rear.elem
        self._rear = self._rear.prev
        if not self._rear:
            self._head = None
        else:
            self._rear.next = None
        return e

    def reverse(self):
        p = None
        r = self._head
        while self._head:
            q = self._head
            self._head = q.next
            q.prev = q.next
            q.next = p
            p = q
        self._head = p
        self._rear = r


class DCList(LCList):
    def __init__(self):
        super(DCList, self).__init__()

    def prepend(self, elem):
        p = DLNode(elem)
        if not self._rear:
            p.next = p
            p.prev = p
            self._rear = p
        else:
            p.next = self._rear.next
            p.prev = self._rear
            self._rear.next.prev = p
            self._rear.next = p

    def append(self, elem):
        self.prepend(elem)
        self._rear = self._rear.next
    
    def pre_pop(self):
        if not self._rear:
            raise LinkedListUnderflow("in pre pop")
        p = self._rear.next
        if self._rear is p:
            self._rear = None
        else:
            self._rear.next = p.next
            p.next.prev = self._rear
        return p.elem

    def pop(self):
        if not self._rear:
            raise LinkedListUnderflow("in pop")
        p = self._rear.next
        e = self._rear.elem
        if self._rear is p:
            self._rear = None
        else:
            while p.next is not self._rear:
                p = p.next
            p.next = self._rear.next
            self._rear.next.prev = p
            self._rear = p
        return e

    def reverse(self):
        if not self._rear:
            return
        p = self._rear
        q = p.next
        rear = q
        while q is not self._rear:
            r = q.next
            q.prev = r
            q.next = p
            p = q
            q = r
        q.next = p
        q.prev = rear
        self._rear = rear

class LinkedListUnderflow(ValueError):
    pass

class LNode:
    def __init__(self, elem, next_=None):
        self.elem = elem
        self.next = next_

class DLNode(LNode):
    def __init__(self, elem, prev=None, next_=None):
        super(DLNode, self).__init__(elem, next_)
        self.prev = prev