链表的创建——python

源码：

# 定义一个普通节点类
class Node:
    def __init__(self, value):
        # 节点的值
        self.value = value
        # 指向下一个节点的指针，初始化为None
        self.next = None


# 定义链表类
class Linklist:
    def __init__(self, node=None):
        # 链表的头节点，初始化为传入的节点，如果没有传入则为None
        self.head = node
        # 链表的节点个数，初始化为0
        self.size = 0

    # 判断链表是否为空的方法
    def is_empty(self):
        # 如果链表的大小为0，则返回True，否则返回False
        return self.size == 0

    # 在链表头部插入节点的方法
    def head_insert(self, value):
        # 创建一个新节点，值为传入的value
        node = Node(value)
        # 新节点的下一个节点指向当前的头节点
        node.next = self.head
        # 将新节点设置为链表的新头节点
        self.head = node
        # 链表节点个数加1
        self.size += 1

    # 遍历链表并打印每个节点值的方法
    def print_list(self):
        # 从链表的头节点开始
        p = self.head
        while p:
            # 打印当前节点的值，不换行
            print(f'{p.value}', end=' ')
            # 将指针移动到下一个节点
            p = p.next
        # 遍历完链表后换行
        print()

    # 在链表尾部插入节点的方法
    def tail_insert(self, value):
        # 创建一个新节点，值为传入的value
        node = Node(value)
        p = self.head
        # 通过循环找到链表的最后一个节点（当前链表大小为self.size，所以循环到self.size - 1即可）
        for i in range(1, self.size):
            p = p.next
        # 将最后一个节点的next指针指向新创建的节点
        p.next = node
        # 链表节点个数加1
        self.size += 1

    # 在链表指定位置插入节点的方法
    def insert_list(self, value, index):
        # 如果插入位置小于0或者大于链表当前大小，则打印错误信息并返回
        if index < 0 or index > self.size:
            print("error")
            return
        else:
            # 创建一个新节点，值为传入的value
            node = Node(value)
            p = self.head
            # 如果插入位置是1，直接调用头插法插入节点
            if index == 1:
                self.head_insert(value)
            else:
                # 通过循环找到要插入位置的前一个节点（循环到index - 1）
                for i in range(1, index - 1):
                    p = p.next
                # 新节点的下一个节点指向当前位置的下一个节点
                node.next = p.next
                # 当前位置的节点的next指针指向新节点
                p.next = node
                # 链表节点个数加1
                self.size += 1

    # 删除链表尾部节点的方法
    def del_tail(self):
        p = self.head
        # 通过循环找到链表的倒数第二个节点（当前链表大小为self.size，所以循环到self.size - 2即可）
        for i in range(1, self.size - 1):
            p = p.next
        # 将倒数第二个节点的next指针置为None，即删除了最后一个节点
        p.next = None
        # 链表节点个数减1
        self.size -= 1

    # 删除链表头部节点的方法
    def del_head(self):
        # 如果链表为空，打印提示信息并返回
        if self.is_empty():
            print("列表为空")
            return
        # 将头节点指向下一个节点，即删除了原来的头节点
        self.head = self.head.next
        # 链表节点个数减1
        self.size -= 1

    # 在链表指定位置删除节点的方法
    def del_list(self, index):
        # 如果删除位置小于0或者大于链表当前大小，则打印错误信息并返回
        if index < 0 or index > self.size:
            print("error")
            return
        else:
            p = self.head
            # 通过循环找到要删除位置的前一个节点（循环到index）
            for i in range(1, index):
                p = p.next
            # 将当前位置的节点的next指针指向下下一个节点，即跳过了要删除的节点
            p.next = p.next.next
            # 链表节点个数减1
            self.size -= 1

    # 按值修改链表中节点值的方法
    def change_value(self, old_value, new_value):
        # 如果链表为空，打印提示信息并返回
        if self.is_empty():
            print("列表为空")
            return
        else:
            p = self.head
            # 遍历链表
            for i in range(self.size):
                # 如果找到值为old_value的节点
                if p.value == old_value:
                    # 将该节点的值修改为new_value
                    p.value = new_value
                    return
                else:
                    # 将指针移动到下一个节点继续查找
                    p = p.next
            else:
                # 如果遍历完链表都没有找到该值，打印提示信息并返回
                print("没有该值")
                return

    # 按值查找并返回节点在链表中的位置的方法
    def value_index(self, value):
        # 如果链表为空，打印提示信息并返回
        if self.is_empty():
            print("列表为空")
            return
        else:
            p = self.head
            # 遍历链表，从位置1开始（因为链表节点位置通常从1开始计数）
            for i in range(1, self.size + 1):
                # 如果找到值为value的节点
                if p.value == value:
                    # 返回该节点在链表中的位置
                    return i
                else:
                    # 将指针移动到下一个节点继续查找
                    p = p.next
            print("没有该值")

    # 链表反转的方法（采用头插法）
    def reverse_list(self):
        # 如果链表为空，打印提示信息并返回
        if self.is_empty():
            print("空列表")
            return
        else:
            # 记录链表的头节点
            start = self.head
            # 记录头节点的下一个节点
            end = self.head.next
            while end:
                # 将start节点的下一个节点指向下下一个节点，即断开start与end的连接
                start.next = end.next
                # 将end节点的下一个节点指向原来的头节点
                end.next = self.head
                # 将end节点设置为新的头节点
                self.head = end
                # 将end节点更新为start节点原来的下一个节点（即新的start节点的下一个节点）
                end = start.next