单链表（python）

说明：只是因为每次自己都要重写链表很麻烦，所以把写好的代码保存起来，方便以后使用。（简称偷懒）

class LNode(object):
    "单链表的结点"

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


class LinkedListUnderflow(ValueError):
    """异常"""
    pass


class LList(object):
    """链表"""

    def __init__(self):
        self._head = None
        self.size = 0

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

    def pretend(self, elem):
        """；、链表首端加节点"""
        self._head = LNode(elem, self._head)
        self.size += 1

    def pop(self):
        if self._head is None:
            raise LinkedListUnderflow("in pop")
        e = self._head.elem
        self._head =self._head.next
        self.size -= 1
        return e

    def append(self,elem):
        if self._head is None:
            self._head = LNode(elem)
            self.size += 1
            return
        p = self._head
        while p.next is not None:
            p = p.next
        p.next  = LNode(elem)
        self.size += 1



    def print_all(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 sort1(self):
        '''插入排序'''
        if self._head is None:
            return
        crt = self._head.next#从首节点开始处理
        while crt is not None:
            x = crt.elem
            p = self._head
            while p is not crt and p.elem <= x:#跳过小元素
                p =p.next
            while p is not crt:
                y = p.elem
                p.elem =x
                x = y
                p = p.next
            crt.elem = x#最后的回填
            crt = crt.next


    def sort2(self):
        """换连接方式的插入排序"""
        p = self._head
        if p is None or p.next is None: # 如果只有一个元素后为空表
            return
        rem = p.next
        p.next = None
        while rem is not None: # 还有未排序的元素，将rem节点插入正确的位置
            p = self._head
            q = None # p是第一个节点，q是p的前一个节点
            while p is not None and p.elem <= rem.elem: # 比较p与rem的元素
                q = p
                p = p.next # 元素较小，前进一步
            if q is None: # q为空表应该插入作为表头
                self._head = rem
            else: # 否则插入q节点之后
                q.next = rem
            q = rem
            rem = rem.next # rem指针前进一步
            q.next = p # 连接好q之后的表

    def len(self):
        return self.size


    def index(self,pos = 1):
        if self._head is None:
            print("ERROR")
            return
        if pos > self.size :
            print("ERROR")
            return
        if pos<=0:
            print("ERROR")
            return
        f = self._head
        t = 1
        while t < pos:
            f = f.next
            t += 1
        return f.elem

    def reserve(self):
        """翻转链表"""
        """O(n)"""
        pre = None
        p = self._head
        if p is None:
            return
        next = p.next
        while p is not None:
            p.next = pre
            pre = p
            p = next
            if p is not None:
                next = p.next

        self._head = pre

if __name__ == '__main__':
    testlist = LList()
    for i in range(10):
        testlist.pretend(i)
    for i in range(11,20):
        testlist.append(i)
    testlist.print_all()
    testlist.sort2()
    testlist.print_all()
    testlist.pop()
    testlist.print_all()
    testlist.sort1()
    testlist.print_all()
    print(testlist.len())
    print(testlist.index(2))
    testlist.reserve()
    testlist.print_all()

当然，最好先自己写一遍加深印象。

各位学习者尽管使用，如果哪里有错误，欢迎指正！如果有哪里不懂的地方也可以在评论指出，我会加上注释完善代码。谢谢关注！