删除链表中等于给定值 val 的所有节点--Java版

示例:

输入: 1->2->6->3->4->5->6, val = 6
输出: 1->2->3->4->5
方法一：暴力求解

思路： 最容易想到的是遍历链表，将数据域为val的节点删除。但是，单链表一涉及删除，那么就得找到待删除节点的前驱节点，然而第一个节点没有前驱节点，当val恰为第一个节点的数据域时，这时就要做出不同的操作。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        //给定值恰好为头节点，一个if就行的事，为什么用while循环？
        //假设，前几个节点的数据域为val，或者整个链表节点的数据域为val时，这时就会用到while循环了
        while (head != null && head.val == val) {
            head = head.next;
        }
        /*
        此时有两种情况
            1：前几个节点的数据域为val，删除了指定节点后，留下了待删除节点均有前驱节点的链表
                例如： 1->1->1->2->6->3->4->1->6, val = 1--->  2->6->3->4->1->6
            2：整个链表的数据域为val，被删除完毕
        */
        if (head == null) {//处理第2种情况
            return null;
        }
        //处理第1种情况
        ListNode prev = head;//前驱节点
        //while循环的出口初学者不好确定，记住谁待删除，就找谁
        while (prev.next != null){
            if (prev.next.val == val) {
                prev.next = prev.next.next;
            }else{
                prev = prev.next;
            }
        }
        return head;
    }
}

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37

方法二：虚拟头节点

思路： 既然知道删除没有头节点的节点需要用别的方法，那么创建一个虚拟头节点，使所有节点都有头节点，就可以用同一种方法解决了。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        //创建一个虚拟头节点，数据域象征性给-1
        ListNode dummyHead = new ListNode(-1);
        dummyHead.next = head;
        //此时链表中所有节点都有前驱节点
        ListNode prev = dummyHead;
        while (prev.next != null) {
            if (prev.next.val == val) {
                prev.next = prev.next.next;
            } else {
                prev = prev.next;
            }
        }
        return dummyHead.next;
    }
}

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25

方法三：递归

思路： 将一个链表看为head，和head.next两部分，先删除head.next链表中等于给定值 val 的所有节点后，在判断head节点是否要被删除。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode removeElements(ListNode head, int val) {
       //head要找到head.next则head必须不为空，所有先排除head为空的情况
       if (head == null) {
           return null;
       }
        head.next = removeElements(head.next,val);
        return head.val == val?head.next:head;
    }
}
---------------------
作者：迷路的小绅士
来源：CSDN
原文：https://blog.csdn.net/weixin_40995778/article/details/90208235
版权声明：本文为博主原创文章，转载请附上博文链接！