《剑指offer》面试题18：删除链表节点（扩展）

更多剑指offer习题请点击：《剑指offer》（第二版）题集目录索引

1. 题目一：在 $O(1)$ 时间内删除链表节点

　　给定单向链表的头指针和一个节点指针，定义一个函数在 $O(1)$ 时间内删除该节点。链表节点与函数定义如下：

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

void DeleteNode(ListNode** pListHead, ListNode* pToBeDeleted);

解题思路：
　　要求在 $O(1)$ 内删除节点delete，这就意味着我们不能遍历链表，也就意味着我们没法找到要删除的节点的前一个节点prev。按照常规方法删除节点，必要要找到节点prev，那有没有哪种方法不用去找节点prev，直接删除节点delete？有！
　　
　　不通过遍历我们没法找到节点delet的前一个节点prev，但是我们可以找到节点delete的下一个节点next，把节点next的值赋给要节点delete，然后删除节点next，这样不就相当于删除了节点delete了嘛。但是这种方法只能删除非尾节点（尾节点的下一个节点为nullptr），如果是删除尾节点的话还是老老实实用遍历的方法吧。
　　
　　确定好思路后就可以写代码了，不过最好写之前先分析清楚可能有的情况，这样后期就能少修一点bug。

1. 删除非尾节点：采取上述思路即可。
2. 链表只有一个节点：要删除的既是头结点也是尾节点，既然会改变头结点，所以这个函数传参时应该传头结点指针的地址（二级指针）。
3. 链表有多个节点，删除尾节点：遍历删除。

< Function Code >

void DeleteNode(ListNode** pListHead, ListNode* pToBeDeleted)
{
    if (pListHead == nullptr || pToBeDeleted == nullptr)
        return;

    // 1.删除非尾节点
    if (pToBeDeleted->m_pNext != nullptr)
    {
        ListNode* pNext = pToBeDeleted->m_pNext;
        pToBeDeleted->m_nValue = pNext->m_nValue;
        pToBeDeleted->m_pNext = pNext->m_pNext;

        delete pNext;
        pNext = nullptr;
    }
    // 2.链表只有一个节点,走到这表示没有进入第一个if条件，即pToBeDeleted->m_pNext == nullptr
    else if (*pListHead == pToBeDeleted)
    {
        delete pToBeDeleted;
        pToBeDeleted = nullptr;
        *pListHead = nullptr;
    }
    // 3.链表有多个节点，删除尾节点
    else
    {
        ListNode* pPreNode = *pListHead;
        while (pPreNode->m_pNext != pToBeDeleted)
        {
            pPreNode = pPreNode->m_pNext;
        }

        pPreNode->m_pNext = nullptr;
        delete pToBeDeleted;
        pToBeDeleted = nullptr;
    }
}

< Test Code>

void Test(ListNode* pListHead, ListNode* pNode)
{
    printf("The original list is: \n");
    PrintList(pListHead);

    printf("The node to be deleted is: ");
    PrintListNode(pNode);
    printf("\n");

    DeleteNode(&pListHead, pNode);

    printf("The result list is: \n");
    PrintList(pListHead);
    printf("\n");
}

// 链表中有多个结点，删除中间的结点
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);

    Test(pNode1, pNode3);

    DestroyList(pNode1);
}

// 链表中有多个结点，删除尾结点
void Test2()
{
    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);

    Test(pNode1, pNode5);

    DestroyList(pNode1);
}

// 链表中有多个结点，删除头结点
void Test3()
{
    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);

    Test(pNode1, pNode1);

    DestroyList(pNode1);
}

// 链表中只有一个结点，删除头结点
void Test4()
{
    ListNode* pNode1 = CreateListNode(1);

    Test(pNode1, pNode1);
}

// 链表为空
void Test5()
{
    Test(nullptr, nullptr);
}

测试结果：

---

2. 题目二：删除链表中重复的节点

　　在一个排序的链表中，如何删除重复的结点？例如，在链表1中重复结点被删除之后，链表如链表2所示。
1->2->2->3->3->4->5
1->4->5

注意：
1. 要删除所有重复的节点。
2. 假设链表中重复的节点都相邻。

< Function Code>

void DeleteDuplication(ListNode** pHead)
{
    if (pHead == nullptr || *pHead == nullptr) 
        return;

    ListNode* pPreNode = nullptr; //指向要删除的节点的前一个节点
    ListNode* pNode = *pHead; //指向当前节点

    while (pNode != nullptr)
    {
        ListNode* pNext = pNode->m_pNext;
        bool needDelete = false; //判断是否需要删除

        if (pNext != nullptr && pNext->m_nValue == pNode->m_nValue)
            needDelete = true;

        if (!needDelete) //不需要删除
        {
            pPreNode = pNode;
            pNode = pNext;
        }
        else
        {
            int value = pNode->m_nValue; //记录要删除的重复节点的值
            ListNode* pToBeDeleted = pNode; //指向要删除的节点

            while (pToBeDeleted != nullptr && pToBeDeleted->m_nValue == value) //如果是多个重复的节点在一起，那就要删除多个
            {
                pNext = pToBeDeleted->m_pNext; //记录要删除的节点的下一个节点
                delete pToBeDeleted;
                pToBeDeleted = pNext;
            }
            if (pPreNode == nullptr) //头结点就是重复的节点
                *pHead = pNext;
            else
                pPreNode->m_pNext = pNext;

            pNode = pNext;
        }
    }
}

< Test Code>

void Test(char* testName, ListNode** pHead, int* expectedValues, int expectedLength)
{
    if (testName != nullptr)
        printf("%s begins: ", testName);

    DeleteDuplication(pHead);

    int index = 0;
    ListNode* pNode = *pHead;
    while (pNode != nullptr && index < expectedLength)
    {
        if (pNode->m_nValue != expectedValues[index])
            break;

        pNode = pNode->m_pNext;
        index++;
    }

    if (pNode == nullptr && index == expectedLength)
        printf("Passed.\n");
    else
        printf("FAILED.\n");
}

// 某些结点是重复的
void Test1()
{
    ListNode* pNode1 = CreateListNode(1);
    ListNode* pNode2 = CreateListNode(2);
    ListNode* pNode3 = CreateListNode(3);
    ListNode* pNode4 = CreateListNode(3);
    ListNode* pNode5 = CreateListNode(4);
    ListNode* pNode6 = CreateListNode(4);
    ListNode* pNode7 = CreateListNode(5);

    ConnectListNodes(pNode1, pNode2);
    ConnectListNodes(pNode2, pNode3);
    ConnectListNodes(pNode6, pNode7);

    ListNode* pHead = pNode1;

    ConnectListNodes(pNode3, pNode4);
    ConnectListNodes(pNode4, pNode5);
    ConnectListNodes(pNode5, pNode6);
    int expectedValues[] = { 1, 2, 5 };
    Test("Test1", &pHead, expectedValues, sizeof(expectedValues) / sizeof(int));

    DestroyList(pHead);
}

// 没有重复的结点
void Test2()
{
    ListNode* pNode1 = CreateListNode(1);
    ListNode* pNode2 = CreateListNode(2);
    ListNode* pNode3 = CreateListNode(3);
    ListNode* pNode4 = CreateListNode(4);
    ListNode* pNode5 = CreateListNode(5);
    ListNode* pNode6 = CreateListNode(6);
    ListNode* pNode7 = CreateListNode(7);

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

    ListNode* pHead = pNode1;

    int expectedValues[] = { 1, 2, 3, 4, 5, 6, 7 };
    Test("Test2", &pHead, expectedValues, sizeof(expectedValues) / sizeof(int));

    DestroyList(pHead);
}

// 除了一个结点之外其他所有结点的值都相同
void Test3()
{
    ListNode* pNode1 = CreateListNode(1);
    ListNode* pNode2 = CreateListNode(1);
    ListNode* pNode3 = CreateListNode(1);
    ListNode* pNode4 = CreateListNode(1);
    ListNode* pNode5 = CreateListNode(1);
    ListNode* pNode6 = CreateListNode(1);
    ListNode* pNode7 = CreateListNode(2);

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

    ListNode* pHead = pNode1;

    int expectedValues[] = { 2 };
    Test("Test3", &pHead, expectedValues, sizeof(expectedValues) / sizeof(int));

    DestroyList(pHead);
}

// 所有结点的值都相同
void Test4()
{
    ListNode* pNode1 = CreateListNode(1);
    ListNode* pNode2 = CreateListNode(1);
    ListNode* pNode3 = CreateListNode(1);
    ListNode* pNode4 = CreateListNode(1);
    ListNode* pNode5 = CreateListNode(1);
    ListNode* pNode6 = CreateListNode(1);
    ListNode* pNode7 = CreateListNode(1);

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

    ListNode* pHead = pNode1;

    Test("Test4", &pHead, nullptr, 0);

    DestroyList(pHead);
}

// 所有结点都成对出现
void Test5()
{
    ListNode* pNode1 = CreateListNode(1);
    ListNode* pNode2 = CreateListNode(1);
    ListNode* pNode3 = CreateListNode(2);
    ListNode* pNode4 = CreateListNode(2);
    ListNode* pNode5 = CreateListNode(3);
    ListNode* pNode6 = CreateListNode(3);
    ListNode* pNode7 = CreateListNode(4);
    ListNode* pNode8 = CreateListNode(4);

    ConnectListNodes(pNode1, pNode2);
    ConnectListNodes(pNode2, pNode3);
    ConnectListNodes(pNode3, pNode4);
    ConnectListNodes(pNode4, pNode5);
    ConnectListNodes(pNode5, pNode6);
    ConnectListNodes(pNode6, pNode7);
    ConnectListNodes(pNode7, pNode8);

    ListNode* pHead = pNode1;

    Test("Test5", &pHead, nullptr, 0);

    DestroyList(pHead);
}

// 除了两个结点之外其他结点都成对出现
void Test6()
{
    ListNode* pNode1 = CreateListNode(1);
    ListNode* pNode2 = CreateListNode(1);
    ListNode* pNode3 = CreateListNode(2);
    ListNode* pNode4 = CreateListNode(3);
    ListNode* pNode5 = CreateListNode(3);
    ListNode* pNode6 = CreateListNode(4);
    ListNode* pNode7 = CreateListNode(5);
    ListNode* pNode8 = CreateListNode(5);

    ConnectListNodes(pNode1, pNode2);
    ConnectListNodes(pNode2, pNode3);
    ConnectListNodes(pNode3, pNode4);
    ConnectListNodes(pNode4, pNode5);
    ConnectListNodes(pNode5, pNode6);
    ConnectListNodes(pNode6, pNode7);
    ConnectListNodes(pNode7, pNode8);

    ListNode* pHead = pNode1;

    int expectedValues[] = { 2, 4 };
    Test("Test6", &pHead, expectedValues, sizeof(expectedValues) / sizeof(int));

    DestroyList(pHead);
}

// 链表中只有两个不重复的结点
void Test7()
{
    ListNode* pNode1 = CreateListNode(1);
    ListNode* pNode2 = CreateListNode(2);

    ConnectListNodes(pNode1, pNode2);

    ListNode* pHead = pNode1;

    int expectedValues[] = { 1, 2 };
    Test("Test7", &pHead, expectedValues, sizeof(expectedValues) / sizeof(int));

    DestroyList(pHead);
}

// 结点中只有一个结点
void Test8()
{
    ListNode* pNode1 = CreateListNode(1);

    ConnectListNodes(pNode1, nullptr);

    ListNode* pHead = pNode1;

    int expectedValues[] = { 1 };
    Test("Test8", &pHead, expectedValues, sizeof(expectedValues) / sizeof(int));

    DestroyList(pHead);
}

// 结点中只有两个重复的结点
void Test9()
{
    ListNode* pNode1 = CreateListNode(1);
    ListNode* pNode2 = CreateListNode(1);

    ConnectListNodes(pNode1, pNode2);

    ListNode* pHead = pNode1;

    Test("Test9", &pHead, nullptr, 0);

    DestroyList(pHead);
}

// 空链表
void Test10()
{
    ListNode* pHead = nullptr;

    Test("Test10", &pHead, nullptr, 0);
}

测试结果：

---

3. 测试所需的代码

ListNode* CreateListNode(int value) //创建节点
{
    ListNode* newNode = new ListNode;
    newNode->m_nValue = value;
    newNode->m_pNext = nullptr;

    return newNode;
}

void ConnectListNodes(ListNode* pNode1, ListNode* pNode2) //链接节点
{
    pNode1->m_pNext = pNode2;
}

void DestroyList(ListNode* pListHead)  //销毁链表
{
    if (pListHead == nullptr)
        return;

    ListNode* pCurNode = pListHead->m_pNext;
    while (pCurNode != nullptr)
    {
        delete pListHead;
        pListHead = pCurNode;
        pCurNode = pCurNode->m_pNext;
    }
    delete pListHead;
    pListHead = nullptr;
}

void PrintList(ListNode* pListHead) //打印链表
{
    ListNode* pCurNode = pListHead;

    while (pCurNode != nullptr)
    {
        printf("%d -> ", pCurNode->m_nValue);
        pCurNode = pCurNode->m_pNext;
    }
    printf("nullptr\n");
}

void PrintListNode(ListNode* pNode) //打印节点
{
    if (pNode != nullptr)
    {
        printf("%d ", pNode->m_nValue);
    }
    else
    {
        printf("nullptr");
    }
}