第三章线性表

顺序表的实现

python自带的list就是线性表，关于它的实现，操作，性质就不讲了，记住一点即可：分离式技术实现的动态顺序表。

链接表

#定义表节点类
class LNode:
    def __init__(self,elem,next_=None):
        self.elem=elem
        self.next=next_

链接表的基本操作

#自定义异常
class LinkedListUnderflow(ValueError):
    pass

#LList类的定义，基于结点类LNode定义一个单链表对象的类。
class LList:
    
    def __init__(self):
        self._head=None
        
    #判断LList类是否为空
    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=p.next
        e=p.next.elem
        p.next=None
        return e
    
    #查询第一个满足某条件的结点（pred()表示判断条件）
    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:
            proc(p.elem)
            p=p.next
    '''
    当proc=print时，将一行一行输出
    list1.for_each(print)
    '''
    
    #生成器
    def elements(self):
        p=self._head
        while p is not None:
            yield p.elem
            p=p.next
    '''
    for x in list1.elements()
        print(x)
    '''
    
    #筛选生成器(满足某个条件的多个结点)
    def filtert(self,pred):
        p=self._head
        while p is not None:
            if pred(p.elem):
                yield p.elem
            p=p.next

单链表简单变形

a)给表对象增加一个对表尾结点的引用

前面实现的一个缺点是尾端加入操作的效率低
实际中可能经常需要频繁地在表的两端加入元素

#链表简单变形，表对象增加一表尾节点引用域，有了这个域，只需常量时间就能找到表尾结点

class LList01(LList):

    def __init__(self):
        self._head=None
        self._rear=None
        
    #首端加入
    def prepend(self,elem):
        if self._head 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._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:
            e=p.elem
            self._head=None
            self._rear=self._head
            return e
        while p.next.next is not None:
            p=p.next
        e=p.next
        p.next=None
        self._rear=p
        return e
    
    #新增函数，输出链表最后一个节点的值
    def print_lastone(self):
        print(self._rear.elem)