HJ48 从单向链表中删除指定值的节点的提交代码

java代码采用单向链表完成删除指定值的节点

题目要求

输入一个单向链表和一个节点的值，从单向链表中删除等于该值的节点，删除后如果链表中无节点则返回空指针。
链表的值不能重复。
构造过程，例如输入一行数据为:
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

提交代码

import java.util.Scanner;

public class HJ48 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int size = scanner.nextInt();
        int headvalue = scanner.nextInt();
        ListNode01 listNode01 = new ListNode01();
        listNode01.addNode(headvalue);
        for(int i=0;i<size-1;i++){
            int value1 = scanner.nextInt();
            int value2 = scanner.nextInt();
            ListNode01 currentnode = listNode01.head;
            while (currentnode != null){
                if(currentnode.value == value2){
                    ListNode01 nextnode = currentnode.next;
                    ListNode01 newnode = new ListNode01(value1);
                    currentnode.next = newnode;
                    newnode.next = nextnode;
                }
                currentnode = currentnode.next;
            }
        }
        int tailvalue = scanner.nextInt();
        listNode01.deleteNode(listNode01.head,tailvalue);
        ListNode01 currentnode = listNode01.head;
        while (currentnode != null){
            System.out.printf("%d " ,currentnode.value);
            currentnode = currentnode.next;
        }
    }
}


class ListNode01{

    int value;
    ListNode01 next;
    ListNode01 head;

    public ListNode01(){
    }

    public ListNode01(int value) {
        this.value = value;
    }

    // 添加节点
    public void addNode(int value){
        if(head == null){
            head = new ListNode01(value);
            return;
        }
        ListNode01 temp = head;
        while (temp.next != null){
            temp = temp.next;
        }
        temp.next = new ListNode01(value);
    }
    // 删除节点
    public void deleteNode(ListNode01 head,int targetValue){
    	// 当需要删除的值为头节点
        if(head.value == targetValue){
            ListNode01 nextnode = head.next;
            head.value = nextnode.value;
            head.next = nextnode.next;
        }else{
            ListNode01 prenode = head;
            ListNode01 currentnode = head.next;
            while (currentnode != null){
                ListNode01 nextnode = currentnode.next;
                if(currentnode.value == targetValue){
                	// 判断需要删除的节点是否有下一个节点
                    if(nextnode != null){
                        prenode.next = nextnode;
                    }else{
                        prenode.next = null;
                    }
                }
                prenode = prenode.next;
                currentnode = currentnode.next;
            }
        }
    }
}