18 删除链表的节点/重复节点

Posted 2021-02-11 guoxinxin

题目描述： 

题目一：在O(1)时间内删除链表节点 ：在给定的单向链表的头指针和一个节点指针，定义一个函数在O(1)时间内删除该节点。

//链表定义
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
        val(x), next(NULL) {
    }
};

 注意：输入提供了要删除节点的指针！！

测试用例：　

 1）功能测试（从有多个节点的链表中删除中间、头、尾节点；从只有一个节点的链表中删除唯一的节点）

 2）特殊输入测试（头指针为nullptr；指向要删除的节点的指针为nullptr）

 

解题思路：

1）常规做法： 平均时间复杂度为O(n)   面试时不建议使用   

 遍历到要删除节点的前一个节点pre，将要删除节点的下一个节点赋值给前一个节点。pre->next = pCurrent->next;

2）不访问当前节点的前一个节点：

因为要删除节点的指针知晓，则其下一个节点是可以访问的。将下一个节点的值（val和next）赋值给当前节点，然后删除下一个节点即可。

 pCurrent->val = pNext->val;

 pCurrent->next = pNext->next;

delete pNext;

pNext = nullptr;

 

题目描述： 

题目二：删除链表中重复的节点

在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5

注：虽然题目示例给的重复节点的个数都是2，但是题目中并没有明确指出。因此要考虑重复节点为多个的情况。如1->2->3->3->3->4处理后应该是1->2->4

 

测试用例：

1）功能测试（重复节点位于链表的头部、中间、尾部；链表中没有重复的节点）

2）特殊输入测试（指向链表头节点的指针为nullptr；链表中所有节点都是重复的）

 

解题思路：

1）由于链表是排序的，只要考虑相邻元素值是否相等，相等即重复。

如果当前节点与下一个节点值相同，他们是重复的节点，需要被删除。为了保证删除之后链表仍然是相连的，我们要把当前节点的前一个节点（因此要定义pPreNode）与后面值比当前节点值大的节点相连。 

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
        val(x), next(NULL) {
    }
};
*/
class Solution {
public:
    ListNode* deleteDuplication(ListNode* pHead)
    {
        //链表为空时
        if(pHead==nullptr)return pHead;
        
        ListNode* pPreNode = nullptr; //先初始为空
        ListNode* pCurrentNode = pHead;//指向第一个节点
        ListNode* pNext = nullptr;
        while(pCurrentNode!=nullptr){ //pCurrentNode->next!=nullptr
           // ListNode* pNext = pCurrentNode->next;  //pNext可能为空  //不要放到循环里面定义，每次循环都会定义
            pNext = pCurrentNode->next;  //pNext可能为空
            if(pNext!=nullptr && pCurrentNode->val==pNext->val){  //pNext不为空时，才可以访问其val值，即pNext->val存在
                //有重复节点
                //删除重复节点
                int value = pCurrentNode->val;
                ListNode* pNodeToDel = pCurrentNode;
                while(pNodeToDel!=nullptr && pNodeToDel->val==value){  //循环，以遍历多个连续的重复值
                    pNext = pNodeToDel->next;   // pNodeToDel会被删除，要记录一下它的下一个节点，否则之后就访问不到了 
                    delete pNodeToDel;
                    pNodeToDel = nullptr;
                    pNodeToDel = pNext; //移动到下一个节点
                }
                //重新连接链表
                if(pPreNode == nullptr){ //说明时头节点
                    pHead = pNext;
                }else{ //非头节点
                    pPreNode->next = pNext; //not pPreNode = pNext; 由于写错，总报段错误！！！ 不能把pPreNode直接指向pNext
                }
                pCurrentNode = pNext; //别忘了也要更新 pCurrentNode
            }else{
                //没有重复节点
                pPreNode = pCurrentNode;
                //pCurrentNode = pNext;
                pCurrentNode = pCurrentNode->next;
            }   //无论是否删除节点，每一次都要更新pPreNode与pCurrentNode,pNext会在每次循环初被更新
        }
        
        return pHead;
    }
};　　

 注意：

[1] delete指针后一定先将指针置空。因为不确定后面是否会在使用指针（会赋值），如果不置空，使用未定义的指针是十分危险的行为。

[2] 要区分删除的节点是否是头节点：line36和line38。因为连接的操作是不同的

2）为了统一删除节点后，头节点与其他节点的连接关系。创建一个新的指针指向头指针。

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
        val(x), next(NULL) {
    }
};
*/
class Solution {
public:
    ListNode* deleteDuplication(ListNode* pHead)
    {
        
        if(pHead==nullptr || pHead->next==nullptr) return pHead;
           
        ListNode* newpHead =new ListNode(-1);
        newpHead->next = pHead;
           
        ListNode* pPreNode = newpHead; 
        ListNode* pNode = pHead; 
        ListNode* pNext = nullptr; 
           
        while(pNode!=nullptr){
            pNext = pNode->next;
            if(pNext!=nullptr && pNode->val==pNext->val){
                //有重复节点
                ListNode* pToDel = pNode;
                int value = pNode->val;
                while(pToDel!=nullptr && pToDel->val==value){
                    pNext =  pToDel->next;
                    delete  pToDel;
                    pToDel = nullptr;
                    pToDel = pNext;
                }
                pPreNode->next = pNext;
                pNode = pNext; //勿忘 
            }else{
                //没有重复节点
                pPreNode = pNode;
                pNode = pNext;
            }
        }
        return newpHead->next;

    }
};

3）使用递归方法：

当头节点重复时，直接移动头节点到第一个不重复的节点。头节点不重复时，移动到下一个节点，剩余部分递归调用。这样链表可以只处理头节点重复的情况。

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
        val(x), next(NULL) {
    }
};
*/
class Solution {
public:
    ListNode* deleteDuplication(ListNode* pHead)
    {
        //递归的终止条件
        if(pHead==nullptr || pHead->next==nullptr) return pHead;
        

        ListNode* pNode = nullptr; 
        
        if(pHead->val==pHead->next->val){
            //链表的头节点有重复
            int value = pHead->val;
            
            while(pHead!=nullptr && pHead->val==value){
                pNode = pHead->next;
                delete pHead;
                pHead=nullptr;
                pHead=pNode;
            }
            
            return deleteDuplication(pHead);  //因为输入的是头节点，没有next指针接收，因此直接return
            
        }else{
            //链表不重复
            pHead->next = deleteDuplication(pHead->next); //返回的链表应该连接在头指针的下面
        }
        return pHead;

    }
};