删除链表中的节点_237_83_82_203

LeetCode_237：删除链表中的节点：https://leetcode-cn.com/problems/delete-node-in-a-linked-list/

请编写一个函数，用于删除单链表中某个特定节点 。在设计函数时需要注意，你无法访问链表的头节点 head ，只能直接访问要被删除的节点 。

题目数据保证需要删除的节点不是末尾节点 。

/*
解题思路：
    要删除链表中某个节点p：
    1.如果知道该节点的前驱节点s，则直接s.next = s.next.next即可。
    2.如果不知道该节点的前驱，可以通过值的覆盖实现，
        让 p.val = p.next.val，然后删除p.next，
        然后 p.next = p.next.next
*/        
 
class Solution {
    public void deleteNode(ListNode node) {
        node.val = node.next.val;
        node.next = node.next.next;
    }
}

剑指 Offer 18. 删除链表的节点: https://leetcode-cn.com/problems/shan-chu-lian-biao-de-jie-dian-lcof/

 给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。【val唯一】

返回删除后的链表的头节点。

/*
解题思路：
    首先，对head进行初始化判断。
    1.然后，判断head值是否为val
        1.1 如果是，则直接返回head.next
        1.2 如果不是，则进行下一步
    2.循环判断head.next值是否为val，
        2.1 循环终止条件为head.next 不为空。
        2.2 当head.next == val 时
            2.2.1 删除head.next，将head.next置空
        2.3当head.next != val 时
            head = head.next;
    3.最后返回head即可。
*/
class Solution {
    public ListNode deleteNode(ListNode head, int val) {
        if(head == null) return null;
        if(head.val == val){
            return head.next;
        }
        ListNode cur = head;
        while(cur.next != null) {
          if(cur.next.val == val){
              ListNode deleteNode = cur.next;
              cur.next = deleteNode.next;
              deleteNode.next = null;
              // cur.next = cur.next.next;
               break;
          } else{
              cur = cur.next;
          }
        }
        return head;
    }
}

 LeetCode_83. 删除排序链表中的重复元素：https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list/

给定一个已排序的链表的头 head，删除所有重复的元素，使每个元素只出现一次。返回已排序的链表。

/*
初始化判断链表head，当head==null || head.next == null 时 return head;
1.定义工作指针cur,指向head
2.循环判断cur.val和cur.next.val是否相等
    2.1 相等，则直接将cur.next = cur.next.next 
    2.2 不等，则cur = cur.next;
3.循环的终止条件是：cur!=null && cur.next!=null 
4.return head    
*/

class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if(head == null || head.next == null) {
            return head;
        }
        ListNode cur = head;
        while (cur != null && cur.next != null) {
            if(cur.val == cur.next.val){
                cur.next = cur.next.next;
            } else {
                cur = cur.next;
            }
        }
        return head;
    }
}

82. 删除排序链表中的重复元素II：https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list-ii/

给定一个已排序的链表的头 head，删除原始链表中所有重复数字的节点，只留下不同的数字。返回 已排序的链表 。

/*    
解题思路：
初始化判断链表head，当head==null || head.next == null 时 return head;
1.定义工作指针cur，指向head。
2.定义虚拟头结点dummy，以及工作指针prev
3.循环判断prev.next.val 和 cur.next.val是否相等 
    3.1 当值不相等时，prev和cur都向后走一步
    3.2 当值相等时，就不断的移动cur，直到当前prev.next.val和cur.next.val值不等
          1.注意这里的循环条件时：
            while(cur!=null && cur.next != null && prev.next.val == cur.next.val)
          2.退出内部循环后，更新prev 和 cur的值。
                prev.next = cur.next;
                cur = cur.next;
4.最后返回dummy.next即可。
*/

class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if(head == null || head.next == null) {
            return head;
        }
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode prev = dummy;
        ListNode cur = head;
        while(cur != null && cur.next != null) {
            if (prev.next.val != cur.next.val) {
                prev = prev.next;
                cur = cur.next;
            } else {
                while(cur!=null && cur.next!= null && prev.next.val == cur.next.val)
                    cur = cur.next;
                prev.next = cur.next;
                cur = cur.next;
            }
        }
        return dummy.next;
    }
}

203. 移除链表元素：https://leetcode-cn.com/problems/remove-linked-list-elements/

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

/*
解题思路：
    1.借助虚拟头结点dummy判断，工作指针prev
        1.循环判断prev.next.val == val 
            1.1相等，则prev.next = prev.next.next;
            1.2不等，则prev = prev.next 
        2.循环条件为prev.next != null 
        3.最后然后dummy.next即可 
        
    2.不借助头结点 
        1.首先对head进行初始化判断 head == null return head;
        2.然后判断head.val值是否为给定的val
            2.1 相等，则head=head.next ，继续判断while(head!=null)
        3.然后判断此时的head是否为null
        4.继续循环判断head.next.val跟val是否相等
            4.1相等，则删除head.next 
            4.2不等，则head = head 
        5.返回head即可
*/

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        if(head == null) {
            return head;
        }
        while(head != null && head.val == val){
            head = head.next;
        }
        if(head == null) return head;
        ListNode prev = head;
        while(prev.next != null) {
            if(prev.next.val == val){
                prev.next = prev.next.next;
            } else{
                prev = prev.next;
            }
        }
        return head;
    }
}

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        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;
    }
}