删除链表中重复的结点

python

class Solution:
    def deleteDuplication(self,pHead):
        if not pHead or not pHead.next:
            return pHead
        //返回无重复第一个节点
        if pHead.val == pHead.next.val:
            pnode = pHead.next.next
            while pnode and pnode.val==pnode.next.val:
                pnode = pnode.next.next
            //这个时候第一个pnode.val != pnode.next.val
            //return 的意思是，再次迭代pnode.val==pnode.next.val的情况，一直到没有相等的时候执行else
            #此时应该会相同所有相同结点的下一个，这个时候继续将这个节点进行迭代
            #注意，要返回的是删除了相同结点后下一个结点
            return self.deleteDuplication(pnode)
        else:
            #如果这个节点和下一个结点不一样，那就继续把下一个结点送入到函数中
            #返回的应该是不同节点的第一个个，所以返回phead
            pHead.next = self.deleteDuplication(pHead.next)
            return pHead
    

c++

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
        val(x), next(NULL) {
    }
};
*/
class Solution {
public:
    ListNode* deleteDuplication(ListNode* pHead)
    {
          // 链表有0个/1个节点，返回第一个节点
          if(pHead==NULL||pHead->next==NULL)
              return pHead;
          else
          {
              // 新建一个头节点，防止第一个结点被删除
              ListNode* newHead=new ListNode(-1);
              newHead->next=pHead;

              // 建立索引指针
              ListNode* p=pHead;      // 当前节点
              ListNode* pre=newHead;  // 当前节点的前序节点
              ListNode* next=p->next;    // 当前节点的后序节点

              // 从头到尾遍历编标
              while(p!=NULL && p->next!=NULL)
              {
                  if(p->val==next->val)//如果当前节点的值和下一个节点的值相等
                  {
                      // 循环查找，找到与当前节点不同的节点
                      while(next!=NULL && next->val==p->val)
                      {
                          ListNode* temp=next;
                          next=next->next;

                          // 删除内存中的重复节点
                          delete temp;//delete指针之后，只是回收指针指向位置的空间，指针的值不变，所以还要讲指针设置为null
                          temp = nullptr;//这样可以避免野指针的出现

                      }

                    pre->next=next;
                    p=next;
                  }
                  else//如果当前节点和下一个节点值不等，则向后移动一位
                  {
                      pre=p;
                      p=p->next;
                  }
                  next=p->next;
              }
           return newHead->next;//返回头结点的下一个节点
          }
    }
};

 自己修改了一点点

struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
        val(x), next(NULL) {
    }
};
*/
class Solution {
public:
    ListNode* deleteDuplication(ListNode* pHead)
    {
        if(!pHead || !pHead->next) return pHead;
        ListNode* new_head = new ListNode(-1);
        new_head->next = pHead;
        ListNode* pre = new_head;
        ListNode* cur = pHead;
        ListNode* nex = pHead->next;
        while(cur && nex){
            if(cur->val ==nex->val){
                while(nex && nex->val==cur->val){
                    ListNode* temp = nex;
                    nex = nex->next;
                    delete temp;//delete只是删除了指针指向的位置的空间，指针本身的值没有改变，所以要再设置成null，不然出现野指针现象
                    temp = nullptr;
                }
                pre->next = nex;
                cur = nex;
                nex = nex->next;
            }
            else{
                pre = cur;
                cur = nex;
                nex = nex->next;
            }
        }
        pHead = new_head->next;
        delete new_head;
        return pHead;
    }
};