题解 | #从单向链表中删除指定值的节点#

解题技巧：

• 借助ArrayList的 indexOf方法，可以获取到某个元素的下标位置；
• ArrayList指定在某个位置插入某个元素： list.add(index,element);
• ArrayList指定删除某位置的元素： list.remove(index);

import java.util.*;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        while (sc.hasNext()) {
            int n = sc.nextInt();
            int head = sc.nextInt();

            List<Integer> linkedlist = new ArrayList<>();

            linkedlist.add(head);
            for (int i = 0; i < n - 1; i ++) {
                int next = sc.nextInt();
                int pre = sc.nextInt();
                // 加入到某个节点的下一个位置
                linkedlist.add(linkedlist.indexOf(pre) + 1, next);
            }

            int remove = sc.nextInt();
            // 删除 根据元素下标删除。
            linkedlist.remove(linkedlist.indexOf(remove));
            for (int i : linkedlist) {
                System.out.print(i + " ");
            }
            System.out.println();
        }

        // String str = in.nextLine();
        // String[] strArray = str.split(" ");

        // int length = Integer.parseInt(strArray[0]);
        // int node = Integer.parseInt(strArray[1]);
        // int deleteElement = Integer.parseInt(strArray[strArray.length - 1]);

        // Map<Integer, List<Integer>> map = new HashMap();

        // // 将同一个起点的放入一个list
        // for (int i = 2; i < strArray.length - 1; i++) {
        //     // 第一个是后节点
        //     int value = Integer.parseInt(strArray[i]);
        //     i++;
        //     // 第二个是前节点
        //     int key = Integer.parseInt(strArray[i]);

        //     List<Integer> list = map.get(key) == null ? new ArrayList() : map.get(key);
        //     list.add(value);
        //     map.put(key, list);
        // }

        // // 虚拟头节点
        // ListNode temp = new ListNode(-1);
        // ListNode head = temp;

        // // 构建链表
        // for (Map.Entry<Integer, List<Integer>> entry : map.entrySet()) {
        //     List<Integer> list = entry.getValue();

        //     // 如果是头节点 先加入key
        //     if (entry.getKey() == node) {
        //         head.next = new ListNode(node);
        //         head = head.next;
        //     }
        //     // list中的值为： 3--4--5，5为最后要插入到key节点之后的， 所以逆序插入
        //     for (int i = list.size() - 1; i >= 0; i--) {
        //         head.next = new ListNode(list.get(i));
        //         head = head.next;
        //     }

        // }

        // ListNode res = temp;
        // // 删除操作：
        // if (res.next.val == deleteElement) {
        //     res.next = res.next.next;
        //     res = res.next;
        // } else {
        //     // 删除的不是头节点
        //     while (res != null && res.next != null) {
        //         if (res.next.val == deleteElement) {
        //             res.next = res.next.next;
        //         }
        //         res = res.next;

        //     }
        // }

        // assert temp != null;
        // while (temp.next != null) {
        //     System.out.print(temp.next.val + " ");
        //     temp = temp.next;
        // }
    }
}

/*class ListNode {
    int val;
    ListNode next;

    ListNode() {
    }

    ListNode(int val) {
        this.val = val;
    }

    ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
    }

    int getVal() {
        return val;
    }
}*/