剑指 18 删除链表的节点

剑指 18 删除链表的节点

原题目

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

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

示例 1:

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

---

考查知识点

链表的顺序访问，虚拟头结点，双指针法

---

自己的第一遍解法

第一想法没什么亮点，既然给定了头结点，就沿着头结点顺序查找，找到要删除节点的前一个节点，修改该节点让它指向要删除节点的下一个节点。

这里主要就是对头结点的处理，因为头结点没有前一个节点，在处理的时候要单独考虑。使用虚拟头结点可以将头结点与非头结点进行相同的操作。

节点的定义如下：

//Definition for singly-linked list.
struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(nullptr) {}
};

使用虚拟头结点virhead指向原来的头结点，代码如下：

//虚拟头结点，顺序查找
class Solution {
public:
    ListNode* deleteNode(ListNode* head, int val) {
        if (head == nullptr)    return nullptr;

        ListNode virHead(-1);       //虚拟头结点，指向原头结点
        virHead.next = head;
        ListNode *curNode = &virHead;

        while (curNode->next != nullptr)
        {
            if (curNode->next->val == val)
                curNode->next = curNode->next->next;
            else
                curNode = curNode->next;
        }

        return virHead.next;
    }
};

注意这里创建虚拟头结点virHead时，如果使用new来动态创建，最后还要return虚拟头结点指向的当前头结点，因此不能使用delete virHead，因此不能及时释放内存引起内存泄漏。

---

好的解法

这里上一个力扣上比较简洁的程序，思路一样，就是对头结点的处理单独列出来

//力扣优化顺序查找
class Solution_02 {
public:
    ListNode* deleteNode(ListNode* head, int val) {
        //不使用虚体头结点，单独考虑删除头节点的情况
        if (!head)  return nullptr;

        if (head->val == val)   return head->next;

        ListNode *cur = head;
        while (cur->next)
        {
            if (cur->next->val == val)
            {
                cur->next = cur->next->next;
                return head;
            }
            cur = cur->next;
        }

        return nullptr;
    }
};

双指针法

一般数组或链表题目都可以使用双指针法，这道题使用双指针法时间要比顺序查找快一些，下面是代码：

//力扣双指针顺序查找
//fast最终指向要删除的节点
//slow最终指向要删除的节点的前一个节点
class Solution_03 {
public:
    ListNode* deleteNode(ListNode* head, int val) {
        if(head == nullptr){
            return head;
        }
        bool flag = false;
        ListNode *cur = new ListNode(-1);	//最后没有释放，引起内存泄露
        cur->next = head;
        ListNode *fast = cur->next;
        ListNode *slow = cur;
        while(fast){
            if(fast->val == val){
                flag = true;
                break;
            }
            slow = slow->next;
            fast = fast->next;
        }
        if(flag){
            slow->next = fast->next;
        }else{
            return head;
        }
        return cur->next;
    }
};

---

剑指原题

力扣的题目是修改的，给定的是头指针与一个要删除的节点的值，因为是顺序查找，时间复杂度为O(n)。剑指书中给出的原题是给定头指针与一个节点指针，并且没有返回头结点的要求。如果给定要删除的节点指针，这道题的时间效率还能提升到O(1)。

主要思想就是已有要删除的节点toDelete，那么就直接使toDelete的下一个节点的值覆盖掉toDelete节点的值，并且让toDelete节点指向下个节点的下个节点，这样在覆盖的时候就相当于将下一个节点复制到toDelete的内存位置，删掉了toDelete的原本数据。

这种思路就必须考虑toDelete在链表两端的情况，代码如下：

class Solution_04{
public:
    void deleteNode(ListNode *head, ListNode *toDelete)
    {
        if (!head || !toDelete)   return;
        
        //要删除的不是尾节点
        if (toDelete->next != nullptr)
        {
            ListNode *nextNode = toDelete->next;        //要删除节点的下一节点
            toDelete->val = nextNode->val;              //下一节点的值覆盖要删除的节点
            toDelete->next = toDelete->next->next;      //链表上的删除
            
            delete nextNode;        //释放删除节点占用的内存
            nextNode = nullptr;     //将指向原删除节点的指针置为空指针，避免野指针；
        }
        //链表只有一个节点
        else if (head == toDelete)
        {
            delete toDelete;
            toDelete = nullptr;
            head = nullptr;
        }
        //链表有多个节点，删除尾节点
        else
        {
            ListNode *cur = head;
            while (cur->next != toDelete)
                cur = cur->next;
            
            cur->next = nullptr;
            delete toDelete;
            toDelete = nullptr;
        }
    }

};

这里注意要想删除一个指针，除了用delete释放内存以后，还要将它置为空指针，否则delete以后的指针会变成野指针，在下一次使用new开辟新的动态空间时，该野指针与新指针都会指向新开辟的内存空间，这是非常可怕的事情。

delete以后不nullptr的情况，在这里说的很详细 C++指针delete后还要置为null