单链表类的实现

如何用python语言实现一个链表类

首先，先自定义一个异常类，用来捕获一些操作链表过程中遇到的错误状态，如遇到无法操作的错误参数

class LinkedListUnderflow(ValueError):
    pass

定义一个结点LNode

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

现在基于结点LNode定义一个单链表对象的类，在这种表对象里只有一个引用链接结点的_head域，初始化为None表示建立一个空表

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 pop(self):
        # 删除表头并返回这个结点的数据
        if self._head is None:
            raise LinkedListUnderflow("in pop")
        e = self._head.elem
        self._head = self._head.next
        return e    

    def append(self, elem):
        # 后端插入
        if self._head is None:
            self._head = LNode(elem)
            return
        p = self._head
        while p.next is not None:
            p = p.next
         p.next = LNode(elem)

    def pop_last(self):
        if self._head is None:  # 空表
            raise LinkedListUnderflow("in pop_last")
        p = self._head
        if p.next is None:  # 表中只有一个元素
            e = p.elem
            self._head = None
            return e
        while p.next.next is not None:  # p.next是最后结点
            p = p.next
        e = p.next.elem
        p.next = None
        return e

    def find(self, pred):
        p = self._head
        while p is not None:
            if pred == p.elem:
                return p.elem
            p = p.next
        return p

    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
        print("")
    def filter(self,pred):
        p = self._head
        while p is not None:
            if pred == p.elem:
                yield p.elem
            p = p.next

 循环单链表类：其中最后 一个结点的next域不用None，而是指向表的第一个结点。

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 self._rear is None:
            p.next = p
            self._rear = p
        else:
            p.next = self._rear.next
            self._rear = p
    def pop(self):
        # 删除表头并返回这个结点的数据
        if self._rear is None:
            raise LinkedListUnderflow("in pop")
        p = self._rear.next
        if self._rear is p:
            self._rear = None
        else:
            self._rear.next = p.next           
    def append(self, elem):
        self.prepend(elem)
        self._rear = self._rear.next
    def printall(self):
        if self.is_empty():
            return
        p = self._rear.next
        while True:
            print(p.elem)
            if p is self._rear:
                break
            p = p.next