单向链表（python）

描述：链表其实是有节点组成，节点内包含两个变量，一个存储数据，一个存储下一个节点对象地址。

class Node:
    #初始化加载
    def __init__(self,initdata):
        self.data = initdata
        self.next_node = None
    #修改数据
    def set_data(self,newdata):
        self.data = newdata
    #查看节点数据
    def peek_data(self):
        return self.data
    #添加/修改指向节点
    def set_nextnode(self,node):
        self.next_node = node
    #获取下一个节点
    def get_nextnode(self):
        return self.next_node
class UnOrderOneWayList:
    def __init__(self):
        self.head = None
    def is_empty(self):
        return self.head == None
    #添加节点，两种情况，一种是链表为空时，另一种是链表不为空时
    def add(self,data):
        if self.is_empty():
            self.head = Node(data)
        else:
            temp = self.head
            self.head = Node(data)
            self.head.next_node = temp
    #向尾部添加节点
    def append(self,data):
        if self.is_empty():
            self.head = Node(data)
        else:
            current = self.head
            while current.get_nextnode() != None:
                current = current.get_nextnode()
            current.set_nextnode(Node(data))
    #查找链表长度
    def length(self):
        index = 0
        temp_node = self.head
        while temp_node != None:
            index += 1
            temp_node = temp_node.next_node
        return index
    #节点数据查询
    def search(self,data):
        result = False
        current = self.head
        while current!=None and result !=True:
            if current.peek_data() == data:
                result = True
            else:
                current = current.get_nextnode()
        return result
    #指定数据节点移除
    def remove(self,data):
        current = self.head
        prenode = None
        found = False
        b_nextnode = True
        while not found and b_nextnode:
            if current.peek_data() == data:
                found = True
            else:
                prenode = current
                current = prenode.get_nextnode()
                if current == None:
                    b_nextnode = False
        if prenode == None:
            self.head = current.get_nextnode()
        else:
            if found and b_nextnode:
                prenode.set_nextnode(current.get_nextnode())
    #移除最后一个节点
    def pop(self):
        if self.head ==None:
            return False
        elif self.head.next_node == None:
            self.head = None
            return True
        else:
            pro_current = self.head
            current = self.head.next_node
            after_node = True
            while after_node:
                if current.get_nextnode() != None:
                    pro_current = current
                    current = current.get_nextnode()
                else:
                    pro_current.set_nextnode(None)
                    after_node = False

测试：

test = UnOrderOneWayList()
test.add(1)
test.add(2)
test.append(2)
test.add(3)
test.append(2)
test.remove(1)
test.pop()
test.pop()
print(test.length())
print(test.search(2))