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

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

描述

输入一个单向链表和一个节点的值，从单向链表中删除等于该值的节点，删除后如果链表中无节点则返回空指针。

链表的值不能重复。

构造过程，例如输入一行数据为:
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

数据范围：链表长度满足 1≤n≤1000 1≤n≤1000 ，节点中的值满足 0≤val≤10000 0≤val≤10000

测试用例保证输入合法

输入描述：

输入一行，有以下 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

题解

ArrayList

import java.util.Scanner;

import java.util.ArrayList;
import java.util.List;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextInt()) { // 注意 while 处理多个 case
            //1 输入链表结点个数
            //2 输入头结点的值
            //3 按照格式插入各个结点
            //4 输入要删除的结点的值
            int n = in.nextInt();
            int head = in.nextInt();
            // 按照格式插入各个结点
            List<Integer> list = new ArrayList<>();
            list.add(head);
            for (int i = 0; i < n - 1; i++) {
                // 接收 值 value
                int value = in.nextInt();
                // 接收 target
                int targert = in.nextInt();
                // 添加到 list 集合
                list.add(list.indexOf(targert) + 1, value);
            }
            // 要删除的节点值
            int key = in.nextInt();
            list.remove(list.indexOf(key));
            // 遍历输出
            for (int i = 0; i < n - 1; i++) {
                System.out.print(list.get(i) + " ");
            }
            System.out.println();
        }
    }
}

链表

import java.util.Scanner;
public class Main {
    public static void main(String[] arggs) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            String[] str = sc.nextLine().split(" ");
            int n = Integer.parseInt(str[0]);// 节点个数
            int headInt = Integer.parseInt(str[1]);
            // 初始化链表
            ListNode head = new ListNode(headInt);
            for (int i = 1; i < n; i++) {
                // 把 a 插入到 b后面
                int a = Integer.parseInt(str[2 * i ]);
                int b = Integer.parseInt(str[2 * i + 1]);
                // 遍历链表 寻找到要插入的位置
                ListNode tmp = head;
                while (tmp.key != b) {
                    tmp = tmp.next;
                }
                // 插入
                ListNode nodeA = new ListNode(a);
                nodeA.next = tmp.next;
                tmp.next = nodeA;
            }

            // 删除节点
            // 要删除的节点值
            int delete = Integer.parseInt(str[2 * n]);
            StringBuilder sb = new StringBuilder();
            // 遍历链表
            ListNode temp = head;
            while (temp != null) {
                if (temp.key != delete) {
                    sb.append(temp.key).append(" ");
                }
                temp = temp.next;
            }
            System.out.println(sb.toString());
        }
    }
}
class ListNode {
    int key;
    ListNode next;
    ListNode(int val) {
        this.key = val;
        next = null;
    }
}