用O（1）的时间复杂度删除链表中的结点

//链表结点
typedef struct ListNode
{
    int data;
    struct ListNode* next;
}ListNode,*pListNode;
//函数
void DeleteNode(pListNode* pListHead, pListNode pos);

我们普通所想到的方法就是，遍历这个链表，然后查找到该节点，查找到它的前驱，删除当前结点。时间复杂度为o(n)

void DeleteNode(pListNode* pListHead, pListNode pos)
{
    assert(pListHead != NULL);
    assert(pos != NULL);
    ListNode* cur = *pListHead;
    //如果要删除的结点不是第一个结点，找到要删除结点的前面那个结点，然后删除
    if ((*pListHead)->next == NULL)
    {
        while (cur->next == pos)
        {
            cur = cur->next;
        }
        cur->next = NULL;
        free(pos);
        pos = NULL;
    }
    //如果链表只要一个结点，正好那个结点是要删除的结点
    else
    {
        *pListHead = NULL;
        free(pos);
        pos = NULL;
    }
}

而剑指offer了提出了数据覆盖法可以达到时间复杂度为O（1）

假设删除结点i，那么把i的下一个结点j的内容复制到i，然后把i的指针指向结点j的下一个节点，然后在删除结点j。

但是如果要删除的结点位于链表的尾部，我们仍然需要从链表的头节点开始顺序遍历，找到这个结点的前驱，来完成删除操作。

如果链表中只有一个结点，我们要删除头节点（尾节点），删除之后，需要把链表头部也置空。

void DeleteNode(pListNode *plistHead,pListNode pos)
{
    assert(plistHead != NULL);
    assert(pos != NULL);
    ListNode *cur = *plistHead;
    ListNode *del = NULL;
    if(pos->next != NULL)
    {
        del = pos->next; //要删除的是当前结点的下一个结点
        pos->data = del->data;
        pos->next = del->next;
        free(del);
        del = NULL;
    }
    else if(*plistHead == pos) //只有一个节点
    {
        *plistHead = NULL;
        free(pos);
        pos = NULL;
    }
    else
    {
        while(cur->next) //要删除的结点是尾节点
        {
            if(cur->next == pos)
            {
                cur = cur->next;
            }
            cur->next == NULL;
            free(pos);
            pos = NULL;
        }
    }
}