Delete a duplicate node in a linked list _ delete duplicate nodes in a linked list

Question: In a sorted list, how to delete duplicate nodes. For example, the following figure:

The detailed implementation code is as follows:

Delete duplicate node void deleteduplication (listnode** phead) {if (Phead = = NULL | | *phead = NULL) return;
    listnode* Pprenode = 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) {pprenode = Pnode;
        Pnode = pnode->m_pnext;    
            else {int value = pnode->m_nvalue;
            listnode* Ptobedel = Pnode; while (Ptobedel!= NULL && ptobedel->m_nvalue = = value) {Pnext = Ptobedel->m_pne
                
                xt
                Delete Ptobedel;
                
                Ptobedel = NULL;
            Ptobedel = Pnext;
            } if (Pprenode = = NULL) *phead = Pnext; ElSe pprenode->m_pnext = pnext;
        Pnode = Pnext; }}//==================== test Code ==================== void Test (char* testname, listnode** phead, int* expecte
    
    dvalues, int expectedlength) {if (testname!= NULL) printf ("%s begins:", testname);
    
    Deleteduplication (Phead);
    int index = 0;
    listnode* pnode = *phead;
            while (Pnode!= NULL && Index < expectedlength) {if (Pnode->m_nvalue!= Expectedvalues[index])
            
        Break
        Pnode = pnode->m_pnext;
    index++;
    } if (Pnode = = NULL && index = = expectedlength) printf ("passed.\n");
else printf ("failed.\n");
    }//Some nodes are duplicated 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 (PNode3, PNODE4);
    Connectlistnodes (PNode4, PNODE5);
    Connectlistnodes (PNODE5, pNode6);

    Connectlistnodes (PNode6, PNode7);
    
    listnode* phead = pNode1;
    int expectedvalues[] = {1, 2, 5};
    
    Test ("Test1", &phead, Expectedvalues, sizeof (expectedvalues)/sizeof (int));
Destroylist (Phead);
    }//All nodes are unique 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);
    }//All nodes are duplicated except one 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);
    }//All nodes are duplicated 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, NULL, 0);
Destroylist (Phead);
    }//All nodes are duplicated in pairs 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, NULL, 0);
Destroylist (Phead);
    }//nodes are duplicated in pairs except two 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);
    }//A list with two unique nodes 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);

    //Only one node in a list void Test8 () {listnode* pNode1 = Createlistnode (1);

    Connectlistnodes (PNode1, NULL);
    
    listnode* phead = pNode1;
    int expectedvalues[] = {1};
    
    Test ("Test8", &phead, Expectedvalues, sizeof (expectedvalues)/sizeof (int));
Destroylist (Phead); //A list with only two duplidated nodes void Test9 () {listnode* pNode1 = Createlistnode (1);

    listnode* PNode2 = Createlistnode (1);

    Connectlistnodes (PNode1, PNode2);
    
    listnode* phead = pNode1;
    
    Test ("Test9", &phead, NULL, 0);
Destroylist (Phead);
    
    }//Empty list void Test10 () {listnode* phead = NULL;
Test ("Test10", &phead, NULL, 0);
    int main (int argc, char* argv[]) {Test1 ();
    Test2 ();
    Test3 ();
    Test4 ();
    Test5 ();
    Test6 ();
    Test7 ();
    Test8 ();
    Test9 ();
        
    Test10 ();
return 0; }