18. 删除链表的节点

剑指offer 18 删除链表的节点

LCR 136. 删除链表的节点

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

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

注意：此题对比原题有改动

示例 1:

输入: head = [4,5,1,9], val = 5
输出: [4,1,9]
解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.

示例 2:

输入: head = [4,5,1,9], val = 1
输出: [4,5,9]
解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.

说明：

• 题目保证链表中节点的值互不相同
• 若使用 C 或 C++ 语言，你不需要 free 或 delete 被删除的节点

解题思路

由于头节点也是有可能被删除的，所以应该建立一个虚拟头节点dummy用于辅助删除头节点的操作，同时用双指针方法的话，设立dummy可以将操作统一。

Java代码

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode deleteNode(ListNode head, int val) {
        if(head == null) return null;
        ListNode dummy = new ListNode(0);//建立虚拟的头节点
        dummy.next = head;
        ListNode pre = dummy;//pre指向要删除节点的前一节点，用于改变pre.next的指向，从而删除节点
        ListNode cur = head;//cur指向当前要进行判断是否要删除的节点
        while(cur != null){
            if(cur.val == val){//当前节点是要删除的节点，则让pre.next指向cur.next即可
                pre.next = cur.next;
                break;//已经删除了节点，可以退出循环了
            }
            pre = pre.next;//当前节点不是要删除的节点，让pre和cur都往后移一个节点
            cur = cur.next;
        }
        return dummy.next;
    }
}

Go代码

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func deleteNode(head *ListNode, val int) *ListNode {
    // 对于单链表的删除，我们需要找到待删除节点的前一节点
    // 为了让头节点能统一操作，所以建立虚拟头结点
    
    // 注意这里不像上面Java代码一样用了两个指针，因为一个指针就够了
    if head == nil {
        return nil
    }
    dummy := &ListNode{}
    dummy.Next = head
    cur := dummy
    for cur != nil && cur.Next != nil  {
        if cur.Next.Val == val {
            cur.Next = cur.Next.Next
            break
        }
        cur = cur.Next   
    }
    return dummy.Next
}

---

扩展题1：LeetCode 237 删除链表中的节点的变形题

237. 删除链表中的节点

237. 删除链表中的节点

请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点。传入函数的唯一参数为 要被删除的节点 。

现有一个链表 – head = [4,5,1,9]，它可以表示为:

示例 1：

输入： head = [4,5,1,9], node = 5
输出：[4,1,9]
解释： 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.

示例 2：

输入： head = [4,5,1,9], node = 1
输出：[4,5,9]
解释： 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.

提示：

• 链表至少包含两个节点。
• 链表中所有节点的值都是唯一的。
• 给定的节点为非末尾节点并且一定是链表中的一个有效节点。
• 不要从你的函数中返回任何结果。

解题思路

本题其实就是另一种删除链表节点的思路，即我们知道，链表中要删除某个节点的时候，不能通过自己删除自己，而是需要他的前一个节点的next指针改变指向从而删除节点。但是换个思考方式，我们将要删除的节点改成和他的下一个节点一样，然后删除他的下一个节点，这和删除他本身效果是一样的。

1. 如果该节点不是尾节点，那么可以直接将下一个节点的值赋给该节点，然后令该节点指向下下个节点，再删除下一个节点，时间复杂度为 $O(1)$。

2. 如果该节点是尾节点，就需要先遍历链表，找到节点的前一个节点，然后让前一个节点指向 null，时间复杂度为 $O(N)$。
   

综上，如果进行 $N$ 次操作，那么大约需要操作节点的次数为 $N-1+N=2N-1$，其中 $N-1$ 表示 $N-1$ 个不是尾节点的每个节点以 $O(1)$ 的时间复杂度操作节点的总次数，$N$ 表示 $1$ 个尾节点以 $O(N)$ 的时间复杂度操作节点的总次数。$\frac{2N-1}{N}\approx 2$，因此该算法的平均时间复杂度为 $O(1)$。

Java代码

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public void deleteNode(ListNode node) {
        /*直接将要删除结点的下一结点的值复制给要删除结点，然后删除下一结点
        这就相当于删除了要删除的结点，时间是O(1)，但如果要删除尾结点，则需要从头遍历，
        或者要删除的是头节点，则可以head = head.next，但本题要求较少，
        不用考虑要删除的节点是尾节点的情况*/
        node.val = node.next.val;
        node.next = node.next.next;
    }
}

Go 代码

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func deleteNode(node *ListNode) {
    //题目给定的节点为非末尾节点并且一定是链表中的一个有效节点
    //且链表中所有节点的值都是唯一的。
    //故我们完全可以让将要删除的节点复制为他的下一个结点，然后将它的下一个结点删除，
    //这就和删除了指定的节点是一个效果
    node.Val = node.Next.Val
    temp := node.Next // 记录下要移除的节点
    node.Next = node.Next.Next
    temp.Next = nil // 要移除的节点的Next不应该再指向链表中任何节点
}

这里也附上要考虑删除的是头节点或者是尾结点的代码

public ListNode deleteNode(ListNode head, ListNode tobeDelete) {
    if (head == null || tobeDelete == null)
        return head;
    if (tobeDelete.next != null) {
        // 要删除的节点不是尾节点
        tobeDelete.val = tobeDelete.next.val;
        tobeDelete.next = tobeDelete.next.next;
    } else {
        if (head == tobeDelete)
             // 要删除的是头节点
            head = head.next;
        else {//要删除的是尾结点
            ListNode cur = head;
            while (cur.next != tobeDelete)
                cur = cur.next;
            cur.next = null;
        }
    }
    return head;
}

---

扩展题2：LeetCode 83 删除排序链表中的重复元素I

83. 删除排序链表中的重复元素

83. 删除排序链表中的重复元素

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

示例 1:

输入: 1->1->2
输出: 1->2

示例 2:

输入: 1->1->2->3->3
输出: 1->2->3

解题思路

链表中的元素已经是排序的，故从头至尾遍历即可。后一个元素和前一个元素相同则删除，删除方式和上面几题一样，这里的head肯定是不需要删除的，故不需要建立虚拟头节点dummy。

Java代码

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
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;//后一个结点的值与前一结点的值不相等，更新cur，即cur后移
        }
         return head;
    }   
}

Go代码

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func deleteDuplicates(head *ListNode) *ListNode {
    // 和数组删除重复元素思路一样，因为已经排序过了，所以当前节点和前一节点相等则可删除
    if head  == nil {
        return nil
    }
    cur := head 
    for cur != nil {
        if  cur.Next != nil && cur.Val == cur.Next.Val   {
            cur.Next = cur.Next.Next
        } else {
            cur = cur.Next //后一个结点的值与前一结点的值不相等，更新cur，即cur后移
        }
    }
    return head
}

---

扩展题3：LeetCode 82 删除排序链表中的重复元素II

82. 删除排序链表中的重复元素 II

82. 删除排序链表中的重复元素 II

给定一个排序链表，删除所有含有重复数字的节点，只保留原始链表中 没有重复出现 的数字。

示例 1:

输入: 1->2->3->3->4->4->5
输出: 1->2->5

示例 2:

输入: 1->1->1->2->3
输出: 2->3

解题思路

由于头结点也可能是重复的会被删除，所以建立虚拟结点dummy，使得操作统一。我们要把当前为某个值的前一结点pre记录下来，和后面值比当前结点的值大的结点相连。

Java代码

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if(head == null || head.next == null) return head;
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode pre = dummy;
        //由于要用到pre.next.val所以要判断pre.next!=null
        while(pre != null && pre.next != null){
            ListNode cur = pre.next;
            //让cur指向第一个值不为pre.next.val的结点
            while(cur != null && pre.next.val == cur.val) cur = cur.next;
            //如果cur只跨越了一个结点，说明cur跨越的该段不重复，那么就不用删除，移动pre即可
            if(pre.next.next == cur) pre = pre.next;
            else{//cur跨越了多个结点，目前指向了第一个值不为pre.next.val的结点
                //故直接让pre.next = cur,相当于删除了cur跨越的重复的那段
                pre.next = cur;
            }
        }
        return dummy.next;//返回dummy.next
    }
}

Go代码

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func deleteDuplicates(head *ListNode) *ListNode {
    /*由于头结点也可能是重复的会被删除，所以建立虚拟结点dummy，使得操作统一
    我们要把当前为某个值的前一结点preNode记录下来，和后面值比当前结点的值大的结点相连*/
    if head == nil {
        return nil
    }
    dummy := &ListNode{}
    dummy.Next = head
    preNode := dummy

    //由于要用到p.next.val所以要判断p.next!=nil
    for preNode.Next != nil{
        cur := preNode.Next
        n := 0 // 记录跨越了几个节点
        //让cur指向第一个值不为preNode.Next.Val的结点
        for cur != nil && preNode.Next.Val == cur.Val {
            cur = cur.Next
            n++
        }

         //如果curNode只跨越了一个结点，说明curNode跨越的该段不重复，
        //那么就不用删除，移动preNode即可
        if n == 1 {
            preNode = preNode.Next
        } else {//curNode跨越了多个结点，目前指向了第一个值不为preNode.next.val的结点
            //故直接让preNode.next = curNode,相当于删除了curNode跨越的重复的那段
            preNode.Next = cur
        }
    }
    
    return dummy.Next
}

​