解决一个leetcode中里链表相关问题

public class ListNode {
    int val;
    ListNode next;

    ListNode(int x) {
        val = x;
    }

    /**
     * 将数组数组中的元素转化为链表中的元素
     */
    public ListNode(int[] arr) {

        if (arr == null || arr.length == 0) {
            throw new IllegalArgumentException("error");
        }

        ListNode cur = this;
        cur.val = arr[0];

        for (int i = 1; i < arr.length; i++) {
            cur.next = new ListNode(arr[i]);
            cur = cur.next;
        }
    }

    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        ListNode cur = this;

        while (cur != null) {
            stringBuilder.append(cur.val + "-->");
            cur = cur.next;
        }

        stringBuilder.append("tail");

        return stringBuilder.toString();
    }
}

/**
 * leetcode 203
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 *
 * 删除链表中等于给定值 val 的所有节点。
 *
 * 示例:
 *
 * 输入: 1->2->6->3->4->5->6, val = 6
 * 输出: 1->2->3->4->5
 */
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        /**
         * 不使用虚拟头结点的方法
         * 1 判断第一个节点及其后的节点是否为待删除元素
         *
         * 不考虑内存消耗 可以使用简写
         */

        while (head != null && head.val == val) {
            ListNode delNode = head;
            head = delNode.next;
            delNode.next = null;

//            head = head.next;
        }
        //依次遍历 若每个节点都是要删除的元素 此时head=null 可直接返回

        if (head == null) {
            return null;
        }

        //若head的下一个节点不是待删除的元素 需要对后面的节点遍历找出要删除的元素

        ListNode preNode = head;
        while (preNode.next != null) {
            if (preNode.next.val == val) {
                ListNode delNode = preNode.next;
                preNode.next = delNode.next;
                delNode.next = null;

//                preNode.next = preNode.next.next;
            } else {
                preNode = preNode.next;
            }
        }

        return head;
    }

    public static void main(String[] args) {
        int[] a = {2, 2, 3, 4, 2, 3, 2};
        ListNode listNode = new ListNode(a);

        System.out.println(listNode);
        ListNode listNode1 = new Solution().removeElements(listNode, 2);
        System.out.println(listNode1);

//        ListNode curNode = listNode;
//
//        while (curNode != null) {
//            System.out.println(curNode.val);
//            curNode = curNode.next;
//        }

    }
}

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 *
 * 删除链表中等于给定值 val 的所有节点。
 *
 * 示例:
 *
 * 输入: 1->2->6->3->4->5->6, val = 6
 * 输出: 1->2->3->4->5
 */
class Solution2 {
    public ListNode removeElements(ListNode head, int val) {
        /**
         * 使用虚拟头结点的方法
         * 作用:统一头结点和其他节点 简化逻辑
         * 1 创建虚拟头结点
         */

        ListNode dummyNode = new ListNode(0);
        dummyNode.next = head;

        ListNode preNode = dummyNode;
        while (preNode.next != null) {
            if (preNode.next.val == val) {
//                ListNode delNode = preNode.next;
//                preNode.next = delNode.next;
//                delNode.next = null;
                preNode.next = preNode.next.next;
            } else {
                preNode = preNode.next;
            }
        }

        /**
         * 为什么这里不是 return head
         * 如果head节点是一个待删除的节点,那么一旦删除head将不再
         * 存在 而dummyNode.next永远指向新的head节点
         */
        return dummyNode.next;
    }
}