删除链表的节点

题目1 删除一个节点

在 $O(1)$时间内删除链表的节点

分三种情况：

1. 删除的节点不是尾结点，复制下一个节点的值到该节点，然后删除下一个节点
2. 删除的节点是尾结点
   1. 删除的节点与头结点相同，那么，要设置头结点为null
   2. 不是头结点，删除尾结点，顺序查找，找到倒数第二个，然后，删除最后一个。

2.2复杂度为 $O(n)$，其余为 $O(1)$，所以整体还是 $O(1)$。

题目2删除重复的节点

删除链表所有重复的节点

1. 在头结点前增加一个节点0，这样能保证节点0一直在开头，返回时，返回节点0的下一个就好了
2. pre， cur 两个指针分别指向前一个和当前，当前如果需要删除，则while不断删除。

/*
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 preHead = ListNode(0);
        preHead.next = pHead;
        ListNode* preNode = &preHead;
        ListNode* curNode = pHead;
        while(curNode!=nullptr)
        {
            bool needDelete = false;
            if(curNode->next!=nullptr && curNode->next->val == curNode->val)
                needDelete = true;
            if(needDelete)
            {
                int duplicateVal = curNode->val;
                while(curNode!=nullptr && curNode->val==duplicateVal)
                {
                    ListNode* tmp = curNode;
                    curNode = curNode->next;
                    delete tmp;
                }
                preNode->next = curNode;
            }
            else
            {
                preNode = curNode;
                curNode = curNode->next;
            }
        }
        return preHead.next;
    }
};

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
        val(x), next(NULL) {
    }
};
*/
class Solution {
public:
    ListNode* deleteDuplication(ListNode* pHead)
    {
        if (pHead==null || pHead.next==null){return pHead;}
        ListNode Head = new ListNode(0);
        Head.next = pHead;
        ListNode pre  = Head;
        ListNode last = Head.next;
        while (last!=null){
            if(last.next!=null && last.val == last.next.val){
                // 找到最后的一个相同节点
                while (last.next!=null && last.val == last.next.val){
                    last = last.next;
                }
                pre.next = last.next;
                last = last.next;
            }else{
                pre = pre.next;
                last = last.next;
            }
        }
        return Head.next;
    }
};