Python定义节点类Node和单向链表类 单向链表 python

# 要实现的功能：判空，长度，遍历，从头部添加，从尾部添加，从指定位置添加，删除，查找

#定义一个节点类
class Node(object):
    def __init__(self, item):
        #传入的参数
        self.item = item
        #当前节点的下一节点
        self.next = None

#定义一个单向链表类
class Siglelist(object):
    #初始化，头部节点为空
    def __init__(self):
        self.head = None
    #判空
    def is_empty(self):
        return self.head == None
    #长度
    def length(self):
        #记录长度
        count = 0
        #初始时指向头部
        cur = self.head
        #当前指针不为空时，长度自增且指针指向下一个数据
        while cur != None:
            count += 1
            cur = cur.next
        #返回长度
        return count
    #遍历
    def travel(self):
        #初始时指针指向头部
        cur = self.head
        #若当前指针指向的数据不为空，则输出当前数据，并且指针下移
        while cur != None:
            print(cur.item, end=' ')
            cur = cur.next
        #输出一个数据后换行
        print()
    #从头部添加
    def add(self, item):
        #实例化一个节点，并输入想要添加的数据
        node = Node(item)
        #将头部数据赋给头部数据的下一个数据
        node.next = self.head
        # 将输入的实例化数据节点赋给头部节点
        self.head = node

        try:
            print("node.next1:",node.next.item)
            print("self.head1:",self.head.item)
        except:
            print("node.next2:", node.next)
            print("self.head2:", self.head.item)
        print("node：",node.item)
        
    #从尾部添加数据
    def append(self,item):
        #实例化一个节点，并输入要想要插入的数据
        node = Node(item)
        #判断当前链表是否为空，若为空则将插入的数据赋给头部节点
        if self.is_empty():
            self.head = node
        # 反之
        else:
            #初始化指针指向头部节点
            cur = self.head
            #若当前指针的下一个节点不为空时，指针一直下移，
            #直到移动到下一个节点为空，即当前节点为最后一个节点
            while cur.next!=None:
                cur = cur.next
            #在当前节点为链表的最后一个节点时，将输入的数据赋给当前节点的下一个节点,
            #即在最后添加数据
            cur.next = node
    #在指定位置插入数据，pos为指定要插入的下标，item指要插入的数据
    def insert(self,pos,item):
        #指定要插入的的下标小于等于0时，按0处理，在头部添加数据
        if pos<=0:
            self.add(item)
        #指定要插入的的下标大于链表长度时时，按最后一个节点下标处理处理，在尾部添加数据
        elif pos>=self.length():
            self.append(item)
        #指定链表中有的下标时
        else:
            #实例化一个节点并传入要插入的数据
            node = Node(item)
            #指针指向头部节点
            cur = self.head
            #计数
            count = 0
            #将指针移动到指定下标节点的前一个节点
            while count<pos-1:
                cur = cur.next
                count+=1
            #将指定下标节点的值赋给实例化节点的下一个节点，即赋给None
            node.next = cur.next
            #将实例化节点的值赋给指定下标的节点
            cur.next = node
    #删除
    def remove(self,item):
        #定义一个空指针
        pre = None
        #定义一个指针指向头部
        cur = self.head
        #若当前指针的数据不等于要输入的数据
        while cur.item!=item:
            #将当前指针指向的节点赋给空指针
            pre = cur
            #当前指针下移
            cur = cur.next
        #若当前指针的数据等于要删除的数据，则将当前指针指向的节点的下一个节点
        #赋值给当前指针指向的节点的上一个节点，即将当前节点抛弃
        pre.next = cur.next

    #查找
    def search(self, item):
        #初始化指针，将指针指向头部节点
        cur = self.head
        #若当前指针指向节点的下一个节点不为空，即当前节点不是最后一个节点时
        while cur.next != None:
            #遍历链表，若链表中有数据等于要查找的数据时输出True
            if cur.item == item:
                print(True)
                break
            cur = cur.next
        #否则输出Flase
        else:
            print(False)
#实例化链表对象
sigle = Siglelist()
print(sigle.is_empty())
sigle.add(1)
sigle.add(2)
sigle.add(3)
print(sigle.is_empty())
sigle.travel()
sigle.length()
sigle.append(4)
sigle.travel()  # 3 2 1 4
sigle.insert(2, 5)
sigle.travel()
sigle.remove(4)
sigle.travel()
sigle.search(2)