57. 删除链表中重复的结点

题目：在一个排序的链表中，如何删除重复的结点？例如，在图8.5(a)中重复结点被删除之后，链表如图8.5(b)所示。

思路：因为删除的有可能是头结点，所以采用二级指针，函数声明为 void delete(ListNode** pHead)；然后遍历链表，将当前结点的值和下一结点的值相同的结点都删除。为了保证删除之后链表仍然是相连的，序言保存当前即将删除结点的前一结点prevNode，和保存删除完后的下一个不重复结点lastNode，让prevNode指向lastNode。

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

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

ListNode* CreateListNode(int value)
{
    ListNode* node = new ListNode();
    node->m_nValue = value;
    node->m_pNext = NULL;

    return node;
}

void ConnectListNodes(ListNode* node1, ListNode* node2)
{
    if (node1 != NULL && node2 != NULL)
    {
        node1->m_pNext = node2;
    }
}

void PrintListNode(ListNode* pHead)
{
    if (pHead == NULL)
    {
        return;
    }

    while (pHead != NULL)
    {
        cout << pHead->m_nValue << " ";
        pHead = pHead->m_pNext;
    }

    cout << endl;

}

void DestroyList(ListNode* pHead)
{
    ListNode* node = pHead;

    while (node != NULL)
    {
        pHead = pHead->m_pNext;
        delete node;
        node = pHead;
    }
}

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

    ListNode* prevNode = NULL;
    ListNode* pNode = *pHead;

    while (pNode != NULL)
    {
        ListNode* pNext = pNode->m_pNext;
        bool needDelete = false;
        if (pNext != NULL && pNext->m_nValue == pNode->m_nValue)
        {
            needDelete = true;
        }

        if (!needDelete)
        {
            prevNode = pNode;
            pNode = pNode->m_pNext;
        }
        else
        {
            int value = pNode->m_nValue;
            ListNode* toBeDel = pNode;
            while (toBeDel != NULL && toBeDel->m_nValue == value)
            {
                pNext = toBeDel->m_pNext;
                delete toBeDel;
                toBeDel = NULL;

                toBeDel = pNext;
            }

            if (prevNode == NULL)
            {
                *pHead = pNext;
            }
            else
            {
                prevNode->m_pNext = pNext;
            }
            pNode = pNext;
        }
    }
}

void test1()
{
    ListNode* node1 = CreateListNode(1);
    ListNode* node2 = CreateListNode(2);
    ListNode* node3 = CreateListNode(3);
    ListNode* node4 = CreateListNode(4);
    ListNode* node5 = CreateListNode(5);
    ListNode* node6 = CreateListNode(6);
    ListNode* node7 = CreateListNode(5);

    ConnectListNodes(node1, node2);
    ConnectListNodes(node2, node3);
    ConnectListNodes(node3, node4);
    ConnectListNodes(node4, node5);
    ConnectListNodes(node5, node7);
    ConnectListNodes(node7, node6);

    PrintListNode(node1);

    DeleteDuplication(&node1);
    PrintListNode(node1);


}

int main()
{
    test1();

    return 0;
}