第18题:在O(1)时间删除链表结点+删除链表中重复的节点
题目描述：题目描述在O(1)时间删除链表结点
给定单向链表的头指针和一个结点指针，定义一个函数在O(1)时间删除该结点。
考查创新编程能力。
思路：
1.如果从头到尾遍历，时间O(n）
2.如果将待删除节点的下一个节点j复制到待删除节点i上，然后将i的下一个节点指向j的下一个节点，删除j的节点。
3.对于尾节点，需要从头开始遍历
4.对于只有一个节点的链表，要将*HeadNode设置为Nullptr.
5.时间复杂度
n-1个非尾节点，时间O(1)
1个尾节点，时间O(n)
最终((n-1)*O(1)+O(n))/n=O(1)符合题目要求
注意：
1.每次删除完节点后，要释放节点，即将节点的指针设为nullptr。
2.n-1个非尾节点，删除的是待删除节点的下一个pNext，而不是本身的节点。
3.最后一个尾节点，用while遍历，pNode指针向后指，找到最后一个节点，删除后，将pNode->Next设为nullptr。
//已知该节点存在链表中
void DeleteNode(ListNode** pListHead, ListNode* pToBeDeleted)
{
//1.如果链表头节点或待删除节点为空，返回
if (!pListHead || !pToBeDeleted)
return;
//2.多个节点的链表，前n-1个非尾节点
if (pToBeDeleted->m_pNext)
{
//2.1 pNext：待删除节点J的下个节点K
ListNode* pNext = pToBeDeleted->m_pNext;
//2.2 复制值J=K
pToBeDeleted->m_nValue = pNext->m_nValue;
//2.3 复制指针J->NEXT=K->NEXT
pToBeDeleted->m_pNext = pNext->m_pNext;
//2.4 删去下个节点K(pNext)
delete pNext;
//2.5 pNext设为空指针
pNext = nullptr;
}
//3.只有一个节点的链表，删完要将头节点指针设为空
else if(*pListHead==pToBeDeleted)
{
//3.1删除节点
delete pToBeDeleted;
//3.2 释放删除节点的指针
pToBeDeleted = nullptr;
//3.3 删除后将头节点设为空指针
*pListHead = nullptr;
}
//4.如果是最后一个尾节点，就用遍历
else
{
//4.1 pNode：遍历指针,从头开始
ListNode* pNode = *pListHead;
//4.2 while遍历找到pNode的下一个节点是要删除的节点
while(pNode->m_pNext == pToBeDeleted)
{
//4.2.1 指针向后指
pNode = pNode->m_pNext;
}
//4.3 将pNode的下一个节点设为空
pNode->m_pNext = nullptr;
//4.4 删除最后的节点
delete pToBeDeleted;
//4.5 释放指针
pToBeDeleted = nullptr;
}
}
题目描述
在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5
思路：
1.确定函数的参数，头节点也可能被删除，所以函数声明应该为
void deleteDuplication(ListNode** pHead);
2.从头到尾遍历链表，确保pPreNode始终和下一个没有重复的节点连在一起。
//函数的参数:ListNode** pHead。
//因为头节点可能重复，会被删除，所以不用ListNode* pHead
void DeleteDuplication(ListNode** pHead)
{
//1.如果是空链表或头节点为空，返回
if (!pHead || !*pHead)
return;
//2.ListNode* pNode:初始化指向当前头节点*pHead
ListNode* pNode = *pHead;
//3.ListNode* pPreNode:指向上个节点,初始化为空
ListNode* pPreNode = nullptr;
//4.循环遍历
while (pNode)
{
//4.1.新建一个节点pNext，指向下个节点
ListNode* pNext = pNode->m_pNext;
//4.2 设置标记：pNode节点是否需要删除
bool needDetele = false;
//4.3 如果下个节点pNext不为空，且pNode节点值和下个节点pNext的值相同，pNode节点就需要删除
if (pNext!=nullptr && pNext->m_nValue == pNode->m_nValue)
needDetele = true;
//4.4 如果不需要删除，就遍历下一个
if (!needDetele)
{
//4.4.1 上个节点pPreNode设为当前节点pNode
pPreNode = pNode;
//4.4.2 当前节点pNode设为下个节点pNext
pNode = pNext;
/* pNode->m_nValue = pNext->m_nValue;
pNode->m_pNext = pNext->m_pNext;*/
}
//4.5 否则，开始删除
else
{
//4.5.1 记录pNode值
int value = pNode->m_nValue;
//4.5.2 定义要删除的节点变量toBeDeleted，初始化为该节点
ListNode* toBeDeleted = pNode;
//4.5.3 循环遍历：如果toBeDeleted节点不为空，且等于下一个节点，就将toBeDeleted删除，
while (toBeDeleted&&value == toBeDeleted->m_nValue)
{
//4.5.3.1 pNext指向toBeDeleted下个节点
pNext = toBeDeleted->m_pNext;
//4.5.3.2 删除toBeDeleted节点
delete toBeDeleted;
toBeDeleted = nullptr;
//4.5.3.3 toBeDeleted节点赋值为下个节点pNext
toBeDeleted = pNext;
}
//4.5.4 如果删除的是头节点,即pPreNode为空，将头节点改为下个节点
if (!pPreNode)
*pHead = pNext;
//4.5.5 否则，将pPreNode的下个节点设置为下个节点pNext
else
pPreNode->m_pNext = pNext;
//4.5.6 当前节点pNode设为下个节点pNext
pNode = pNext;
}
}
}第二遍
/*
struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) :
val(x), next(NULL) {
}
};
*/
class Solution {
public:
ListNode* deleteDuplication(ListNode* pHead)
{
//1.如果链表为空或者头节点为空，返回nullptr
if(!pHead)
return nullptr;
//2.pPreNode指向上一个节点，初始化为nullptr;
ListNode* pPreNode = nullptr;
//3.当前节点pNode,初始化指向头节点
ListNode* pNode=pHead;
//4.删除重复节点，while循环条件：pNode不为空
while(pNode)
{
//4.1 pNext指向pNode下个节点
ListNode* pNext= pNode->next;
//4.2 bool标记pNode是否需要删除,默认值false
bool needDelete=false;
//4.3 更新needDelete标记值:如果pNode的值和下个节点pNext的值相等的话，这个节点需要删除
if(pNext&&pNode->val==pNext->val)
needDelete=true;
//4.4 如果不需要删除，当前节点pNode向后指一个pNext,上一个节点pPreNode指向当前节点
if(!needDelete)
{
pPreNode=pNode;
pNode=pNext;
}
//4.5 否则需要删除
else
{
//4.5.1 存放当前pNode的值int
int value=pNode->val;
//4.5.2 定义待删除的节点toBeDeleted
ListNode* toBeDeleted=pNode;
//4.5.2 如果待删除的节点toBeDeleted存在，且值等于当前pNode的值,则删除该节点
while(toBeDeleted&&toBeDeleted->val==value)
{
//4.5.2.1 保存待删除节点的下个节点
pNext=toBeDeleted->next;
//4.5.2.2 删除该节点
delete toBeDeleted;
toBeDeleted=nullptr;
//4.5.2.3 重新更新待删除的节点
toBeDeleted=pNext;
}
//4.5.3 如果上个节点为空，即头节点被删除,头节点为pNext
if(!pPreNode)
pHead=pNext;
//4.5.4上一个节点pPreNode指向当前节点
else
pPreNode->next=pNext;
//4.6 将当前节点pNode向后指一个pNext
pNode=pNext;
}
}
//5. 返回链表
return pHead;
}
};网友的
class Solution {
public:
ListNode* deleteDuplication(ListNode* pHead)
{
if (pHead==NULL)
return NULL;
if (pHead!=NULL && pHead->next==NULL)
return pHead;
ListNode* current;
if ( pHead->next->val==pHead->val){
current=pHead->next->next;
while (current != NULL && current->val==pHead->val)
current=current->next;
return deleteDuplication(current);
}
else {
current=pHead->next;
pHead->next=deleteDuplication(current);
return pHead;
}
}
};
