13. 在O(1)时间删除链表结点

  题目：给定单向链表的头指针和一个结点指针，定义一个函数在O(1)时间删除该结点。链表结点与函数的定义如下：
  
  思路：设这个要删除的结点指针为i，找到该结点的下一结点j，然后将j的内容复制给i，并将i的指针指向j的下一结点，然后将j结点删除。这样的效果就是把i结点删除；
  但是如果要删除的结点在链表尾部，那它就没有下一结点。所以也需要从链表的头结点开始，顺序遍历得到该结点的前序结点，然后完成删除操作；
  如果链表中只有一个结点，在删除之后，应该将链表的头结点设置为NULL。

  测试用例：
  1.功能测试：头、尾、中间结点、唯一结点
  2.特殊输入测试：NULL指针

#include<iostream>
#include<cstdio>
using namespace std;

struct ListNode
{
    int             m_nValue;
    ListNode*       m_pNext;
};

//创建链表结点
ListNode* CreateListNode(int value)
{
    ListNode* pNode = new ListNode();
    pNode->m_nValue = value;
    pNode->m_pNext = NULL;

    return pNode;
}

//连接链表节点
void ConnectListNodes(ListNode* pCurrent, ListNode* pNext)
{
    if (pCurrent == NULL)
    {
        cout << "连接错误" << endl;
        return;
    }

    pCurrent->m_pNext = pNext;
}

//打印链表
void PrintList(ListNode* pHead)
{
    ListNode* pNode = pHead;
    while (pNode != NULL)
    {
        cout << pNode->m_nValue << " ";
        pNode = pNode->m_pNext;
    }
    cout << endl;
}

//销毁链表
void DestroyList(ListNode* pHead)
{
    ListNode* pNode = pHead;
    while (pNode != NULL)
    {
        pHead = pHead->m_pNext;
        delete pNode;
        pNode = pHead;
    }
}

void DeleteNode(ListNode** pListHead, ListNode* pToBeDeleted)
{
    if (!pListHead || !pToBeDeleted)
    {
        return;
    }

    //要删除的结点不是尾结点
    if (pToBeDeleted->m_pNext != NULL)
    {
        ListNode* pNext = pToBeDeleted->m_pNext;
        pToBeDeleted->m_nValue = pNext->m_nValue;
        pToBeDeleted->m_pNext = pNext->m_pNext;

        delete pNext;
        pNext = NULL;
    }

    //链表只有一个结点，删除头结点（也是尾结点），删除之后设NULL
    else if (*pListHead == pToBeDeleted)
    {
        delete pToBeDeleted;
        pToBeDeleted = NULL;
        *pListHead = NULL;
    }

    //链表中有多个结点，删除尾结点，遍历链表
    else
    {
        ListNode* pNode = *pListHead;
        while (pNode->m_pNext != pToBeDeleted)
        {
            pNode = pNode->m_pNext;
        }

        pNode->m_pNext = NULL;
        delete pToBeDeleted;
        pToBeDeleted = NULL;
    }
}

//测试
void test1()
{
    ListNode* pNode1 = CreateListNode(1);
    ListNode* pNode2 = CreateListNode(2);
    ListNode* pNode3 = CreateListNode(3);
    ListNode* pNode4 = CreateListNode(4);
    ListNode* pNode5 = CreateListNode(5);

    ConnectListNodes(pNode1, pNode2);
    ConnectListNodes(pNode2, pNode3);
    ConnectListNodes(pNode3, pNode4);
    ConnectListNodes(pNode4, pNode5);

    PrintList(pNode1);

    DeleteNode(&pNode1, pNode5);
    PrintList(pNode1);

    DeleteNode(&pNode1, pNode2);
    PrintList(pNode1);

    DeleteNode(&pNode1, pNode1);
    PrintList(pNode1);

    DestroyList(pNode1);
}

void test2()
{
    ListNode* pNode1 = CreateListNode(1);
    PrintList(pNode1);

    DeleteNode(&pNode1, pNode1);
    PrintList(pNode1);
}

void test3()
{
    PrintList(NULL);

    DeleteNode(NULL, NULL);
    PrintList(NULL);
}

int main()
{
    test1();
    test2();
    test3();
}