剑指offer--用O(1)的时间复杂度删除链表的节点

面试题13：给定单项链表的头指针和一个结点指针，定义一个函数在O(1)时间删除该结点。

//不带头结点的单链表
struct ListNode
{
    int m_nKey;
    ListNode *m_pNext;
};

//尾插
void InsertTail(ListNode **head,int key)
{
    ListNode *newnode = new ListNode();
    newnode->m_nKey = key;
    newnode->m_pNext = NULL;

    if(*head == NULL)
    {
        *head = newnode;
    }
    else
    {
        ListNode *p = *head;
        while(p->m_pNext != NULL)
            p = p->m_pNext;

        p->m_pNext = newnode;
    }
}

/*假设该结点在链表中。
如果不假设，我们需要O(n)的时间才能判断链表中是否包含该结点。基于O(1)的限制，只能把确保结点在链表中的要求推给函数调用者*/
void DeleteNode(ListNode **head,ListNode *deletenode)
{
    if(head==NULL || deletenode==NULL)
        return;
    //删除的节点不是尾节点
    if(deletenode->m_pNext != NULL)
    {
        ListNode *p = deletenode->m_pNext;
        deletenode->m_nKey = p->m_nKey;
        deletenode->m_pNext = p->m_pNext;
        delete(p);
        p = NULL;
    }
    //链表只有一个节点，删除的是尾节点
    else if(*head == deletenode)
    {
        delete deletenode;
        deletenode = NULL;
        *head = NULL;
    }
    //链表有多个节点，删除的是尾节点
    else
    {
        ListNode *p = *head;
        while(p->m_pNext != deletenode)
        {
             p = p->m_pNext;
        }
        p->m_pNext = NULL;

        delete deletenode;
        deletenode = NULL;
    }
}

void Show(ListNode *head)
{
    for(ListNode *p=head;p!=NULL;p=p->m_pNext)
    {
        cout<<p->m_nKey<<ends;
    }
    cout<<endl;
}

int main()
{
    ListNode *head = NULL;
    for(int i=0;i<10;i++)
    {
        InsertTail(&head,i);
    }
    cout<<"删除前：";
    Show(head);

    cout<<"删除第三个元素：";
    DeleteNode(&head,head->m_pNext->m_pNext);
    Show(head);

    cout<<"删除首元素：";
    DeleteNode(&head,head);
    Show(head);

    ListNode *p = head;
    while(p->m_pNext != NULL) p = p->m_pNext;
    cout<<"删除尾元素：";
    DeleteNode(&head,p);
    Show(head);
}

对于一个n-1非尾结点而言，可以在O(1)时把下一个结点的内存复制覆盖要删除的结点，并删除下一个结点；对于尾结点来说，由于仍需要顺序查找，时间复杂度为O(n)。总的时间复杂度是[(n-1)*O(1)+O(n)]/n,结果是O(1)。