从单向链表中删除指定值的节点

class ListNode:
    def __init__(self, val, next = None):
        self.val = val
        self.next = next
class Solution:
    def insert(self, head, val_pre, val):
        cur = head
        while cur.val != val_pre:
            cur = cur.next
        next_node = cur.next
        node = ListNode(val)
        cur.next = node
        node.next = next_node
    
    def remove(self, head, val):
        cur, pre = head, head
        while cur.val != val:
            pre = cur
            cur = cur.next
        pre.next = cur.next

input = list(map(int, input().split()))
head = ListNode(input[1])
solution = Solution()
for i in range(2, len(input) - 1, 2):
    solution.insert(head, input[i+1], input[i])
solution.remove(head, input[-1])
while head:
    print(head.val, end = ' ')
    head = head.next

求大佬帮忙看看，为啥超时了

import re
import sys

input_list = input().split()
n = int(input_list[0]) # 链表结点个数
first_value = input_list[1] # 头结点的值
values = input_list[2:(2*n)] # 节点规则list
x = input_list[-1] # 要删除的结点的值

LIST = [first_value] # 链表list


while len(LIST)<n: # 当链表节点个数达到时，跳出循环
    tmp = values.copy() # 复制一个节点规则list，防止后面循环里删除时产生矛盾
    length = len(tmp) 
    last_value = LIST[-1] 
    # 从未完成的链表的最后一个节点开始，找其后面的值
    # 需要倒序看节点规则list，比如头节点的值在节点规则里面出现三次，即头节点后面依次加入了3个节点，并且是倒叙加入
    # 节点规则list里，偶数i对应i-1，i是定位需要添加后一个值的节点，i-1是添加的节点值
    for i in range(length-1,-1,-2): 
        if tmp[i] == last_value:
            LIST.append(tmp[i-1])
            del values[i] # 为了减少遍历的长度，已经添加过的节点，在节点规则list里删除
            del values[i-1] # 为了减少遍历的长度，已经添加过的节点值，在节点规则list里删除

result = ''
for v in LIST:
    if v != x:
        result += str(v)
        result += ' ' 
print(result)

# 定义链表结构
class ListNode:
    def __init__(self,val,next=None):
        self.val = val
        self.next = next

def addNode(old,new):
    newNode = ListNode(new)
    newNode.next = old.next
    old.next = newNode

# 构建初始链表
inList = [int(i) for i in input().split()]
n = inList[0]
k = inList[-1]

dummy =ListNode(None)
root = ListNode(inList[1])
dummy.next = root

#构建完整链表
for i in range(2,len(inList)-2,2):
    old = inList[i+1]
    new = inList[i]
    while root.val != old:
        root = root.next
    addNode(root,new)
    root = dummy.next

#删除指定结点
if root.val == k:
    root = root.next
else:
    for _ in range(n):
        if root.next.val == k:
            root.next = root.next.next
            break
        root = root.next

#打印删除后链表
out = []
for _ in range(n-1):
    out.append(dummy.next.val)
    dummy = dummy.next

for i in range(len(out)):
    print(out[i], end=' ')
  

class ListNode:
    def __init__(self, val):
        self.val = val
        self.next = None
# 根据题意在链表中插入节点        
def create_list(head_node, val1, val2):
    cur=head_node
    while cur:
        if cur.val==val2:
            insert_node=ListNode(val1)
            insert_node.next=cur.next
            cur.next=insert_node
            break
        else:
            cur=cur.next

S=[int(x) for x in input().split()]
head_value=S[1] #头结点值
N=S[2:-1] #链表的操作
value=S[-1] #要删除的节点的值

head=ListNode(head_value)
# 按照题目格式插入各个节点
for i in range(0,len(N),2):
    create_list(head,N[i],N[i+1])
# 删除指定值的结点
cur=head
while cur:
    if cur.next.val==value:
        cur.next=cur.next.next
        break
    else:
        cur=cur.next

# 打印删除后的列表
cur=head
while cur:
    print(cur.val,end=' ')
    cur=cur.next
# 若删除后列表无结点 返回None
if S[0]==1 and S[-1]==S[1]:
    print(None)

data = list(map(int, input().split()))
link=[data[1]]
for i in range(1,data[0]):
    if link.count(data[2*i])==0:
        link.insert(link.index(data[2*i+1])+1, data[2*i])
link.remove(data[-1])
for i in link:
    print(i,end=' ')

while True:
    try:
        s = input().split()
        s_num, s_top, ss, s_d = s[0], s[1], s[2:-1], s[-1]
        print( s_num, s_top, ss, s_d )

        ssr = [s_top]
        for x in range(0, len(ss), 2):
            x1, x2 = ss[x], ss[x+1]
            ssr.insert(ssr.index(x2) + 1, x1)

        ssr.remove(s_d)
        print(' '.join( ssr ))

    except:
        break

#  按照逻辑去获取列表，对链表source_list进行为2的跳跃遍历
#  两两成组，后面的数是前面的数的前驱节点，所以把后面的数称为前驱节点
#  前面的数叫cur,要插入的元素，index置是前驱节点的索引+1
while True:
    try:
        source_list = input().split()
        ls = [source_list[1]]  #获取头结点，放到ls
        
        for idx in range(2, len(source_list[2:]), 2): # 两两成组
            cur, ance = source_list[idx], source_list[idx+1]
            index = ls.index(ance) + 1
            ls.insert( index , cur )  # 插入cur,index位置是ance的索引+1
            
        ls.remove(source_list[-1])    # 移除最后不需要的结点
        print(' '.join(ls))
    except:
        break