题目描述
- 在一个排序的链表中,存在重复的结点,请删除该链表中重复的结点,重复的结点不保留,返回链表头指针。 例如,链表1->2->3->3->4->4->5 处理后为 1->2->5。
算法分析
- 若当前节点与下一个节点值不等currNode->val == currNode->next->val,则为非重复节点,继续向后查找,preNode = currNode,currNode = currNode->next;
- 若找到重复节点,则循环向后查找,直到与重复节点不相等,并将前继指向当前节点;
- 若重复节点为pHead,则需将pHead重新设置为非重复节点;
提交代码(1):使用标志位来判别不同情况
class Solution {
public:
ListNode* deleteDuplication(ListNode* pHead)
{
if (!pHead || !(pHead->next))
return pHead;
ListNode* preNode = pHead;
ListNode* currNode = pHead;
/* 有重复节点标志位 */
bool flag = false;
/* 重复节点为头节点标志位 */
bool headFlag = false;
while (currNode && currNode->next)
{
/* 如果为重复节点则依次向后查找 */
while (currNode->next && currNode->val == currNode->next->val)
{
if (currNode == pHead)
headFlag = true;
/* 防止内存泄露 */
ListNode* temp = currNode;
currNode = currNode->next;
delete temp;
flag = true;
}
if (headFlag)
{
ListNode* temp = currNode;
currNode = currNode->next;
pHead = currNode;
preNode = currNode;
headFlag = false;
flag = false;
delete temp;
}
else
{
if (flag)
{
ListNode* temp = currNode;
currNode = currNode->next;
preNode->next = currNode;
flag = false;
delete temp;
}
else
{
preNode = currNode;
currNode = currNode->next;
}
}
}
return pHead;
}
};
提交代码(2):创建一个头结点,避免pHead被删除的情况
class Solution {
public:
ListNode* deleteDuplication(ListNode* pHead)
{
if (!pHead || !(pHead->next))
return pHead;
ListNode *pNewHead = new ListNode(-1);
pNewHead->next = pHead;
ListNode* preNode = pNewHead;
ListNode* currNode = pHead;
while (currNode && currNode->next)
{
if (currNode->val == currNode->next->val)
{
while (currNode->next && currNode->val == currNode->next->val)
{
/* 防止内存泄露 */
ListNode* temp = currNode;
currNode = currNode->next;
delete temp;
}
ListNode* temp = currNode;
currNode = currNode->next;
preNode->next = currNode;
delete temp;
}
else
{
preNode = currNode;
currNode = currNode->next;
}
}
return pNewHead->next;
}
};
提交代码(3):递归方法
class Solution {
public:
ListNode* deleteDuplication(ListNode* pHead)
{
if (!pHead || !(pHead->next))
return pHead;
ListNode* currNode;
if (pHead->val == pHead->next->val)
{
currNode = pHead->next->next;
while (currNode && currNode->val == pHead->val)
currNode = currNode->next;
return deleteDuplication(currNode);
}
else
{
currNode = pHead->next;
pHead->next = deleteDuplication(currNode);
return pHead;
}
}
};
测试代码:
// ====================测试代码====================
void Test(char* testName, ListNode* pHead, int* expectedValues, int expectedLength)
{
if (testName != nullptr)
printf("%s begins: ", testName);
Solution s;
pHead = s.deleteDuplication(pHead);
int index = 0;
ListNode* pNode = pHead;
while (pNode != nullptr && index < expectedLength)
{
if (pNode->val != expectedValues[index])
break;
pNode = pNode->next;
index++;
}
if (pNode == nullptr && index == expectedLength)
printf("Passed.\n");
else
printf("FAILED.\n");
}
// 某些结点是重复的
void Test1()
{
ListNode* pNode1 = CreateListNode(1);
ListNode* pNode2 = CreateListNode(2);
ListNode* pNode3 = CreateListNode(3);
ListNode* pNode4 = CreateListNode(3);
ListNode* pNode5 = CreateListNode(4);
ListNode* pNode6 = CreateListNode(4);
ListNode* pNode7 = CreateListNode(5);
ConnectListNodes(pNode1, pNode2);
ConnectListNodes(pNode2, pNode3);
ConnectListNodes(pNode3, pNode4);
ConnectListNodes(pNode4, pNode5);
ConnectListNodes(pNode5, pNode6);
ConnectListNodes(pNode6, pNode7);
ListNode* pHead = pNode1;
int expectedValues[] = { 1, 2, 5 };
Test("Test1", pHead, expectedValues, sizeof(expectedValues) / sizeof(int));
//DestroyList(pHead);
}
// 没有重复的结点
void Test2()
{
ListNode* pNode1 = CreateListNode(1);
ListNode* pNode2 = CreateListNode(2);
ListNode* pNode3 = CreateListNode(3);
ListNode* pNode4 = CreateListNode(4);
ListNode* pNode5 = CreateListNode(5);
ListNode* pNode6 = CreateListNode(6);
ListNode* pNode7 = CreateListNode(7);
ConnectListNodes(pNode1, pNode2);
ConnectListNodes(pNode2, pNode3);
ConnectListNodes(pNode3, pNode4);
ConnectListNodes(pNode4, pNode5);
ConnectListNodes(pNode5, pNode6);
ConnectListNodes(pNode6, pNode7);
ListNode* pHead = pNode1;
int expectedValues[] = { 1, 2, 3, 4, 5, 6, 7 };
Test("Test2", pHead, expectedValues, sizeof(expectedValues) / sizeof(int));
//DestroyList(pHead);
}
// 除了一个结点之外其他所有结点的值都相同
void Test3()
{
ListNode* pNode1 = CreateListNode(1);
ListNode* pNode2 = CreateListNode(1);
ListNode* pNode3 = CreateListNode(1);
ListNode* pNode4 = CreateListNode(1);
ListNode* pNode5 = CreateListNode(1);
ListNode* pNode6 = CreateListNode(1);
ListNode* pNode7 = CreateListNode(2);
ConnectListNodes(pNode1, pNode2);
ConnectListNodes(pNode2, pNode3);
ConnectListNodes(pNode3, pNode4);
ConnectListNodes(pNode4, pNode5);
ConnectListNodes(pNode5, pNode6);
ConnectListNodes(pNode6, pNode7);
ListNode* pHead = pNode1;
int expectedValues[] = { 2 };
Test("Test3", pHead, expectedValues, sizeof(expectedValues) / sizeof(int));
//DestroyList(pHead);
}
// 所有结点的值都相同
void Test4()
{
ListNode* pNode1 = CreateListNode(1);
ListNode* pNode2 = CreateListNode(1);
ListNode* pNode3 = CreateListNode(1);
ListNode* pNode4 = CreateListNode(1);
ListNode* pNode5 = CreateListNode(1);
ListNode* pNode6 = CreateListNode(1);
ListNode* pNode7 = CreateListNode(1);
ConnectListNodes(pNode1, pNode2);
ConnectListNodes(pNode2, pNode3);
ConnectListNodes(pNode3, pNode4);
ConnectListNodes(pNode4, pNode5);
ConnectListNodes(pNode5, pNode6);
ConnectListNodes(pNode6, pNode7);
ListNode* pHead = pNode1;
Test("Test4", pHead, nullptr, 0);
//DestroyList(pHead);
}
// 所有结点都成对出现
void Test5()
{
ListNode* pNode1 = CreateListNode(1);
ListNode* pNode2 = CreateListNode(1);
ListNode* pNode3 = CreateListNode(2);
ListNode* pNode4 = CreateListNode(2);
ListNode* pNode5 = CreateListNode(3);
ListNode* pNode6 = CreateListNode(3);
ListNode* pNode7 = CreateListNode(4);
ListNode* pNode8 = CreateListNode(4);
ConnectListNodes(pNode1, pNode2);
ConnectListNodes(pNode2, pNode3);
ConnectListNodes(pNode3, pNode4);
ConnectListNodes(pNode4, pNode5);
ConnectListNodes(pNode5, pNode6);
ConnectListNodes(pNode6, pNode7);
ConnectListNodes(pNode7, pNode8);
ListNode* pHead = pNode1;
Test("Test5", pHead, nullptr, 0);
//DestroyList(pHead);
}
// 除了两个结点之外其他结点都成对出现
void Test6()
{
ListNode* pNode1 = CreateListNode(1);
ListNode* pNode2 = CreateListNode(1);
ListNode* pNode3 = CreateListNode(2);
ListNode* pNode4 = CreateListNode(3);
ListNode* pNode5 = CreateListNode(3);
ListNode* pNode6 = CreateListNode(4);
ListNode* pNode7 = CreateListNode(5);
ListNode* pNode8 = CreateListNode(5);
ConnectListNodes(pNode1, pNode2);
ConnectListNodes(pNode2, pNode3);
ConnectListNodes(pNode3, pNode4);
ConnectListNodes(pNode4, pNode5);
ConnectListNodes(pNode5, pNode6);
ConnectListNodes(pNode6, pNode7);
ConnectListNodes(pNode7, pNode8);
ListNode* pHead = pNode1;
int expectedValues[] = { 2, 4 };
Test("Test6", pHead, expectedValues, sizeof(expectedValues) / sizeof(int));
//DestroyList(pHead);
}
// 链表中只有两个不重复的结点
void Test7()
{
ListNode* pNode1 = CreateListNode(1);
ListNode* pNode2 = CreateListNode(2);
ConnectListNodes(pNode1, pNode2);
ListNode* pHead = pNode1;
int expectedValues[] = { 1, 2 };
Test("Test7", pHead, expectedValues, sizeof(expectedValues) / sizeof(int));
//DestroyList(pHead);
}
// 结点中只有一个结点
void Test8()
{
ListNode* pNode1 = CreateListNode(1);
ConnectListNodes(pNode1, nullptr);
ListNode* pHead = pNode1;
int expectedValues[] = { 1 };
Test("Test8", pHead, expectedValues, sizeof(expectedValues) / sizeof(int));
//DestroyList(pHead);
}
// 结点中只有两个重复的结点
void Test9()
{
ListNode* pNode1 = CreateListNode(1);
ListNode* pNode2 = CreateListNode(1);
ConnectListNodes(pNode1, pNode2);
ListNode* pHead = pNode1;
Test("Test9", pHead, nullptr, 0);
//DestroyList(pHead);
}
// 空链表
void Test10()
{
ListNode* pHead = nullptr;
Test("Test10", pHead, nullptr, 0);
}
int main(int argc, char* argv[])
{
Test1();
Test2();
Test3();
Test4();
Test5();
Test6();
Test7();
Test8();
Test9();
Test10();
return 0;
}