python單鏈表

#!/usr/bin/env python3
# -*- coding:utf-8 -*-


class LNode:
    """
    結點類
    """

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


class LinkedListUnderflow(ValueError):
    """
    自定義異常
    """
    pass


class LList:
    """
    鏈表類
    """

    def __init__(self):
        self._head = None

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

    # 操做pop刪除表頭結點並返回這個結點裏的數據
    def pop(self):
        if self._head is None:
            raise LinkedListUnderflow("in pop")
        e = self._head.elem
        self._head = self._head.next
        return e

    # 在表頭插入元素
    def prepend(self, elem):
        self._head = LNode(elem, self._head)

    # 在鏈表最後插入元素
    def append(self, elem):
        if self._head is None:
            self._head = LNode(elem)
            return None
        # 若是鏈表爲空則直接把表頭指向須要插入的元素便可在。其實是在操做_head域

        p = self._head
        while p.next is not None:
            p = p.next
        p.next = LNode(elem)
        # 若是不爲空，則先從頭掃描鏈表，找到最後的結點，而後把最後結點的next指向須要插入的元素便可。其實是在操做next域

    # 刪除最後一個結點
    def pop_last(self):
        if self._head is None:  # 空表
            raise LinkedListUnderflow("in pop_last")
        p = self._head
        if p.next is None:  # 若是表長爲1，則清空之，並返回原來的元素
            e = p.elem
            self._head = None
            return e
        while p.next.next is not None:
            p = p.next
        e = p.next.elem
        p.next = None
        return e
        # 若是表長大於1,則從頭掃描，找到倒數第二個結點，把倒數第二個結點的next域置空，並返回最後一個結點

    def printall(self):  # 掃描打印鏈表的每一個元素
        p = self._head
        while p is not None:
            print(p.elem, end='')
            if p.next is not None:
                print(',', end='')
            p = p.next

    def elements(self):  # 寫一個生成器，使鏈表支持for操做
        p = self._head
        while p is not None:
            yield p.elem
            p = p.next


class LList1(LList):  # 派生一個變形單鏈表類
    def __init__(self):
        LList.__init__(self)
        self._rear = None

    def prepend(self, elem):  # 重構prepend方法
        if self._rear is None:
            self._head = LNode(elem, self._head)
            self._rear = self._head
        else:
            self._head = LNode(elem, self._head)

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

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