python删除链表中重复的节点_剑指Offer（五十六）：删除链表中重复的结点

摘要

在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。

一、前言

本系列文章为《剑指Offer》刷题笔记。

刷题平台：牛客网

书籍下载：共享资源

二、题目

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

1、思路

删除重复结点，只需要记录当前结点前的最晚访问过的不重复结点pPre、当前结点pCur、指向当前结点后面的结点pNext的三个指针即可。如果当前节点和它后面的几个结点数值相同，那么这些结点都要被剔除，然后更新pPre和pCur；如果不相同，则直接更新pPre和pCur。

需要考虑的是，如果第一个结点是重复结点我们该怎么办？这里我们分别处理一下就好，如果第一个结点是重复结点，那么就把头指针pHead也更新一下。

2、代码

C++：

C++

/*

struct ListNode {

int val;

struct ListNode *next;

ListNode(int x) :

val(x), next(NULL) {

}

};

*/

class Solution {

public:

ListNode* deleteDuplication(ListNode* pHead)

{

if(pHead == NULL){

return NULL;

}

// 指向当前结点前最晚访问过的不重复结点

ListNode* pPre = NULL;

// 指向当前处理的结点

ListNode* pCur = pHead;

// 指向当前结点后面的结点

ListNode* pNext = NULL;

while(pCur != NULL){

// 如果当前结点与下一个结点相同

if(pCur->next != NULL && pCur->val == pCur->next->val){

pNext = pCur->next;

// 找到不重复的最后一个结点位置

while(pNext->next != NULL && pNext->next->val == pCur->val){

pNext = pNext->next;

}

// 如果pCur指向链表中第一个元素，pCur -> ... -> pNext ->...

// 要删除pCur到pNext, 将指向链表第一个元素的指针pHead指向pNext->next。

if(pCur == pHead){

pHead = pNext->next;

}

// 如果pCur不指向链表中第一个元素，pPre -> pCur ->...->pNext ->...

// 要删除pCur到pNext，即pPre->next = pNext->next

else{

pPre->next = pNext->next;

}

// 向前移动

pCur = pNext->next;

}

// 如果当前结点与下一个结点不相同

else{

pPre = pCur;

pCur = pCur->next;

}

}

return pHead;

}

};

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53/*

struct ListNode {

int val;

struct ListNode *next;

ListNode(int x) :

val(x), next(NULL) {

}

};

*/

classSolution{

public:

ListNode*deleteDuplication(ListNode*pHead)

{

if(pHead==NULL){

returnNULL;

}

// 指向当前结点前最晚访问过的不重复结点

ListNode*pPre=NULL;

// 指向当前处理的结点

ListNode*pCur=pHead;

// 指向当前结点后面的结点

ListNode*pNext=NULL;

while(pCur!=NULL){

// 如果当前结点与下一个结点相同

if(pCur->next!=NULL&&pCur->val==pCur->next->val){

pNext=pCur->next;

// 找到不重复的最后一个结点位置

while(pNext->next!=NULL&&pNext->next->val==pCur->val){

pNext=pNext->next;

}

// 如果pCur指向链表中第一个元素，pCur -> ... -> pNext ->...

// 要删除pCur到pNext, 将指向链表第一个元素的指针pHead指向pNext->next。

if(pCur==pHead){

pHead=pNext->next;

}

// 如果pCur不指向链表中第一个元素，pPre -> pCur ->...->pNext ->...

// 要删除pCur到pNext，即pPre->next = pNext->next

else{

pPre->next=pNext->next;

}

// 向前移动

pCur=pNext->next;

}

// 如果当前结点与下一个结点不相同

else{

pPre=pCur;

pCur=pCur->next;

}

}

returnpHead;

}

};

Python：

Python

# -*- coding:utf-8 -*-

# class ListNode:

# def __init__(self, x):

# self.val = x

# self.next = None

class Solution:

def deleteDuplication(self, pHead):

# write code here

pPre = None

pCur = pHead

pNext = None

while pCur != None:

if pCur.next != None and pCur.val == pCur.next.val:

pNext = pCur.next

while pNext.next != None and pNext.next.val == pCur.val:

pNext = pNext.next

if pCur == pHead:

pHead = pNext.next

else:

pPre.next = pNext.next

pCur = pNext.next

else:

pPre = pCur

pCur = pCur.next

return pHead

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25# -*- coding:utf-8 -*-

# class ListNode:

#     def __init__(self, x):

#         self.val = x

#         self.next = None

classSolution:

defdeleteDuplication(self,pHead):

# write code here

pPre=None

pCur=pHead

pNext=None

whilepCur!=None:

ifpCur.next!=NoneandpCur.val==pCur.next.val:

pNext=pCur.next

whilepNext.next!=NoneandpNext.next.val==pCur.val:

pNext=pNext.next

ifpCur==pHead:

pHead=pNext.next

else:

pPre.next=pNext.next

pCur=pNext.next

else:

pPre=pCur

pCur=pCur.next

returnpHead