单向链接表

# 封装普通节点的类
class Node:
    # 构造函数 定义节点的属性
    def __init__(self, data):
        self.data = data  #普通节点的数据域
        self.next =None  #普通节点的链接域  刚构造的节点该位置域为空

# 封装链表的类（封装头节点）
class LinkList:
    #构造函数
    def __init__(self, node=None):
        self.size = 0  #头结点的数据域位0 链表的长度为0
        self.head = node  #头节点的连接域指向None

    #判空
    def is_empy(self):
        return self.size == 0  #判断链表长度是否为0

    # 头插
    def add_head(self,value):
        #创建一个新的节点
        node = Node(value)
        #头插
        node.next = self.head
        self.head = node
        #插入成功 链表长度自增
        self.size += 1

    # 遍历
    def show(self):
        #判空
        if self.is_empy():
            print("空")
            return
        else:
            q = self.head
            while q:
                print("%d" % q.data, end=" ")
                q = q.next  #改变q的指向
            print()
    #尾插
    def add_tial(self,value):
        #可以判空 空的话  直接将head = node
        #创建一个节点
        node = Node(value)
        #找到链表的最后一个节点
        p = self.head
        i = 1
        while i < self.size:
            p = p.next
            i += 1
        #尾插
        p.next = node
        #尾插成功 链表长度自增
        self.size += 1

    # 任意位置插入数据
    def add_idex(self,idex,value):
        # 判断位置是否合理
        if idex<1 or idex > self.size:
            print("插入失败")
            return

        if idex == 1: #当插入的是第一个位置  头插
            self.add_head(value)
        else:
            # 找到要插入位置的前一个节点
            p = self.head
            i = 1
            while i < idex - 1:
                p = p.next
                i += 1
            #创建一个新的节点
            node = Node(value)
            # 插入
            node.next = p.next
            p.next = node
            # 插入成功 链表自增
            self.size += 1
    # 头删
    def del_head(self):
        # 判空
        if self.is_empy():
            print("删除失败")
        else:
            self.head = self.head.next
            # 删除成功 长度自减
            self.size -= 1
    # 尾删
    def del_tail(self):
        # 判空
        if self.is_empy():
            print("删除失败")
        elif self.size == 1:  # 当链表只有一个节点时
                self.head = None
        else:
            # 找到最后一个节点的前一个节点
            q = self.head
            i = 1
            while i < self.size - 1:
                q = q.next
                i += 1
            # 删除
            q.next = None
            # 删除成功 长度自减
            self.size -= 1
    # 任意位置删除
    def del_idex(self,idex):
        if idex<1 or idex > self.size:
            print("删除失败")
            return
        if idex == 1: #当删除的是第一个位置  头删
            self.del_head()
        else:
            # 找到要删除位置的前一个节点
            p = self.head
            i = 1
            while i < idex - 1:
                p = p.next
                i += 1
            # 删除
            q = p.next
            p.next = q.next
            q.next = None
            # 删除成功 链表自减
            self.size -= 1
    # 按位置修改
    def change_idex(self, idex, new_value):
        if idex<1 or idex > self.size:
            print("修改失败")
            return
        if idex == 1: #当插入的是第一个位置  头插
            self.del_head()
            self.add_head(new_value)
        else:
            p = self.head
            i = 1
            while i < idex:
                i += 1
            p.data = new_value
        print(f"节点位置 {idex} 的值已修改为 {new_value}")

    # 按值修改
    def change_value(self, old_value, new_value):
        p = self.head
        while p is not None:
            if p.data == old_value:
                p.data = new_value
                print(f"节点值 {old_value} 已修改为 {new_value}")
                return
            p = p.next
        print(f"修改失败：未找到值 {old_value}")

    # 按值查找返回位置
    def show_idex(self, value):
        p = self.head
        i = 1
        while p is not None:
            if p.data == value:
                print(f"值 {value} 位于链表的第 {i} 个位置")
                return i
            p = p.next
            i += 1
        print(f"值 {value} 不在链表中")
        return -1

    def reverse(self):
        a = None
        p = self.head
        while p is not None:
            next_node = p.next
            p.next = a
            a = p
            p = next_node
        self.head = a
        print("链表已反转")


# 测试
if __name__ == "__main__":
    # 创建链表
    linkList = LinkList()
    # 头插
    linkList.add_head(10)
    linkList.add_head(20)
    linkList.add_head(30)
    linkList.add_head(40)
    # 遍历
    linkList.show()

    # 尾插
    linkList.add_tial(11)

    # 遍历
    linkList.show()

    # 任意位置插入
    linkList.add_idex(3,107)
    linkList.show()

    # 头删
    linkList.del_head()
    linkList.show()

    # 尾删
    linkList.del_tail()
    linkList.show()

    #任意位置删除
    linkList.del_idex(2)
    linkList.show()

    #按位置修改
    linkList.change_idex(1,88)
    linkList.show()

    # 按值修改
    linkList.change_value(20,77)
    linkList.show()

    # 按照值查找返回位置
    linkList.show_idex(10)
    linkList.show()

    #链表的反转
    linkList.reverse()
    linkList.show()