数据结构与算法python语言实现-单链表实现

使用python实现一个简单单链表，头/尾添加/删除元素，查找满足一定条件（任意定义的条件）的元素，遍历对每个元素实行一种操作（任意定义的操作），迭代器一样的访问链表

##代码部分##

#自定义一种错误类型
class LinkedListUnderflow(ValueError):
    pass

#定义链表节点类
class LNode:
    def __init__(self, elem, next_=None):
        self.elem = elem
        self.next = next_
#定义链表类        
class LList:
    #初始化为空表，存self._head储表头信息
    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) #self._head存储一个新的链表节点，原来的self._head变为新节点的next
    #表头删除节点
    def pop(self):
        if self._head is None: #无节点，引发异常
            raise LinkedListUnderflow("in pop")
        e = self._head.elem
        self._head = self._head.next
        return e #返回被删除的elem
    #后端插入
    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
    #查找满足条件的元素,pred是一个判断谓词
    #python中函数也是对象可以作为函数参数传递
    def find(self, pred): 
        p = self._head
        while p is not None:
            if pred(p.elem):
                return p.elem
            p = p.next            
    #遍历操作
    def for_each(self, proc):
        p = self._head
        while p is not None:
            p.elem = proc(p.elem)
            p = p.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
        print('') #换行，参数是空串
    
    #为LList类定义对象iterator
    #这样代码里就可以使用 for i in l.elements():
    #l是链表一个实例  
    def elements(self):
        p = self._head
        while p is not None:
            yield p.elem
            p = p.next

##测试部分##

#新建一个空链表
l = LList()

#尾部添加0-9
for i in range(10):
    l.append(i)

#头部添加10-19
for i in range(10,20):
    l.prepend(i)
#这时l.printall()应为19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9

#头部删除5个元素
for i in range(5):
    l.pop()
#尾部删除5个元素
for i in range(5):
    l.pop_last()
#这时l.printall()应为14, 13, 12, 11, 10, 0, 1, 2, 3, 4

#迭代器样的访问
for x in l.elements():
    print(x)

#遍历查找第一个小于2的元素,输出元素应该为0
def lower_2(num):
    return num < 2
l.find(lower_2) 

#遍历，每个元素加一
def add_1(num):
    return num + 1
l.for_each(add_1)
l.printall()#这时输出应该为15, 14, 13, 12, 11, 1, 2, 3, 4, 5