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

import java.util.ArrayList;
import java.util.Scanner;

// 老八秘制小汉堡代码
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            String s1 = scanner.nextLine();
            String[] split = s1.split(" ");
            String head = split[1];//头节点
            String del = split[(split.length-1)];//输入要删除的结点的值
            String copy[]=new String[split.length-3];
            System.arraycopy(split,2,copy,0,split.length-3);
            ArrayList<String> groupby = new ArrayList<>();//新建集合存放对应组
            for (int i = 0; i <copy.length; i+=2) {
                String s2 = copy[i];
                String s3 = copy[i+1];
                String s4 = s2+" "+s3;
                groupby.add(s4);
            }
            //新建空链表，
            SingleLinkList sLt = new SingleLinkList();
            sLt.insert(Integer.valueOf(head));//新建链表，存放head与next，初始头下标为1
            for (int i = 0; i <groupby.size(); i++) {
                String[] split1 = groupby.get(i).split(" ");
                String h = split1[1];//取出组中的头
                Integer hh = Integer.valueOf(h);
                int index = sLt.getByData(hh);//查找头data对应的位置index
//                System.out.println(index);//这里的下标不同于数组的下标，这里的下标为几，指的就是 这个数后面的个数+1
                String d = split1[0];;//取出组中的尾
                Integer dd = Integer.valueOf(d);
                sLt.insertByIndex(index,dd);//根据上一个的下标，插入组中的尾
            }
            Integer dell = Integer.valueOf(del);//
            int delll = sLt.getByData(dell);//查找删除对象的下标
            sLt.deleteByIndex(delll);
            ArrayList<Integer> traverse = sLt.traverse();
            String success="";
            for (int i = traverse.size()-1; i >=0 ; i--) {
                success=success+traverse.get(i)+" ";
            }
            System.out.println(success);
        }
    }
}
class LinkListNode {
    private Integer data; // 结点的数据域

    private LinkListNode next; // 下一个结点

    public LinkListNode(){
    }

    public LinkListNode(Integer data){
        this.data = data;
        this.next = null;
    }
    public LinkListNode(Integer data,LinkListNode next){
        this.data = data;
        this.next = next;
    }

    public Integer getData() {
        return data;
    }

    public void setData(Integer data) {
        this.data = data;
    }

    public LinkListNode getNext() {
        return next;
    }

    public void setNext(LinkListNode next) {
        this.next = next;
    }
}

class SingleLinkList {

    private LinkListNode head;//定义单链表的头结点

    private int length;//用来记录单链表的长度

    /**
     * 单链表的初始化 init() 无参
     */
    public SingleLinkList(){
        this.head = new LinkListNode();
    }

    /**
     * 单链表的初始化 init() 有参
     * */
    public SingleLinkList(Integer data,LinkListNode next){
        this.head = new LinkListNode();
        LinkListNode node = new LinkListNode();
        node.setData(data);
        node.setNext(next);
        head.setNext(node);
    }

    /**
     * 求单链表长度
     */
    public int getLength(){
        return length;
    }

    /**
     * 新增：默认在最后插入一个数据元素；
     */
    public LinkListNode insert(Integer data){
        LinkListNode newNode = new LinkListNode(data);
        LinkListNode p = head;
        while (p.getNext()!=null){
            p = p.getNext();
        }
        p.setNext(newNode);
        length++;
        return newNode;
    }

    /**
     * 新增：在位置i插入一个数据元素；
     */
    public void insertByIndex(int index,Integer data){
        // 如果位置i大于了单链表的长度 或者 位置不合理 则直接将新结点添加到最后
        if(index>length||index-1<0){
            insert(data);
            return;
        }
        index--;
        // 将指针p指向首元结点
        LinkListNode p = head;//head首元节点永远是链表中的末尾最后一个
        while (index!=0){
            p=p.getNext();
            index--;
        }
        LinkListNode newNode = new LinkListNode(data,p.getNext());
        p.setNext(newNode);
        length++;
    }

    /**
     * 查找：按位置查找
     */
    public Integer getByIndex(int index){
        // 如果查找的元素大于了单链表的长度则返回null
        if(index>length){
            return null;
        }
        // 将指针p指向头结点
        LinkListNode p = head;
        while (index!=0){
            p=p.getNext();
            index--;
        }
        return p.getData();
    }

    /**
     * 查找：按值查找
     */
    public int getByData(Integer data){
        // 将指针p指向首元结点
        LinkListNode p = head;
        int index = 0;
        while (p.getNext()!=null){
            p=p.getNext();
            index++;
            if(p.getData().equals(data)){
                return index;
            }
        }
        if(index==length&&!p.getData().equals(data)){
            return 0;
        }
        return index;
    }

    /**
     * 查找：遍历单链表
     */
    public ArrayList<Integer> traverse(){
        LinkListNode p = head;
        ArrayList<Integer> it = new ArrayList<>();
        while (p.getNext()!=null){
            p = p.getNext();
            it.add(p.getData());
        }
        return it;
    }

    /**
     * 删除：按位置i删除数据元素；
     */
    public Integer deleteByIndex(int index){
        // 如果位置i大于了单链表的长度则返回null
        if(index>length||index-1<0){
            return null;
        }
        // 提前将index-- 是为了将p指针移到被删除元素的前一个位置
        index--;
        // 将指针p指向头结点
        LinkListNode p = head;
        while (index!=0){
            p=p.getNext();
            index--;
        }
        int res = p.getNext().getData();
        p.setNext(p.getNext().getNext());
        length--;
        return res;
    }

    /**
     * 合并链表
     */
    public void marge(SingleLinkList singleLinkList){
        LinkListNode p = head;
        length=length+singleLinkList.length;
        while (p.getNext()!=null){
            p = p.getNext();
        }
        p.setNext(singleLinkList.head.getNext());
    }
}