一、题目

🔸题目描述

输入一个单向链表和一个节点的值，从单向链表中删除等于该值的节点，删除后如果链表中无节点则返回空指针。
链表的值不能重复。
构造过程，例如输入一行数据为:
6 2 1 2 3 2 5 1 4 5 7 2 2
则第一个参数6表示输入总共6个节点，第二个参数2表示头节点值为2，剩下的2个一组表示第2个节点值后面插入第1个节点值，为以下表示:
1 2 表示为
2->1
链表为2->1

3 2表示为
2->3
链表为2->3->1

5 1表示为
1->5
链表为2->3->1->5

4 5表示为
5->4
链表为2->3->1->5->4

7 2表示为
2->7
链表为2->7->3->1->5->4

最后的链表的顺序为 2 7 3 1 5 4

最后一个参数为2，表示要删掉节点为2的值
删除结点 2
则结果为 7 3 1 5 4

🔸输入输出

输入
输入一行，有以下4个部分：
1 输入链表结点个数
2 输入头结点的值
3 按照格式插入各个结点
4 输入要删除的结点的值

输出
输出一行
输出删除结点后的序列，每个数后都要加空格

🔸样例1

输入
5 2 3 2 4 3 5 2 1 4 3




输出
2 5 4 1

说明：
形成的链表为2->5->3->4->1
删掉节点3，返回的就是2->5->4->1

🔸样例2

输入
6 2 1 2 3 2 5 1 4 5 7 2 2



输出
7 3 1 5 4

二、代码参考

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            int total = sc.nextInt();
            int head = sc.nextInt();
            
            List<Integer> linkedlist = new ArrayList<>();
            
            linkedlist.add(head);
            for (int i = 0; i < total - 1; i ++) {
                int value = sc.nextInt();
                int target = sc.nextInt();
                linkedlist.add(linkedlist.indexOf(target) + 1, value);
            }
            
            int remove = sc.nextInt();
            linkedlist.remove(linkedlist.indexOf(remove));
            for (int i : linkedlist) {
                System.out.print(i + " ");
            }
            System.out.println();
        }
    }        
}


--------------------------------------------------------



class Node():
    def __init__(self, val=None, next=None):
        self.val = val
        self.next = next
    
class LinkedList():
    def __init__(self):
        self.head = Node()
        self.length = 0
        
    def insert(self, val1, val2):
        cur = self.head
        node = Node(val2)
        while cur:
            if cur.val == val1:
                node.next = cur.next
                cur.next = node
                break
            else:
                cur = cur.next
    
    def remove(self, val):
        cur = self.head
        pre = None
        while cur:
            if cur.val == val:
                if not pre:
                    self.head = cur.next
                else:
                    pre.next = cur.next
                break
            else:
                pre = cur
                cur = cur.next
                
    def walk(self):
        cur = self.head
        while cur:
            print(cur.val, end=' ')
            cur = cur.next
        print()
        
while True:
    try:
        nums = list(map(int, input().split()))
        L = LinkedList()
        L.length, L.head.val = nums[0], nums[1]
        lst = nums[2:-1]
        i, j, pairs = 0, 1, []
        while i < len(lst):
            pairs.append((lst[i], lst[j]))
            i += 2
            j += 2
        for p in pairs:
            L.insert(p[1], p[0])
        L.remove(nums[-1])
        L.walk()
    except:
        break



--------------------------------------------------------------


#include <stdio.h>
#include <stdlib.h>
int main(){
    int num=0;
    while(scanf("%d",&num)!=EOF){
        int *a;
        a=(int*)malloc(sizeof(int)*num);
        scanf("%d",&a[0]);
        for(int i=1;i<num;i++){
            int temp,value;
            scanf("%d%d",&value,&temp);
            for(int j=0;j<i;j++){
                if(temp==a[j]){
                    for(int k=i; k>j+1;k--)
                        a[k]=a[k-1];
                    a[j+1]=value;
                }
            }
        }
        int delete;
        scanf("%d",&delete);
        for(int i=0;i<num;i++){
            if(a[i]!=delete)
               printf("%d ",a[i]);
        }
        printf("\n");
        free(a);
    }
    return 0;
}