删除单链表中的重复节点(c语言版本)

最新推荐文章于 2024-05-12 20:44:59 发布
最新推荐文章于 2024-05-12 20:44:59 发布
阅读量1.4w 收藏 84
点赞数 15
分类专栏： 算法 数据结构 文章标签： 链表 重复节点
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tao_627/article/details/88687243
版权

这是一道经典的面试题，下面是我的研究和举一反三，特整理如下：

分为三种情形:

（1）删除有序链表的重复节点，重复节点一个都不留

（2）删除有序链表的重复节点，重复节点只留一个

（3）删除无序链表的重复节点，重复节点只留一个

下面是相关节点的定义：

typedef struct ListNode {
    int val;
    struct ListNode *next;                                                      
} ListNode;

ListNode* CreateListNode(int value){
    ListNode* pNode = (ListNode*)malloc(sizeof(ListNode));
    if(pNode == NULL){
        printf("failed to create ListNode\n");
        exit(-1);
    }   
       
    pNode->val = value;
    pNode->next = NULL;
    return pNode;
}      
       
void ConnectListNodes(ListNode* pCurrent, ListNode* pNext){
    if(pCurrent == NULL || pNext == NULL){
        printf("Error to connect two nodes\n");
        exit(-1);
    }   
       
    pCurrent->next = pNext;
}      
       
void DestroyListNode(ListNode* pNode){
    if(pNode != NULL){
        printf("-----delete list node [%d]-----\n", pNode->val);
        free(pNode);
    }   
}

下面给出解读：

1）下面的代码针对删除有序单链表的重复节点，重复节点都删除。

 

ListNode* DeleteDuplication(ListNode* pHead){
    if(pHead == NULL)
        return NULL;
 
    //指向当前节点前最晚访问过的不重复节点；                                    
    ListNode* pPre = NULL;
    //指向当前正在处理的节点；
    ListNode* pCur = pHead;
    //指向当前节点后面的值相同的节点；
    ListNode* pNext = NULL;
    //临时存放节点
    ListNode* pNode = NULL;
 
    while(pCur != NULL){
        //下一个节点与当前节点相同
        if(pCur->next != NULL && pCur->next->val == pCur->val){
            pNext = pCur->next;
            //找出所有与当前节点值相同的节点，因为是排序过的链表，它们都在一切
            while(pNext != NULL && pNext->val == pCur->val){
                pNode = pNext->next;
                DestroyListNode(pNext);
                pNext = pNode;
            }   
            //现在要删除pCur->...->pNext->之间的所有节点
            //如果pCur是链表头，要更新链表头的位置
            if(pCur == pHead)
                pHead = pNext;
            else
                pPre->next = pNext;
            DestroyListNode(pCur);
            pCur = pNext;
        }else{
            pPre = pCur;
            pCur = pCur->next;
        }   
    }   
 
    return pHead;
}

 2）下面是有序链表，只留一个的

//删除有序链表中的重复节点，仅保留一个，使用2指针定位
//考虑到这里需要用到测试框架，这里必须使用二级指针
ListNode* DeleteDuplication(ListNode** pHead){
    if(pHead == NULL || *pHead == NULL)                                         
        return NULL;
            
    //指向当前正在处理的节点；
    ListNode* pCur = *pHead;
    //指向当前节点后面的值相同的节点；
    ListNode* pNext = NULL;
    //临时存放节点
    ListNode* pNode = NULL;
            
    while(pCur != NULL){
        //下一个节点与当前节点相同
        if(pCur->next != NULL && pCur->next->val == pCur->val){
            pNext = pCur->next;
            //找出所有与当前节点值相同的节点，因为是排序过的链表，它们都在一切
            while(pNext != NULL && pNext->val == pCur->val){
                pNode = pNext->next;
                DestroyListNode(pNext);
                pNext = pNode;
            }   
            //将当前节点指向后续不同值的首个节点
            pCur->next = pNext;
        }   
        pCur = pCur->next;
    }       
         
    return *pHead;
}

3）下面是无序链表，只留一个的(注意：这里会兼容前面的两种情况)

//删除无序链表中的重复节点，仅保留一个，使用2指针定位                           
//考虑到这里需要用到测试框架，这里必须使用二级指针
ListNode* DeleteDuplication(ListNode** pHead){
    if(pHead == NULL || *pHead == NULL)
        return NULL; 
                     
    //指向当前正在处理的节点；
    ListNode* p = *pHead;
    //用于遍历p之后的节点；
    ListNode* q = NULL;
    ListNode* r = NULL;
                     
    while(p != NULL){
        q = p;       
        //若后面有节点与当前节点相同，将其统统删除
        while(q->next != NULL){
            if(q->next->val == p->val){
                //保存需要删掉的节点
                r = q->next;
                //需要删掉的节点的前后节点相接
                q->next = r->next;
                DestroyListNode(r);
            }        
            else{    
                q = q->next;
            }        
        }            
        p = p->next; 
    }                
                     
    return *pHead;   
}

下面是针对第三种情况编写的用户测试的截图：

下面是我针对第三种情况的源码实现：

//description: 描述删除单链表的重复节点
//date: 2019-03-20


#include <stdio.h>
#include <stdlib.h>
#include <time.h>


typedef struct ListNode {
    int val;
    struct ListNode *next;
} ListNode;


ListNode* CreateListNode(int value){
    ListNode* pNode = (ListNode*)malloc(sizeof(ListNode));
    if(pNode == NULL){
        printf("failed to create ListNode\n");
        exit(-1);
    }

    pNode->val = value;
    pNode->next = NULL;
    return pNode;
}

void ConnectListNodes(ListNode* pCurrent, ListNode* pNext){
    if(pCurrent == NULL || pNext == NULL){
        printf("No necessary to connect two nodes\n");
        return;
    }

    pCurrent->next = pNext;
}

void DestroyListNode(ListNode* pNode){
    if(pNode != NULL){
        printf("-----delete list node [%d]-----\n", pNode->val);
        free(pNode);
    }
}

//在表头节点后面拼接n个随机元素的单链表
void CreateList(ListNode **pHead, int n){
    if(pHead == NULL || *pHead == NULL){
        printf("Invalid List header ptr\n");
        exit(-1);
    }

    int i;
    srand(time(0));
    ListNode *pNew, *pNode = *pHead;
    for(i=0; i<n; i++){
        pNew = (ListNode*)malloc(sizeof(ListNode));
        pNew->val = rand()%100 + 1;
        pNode->next = pNew;

        pNode = pNew;
    }
    pNode->next = NULL;
}

void DestroyList(ListNode* pHead){
    ListNode *pNode = pHead;
    while(pNode != NULL){
        pHead = pNode->next;
        free(pNode);
        pNode = pHead;
    }
}

void PrintList(ListNode* pHead){
    printf("------------print list begin-----------");
    ListNode* pNode = pHead;
    while(pNode != NULL){
        printf("%d ", pNode->val);
        pNode = pNode->next;
    }
    printf("------------print list end-------------");
}

//==================业务函数定义到这里=============


//删除无序链表中的重复节点，仅保留一个，使用2指针定位
//考虑到这里需要用到测试框架，这里必须使用二级指针
ListNode* DeleteDuplication(ListNode** pHead){
    if(pHead == NULL || *pHead == NULL)
        return NULL;

    //指向当前正在处理的节点；
    ListNode* p = *pHead;
    //用于遍历p之后的节点；
    ListNode* q = NULL;
    ListNode* r = NULL;

    while(p != NULL){
        q = p;
        //若后面有节点与当前节点相同，将其统统删除
        while(q->next != NULL){
            if(q->next->val == p->val){
                //保存需要删掉的节点
                r = q->next;
                //需要删掉的节点的前后节点相接
                q->next = r->next;
                DestroyListNode(r);
            }
            else{
                q = q->next;
            }
        }
        p = p->next;
    }

    return *pHead;
}

//==================测试代码=======================
void Test(char* testName, ListNode** pHead, int* expectedValues, int expectedLength){
    if(testName != NULL)
        printf("%s begins:\n", testName);

    //======真正要干的活儿==========
    ListNode* pNode = DeleteDuplication(pHead);

    int idx = 0;
    while(pNode !=NULL && idx < expectedLength){
        if(pNode->val != expectedValues[idx])
            break;

        pNode = pNode->next;
        idx++;
    }

    if(pNode == NULL && idx == expectedLength)
        printf("%s Passed.\n", testName);
    else
        printf("%s FAILED.\n", testName);
}

//--------------下面测试一些特例情况--------------

//某些节点是重复的
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, 3, 4, 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[] = {1, 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;

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

    //删除该单链表
    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;

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

    //删除该单链表
    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[] = {1, 2, 3, 4, 5};
    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);
    ListNode* pNode2 = CreateListNode(1);

    ConnectListNodes(pNode1, pNode2);

    ListNode* pHead = pNode1;

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

    //删除该单链表
    DestroyList(pHead);
}

//无序链表中某些节点是重复的
void Test9(){
    //构建一个单链表
    ListNode* pNode1 = CreateListNode(11);
    ListNode* pNode2 = CreateListNode(2);
    ListNode* pNode3 = CreateListNode(3);
    ListNode* pNode4 = CreateListNode(3);
    ListNode* pNode5 = CreateListNode(9);
    ListNode* pNode6 = CreateListNode(4);
    ListNode* pNode7 = CreateListNode(5);
    ListNode* pNode8 = CreateListNode(5);
    ListNode* pNode9 = CreateListNode(3);

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

    ListNode* pHead = pNode1;

    int expectedValues[] = {11, 2, 3, 9, 4, 5};
    Test("Test9", &pHead, expectedValues, sizeof(expectedValues) / sizeof(int));

    //删除该单链表
    DestroyList(pHead);
}

//链表中只有一个节点
void Test10(){
    //构建一个单链表
    ListNode* pNode1 = CreateListNode(1);

    ConnectListNodes(pNode1, NULL);

    ListNode* pHead = pNode1;

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

    //删除该单链表
    DestroyList(pHead);
}

//空链表
void Test11(){
    ListNode* pHead = NULL;

    Test("Test11", &pHead, NULL, 0);
}

int main(int argc, char** argv){
    Test1();
    Test2();
    Test3();
    Test4();
    Test5();
    Test6();
    Test7();
    Test8();
    Test9();
    Test10();
    Test11();

    return 0;
}

参考文献

[1].《剑指Offer名企面试官精讲典型编程题》第2版 面试题18-2

 

 

 

雪峰流云
关注
  • 15
    点赞
  • 踩
  • 84
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
将非递减有序的单链表中值相同的多余结点删除
01-25
编写算法程序将非递减有序的单链表中值相同的多余结点删除。设线性表为顺序存储结构。
PTA 3 删除单链表的重复结点
Virgo_616的博客
11-28 380
PTA 3 删除单链表的重复结点
删除链表中重复的节点
JennyTheArtist的博客
04-25 101
题目：在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5 方法一：pre从虚节点开始，永远处在非重复节点的位置上，连接非重复节点。头结点head向后搜索。 /* public class ListNode { int v...
【数据结构】链表
最新发布
小林的博客
05-12 397
​ 链表不同于顺序表，顺序表底层采用数组作为存储容器，需要分配一块连续且完整的内存空间进行使用，而链表不需要，它通过一个指针来连接各个分散的结点，形成了一个链状的结构，每个结点存放一个元素，以及一个指向下一个结点的指针，通过这样一个一个相连，最后形成了链表。​ 它不需要申请连续的空间，只需要按顺序连接即可，虽然物理上可能不想邻，但在逻辑上依然是每个元素相邻存放的，这种结构就叫链表（单链表）
12删除单链表中数值重复的节点
m0_62595744的博客
10-14 304
易知删除需要前驱指针和指向节点的指针，可以将前驱指针和指针进行判断，如果有重复，就用前驱指针进行删除。1.先找到重复的节点，再去删除。
在单链表中删除值相同的多余的结点
qq_51691366的博客
10-13 2072
从前往后遍历单链表，双层for循环或者while循环即可完成操作！依次遍历内层循环，使用外层循环作为对照，如果和外层循环中当前遍历的元素值相同，即可执行删除操作！
C语言--单链表中重复元素的删除
m0_73770012的博客
05-03 1498
C语言--单链表中重复元素的删除 按照数据输入的相反顺序（逆位序）建立一个单链表，并将单链表中重复的元素删除（值相同的元素只保留最后输入的一个）。
数据结构与算法——删除单链表中的重复结点
beilizhang的博客
07-26 8816
如何删除单链表中的重复结点 方法一：递归 对于一个结点head，首先把链表head->next作为头结点的链表中的重复项删除，然后遍历head->next为头结点的链表中的元素，判断遍历到的元素是否与head结点元素相等，如果相等，则删除。对于head->next为头结点的链表而言，可以使用同样的思路来删除以head->next->next为头结点的链表中的重复元素。因此可以使用递归的方法求解 struct ListNode { int val; ListNod
链表之删除单链表中的重复节点
weixin_44952783的博客
11-27 3071
力扣面试题02.01移除重复节点
C语言实现单链表（常规操作）
06-19
C语言实现单链表（常规操作） LinkList CreateHeadListH(); // 头插法创建单链表 LinkList CreateHeadListT(); // 尾插法创建单链表 int ListEmpty(); // 单链表判空 int ListLength(); // 求单链表长度...
C语言创建和操作单链表数据结构的实例教程
09-02
单链表是一种重要的数据结构，尤其在C语言中，它被广泛用来实现动态数组，以克服固定大小数组的局限性。下面将详细解释单链表的原理、特点以及如何使用C语言来创建和操作。 首先，我们要理解为什么需要链表。数组...
C语言程序设计-通讯录
01-18
2. **单链表（Singly Linked Lists）**：虽然在提供的代码中并未直接使用链表，但在描述中提到了单链表，这暗示了可能通过链表实现动态内存分配和数据存储。链表是一种线性数据结构，每个节点包含数据和指向下一个...
C语言程序设计-二手房信息管理系统
01-18
【二手房信息管理系统】是一个基于C语言的程序设计项目，旨在训练学生的编程技能，特别是C语言中的文件操作和单链表的运用。系统设计包括问题定义、系统设计、系统实现、系统维护和归纳总结五个部分。 1. **问题...
C语言贪吃蛇经典小游戏
08-28
这样的设计允许我们用单链表来表示蛇的动态变化，方便地添加和删除蛇的身体部分。 游戏的函数框架通常包括以下几个关键部分： 1. `StartGame()`：初始化游戏，包括设置初始蛇的位置、食物的位置、游戏状态等。 2. `...
删除链表中重复的节点（经典链表面试题）
热门推荐
GangStudyIT的博客
06-08 2万+
题目 删除链表中重复的节点 在一个排序，如何删除重复的节点？ 例如：1 -&amp;gt; 2 -&amp;gt; 3 -&amp;gt; 3 -&amp;gt; 4 删除后是 1 -&amp;gt; 2 -&amp;gt; 4 分析 在链表的面试题中，重要一点是要注意对链表的情况要全部考虑到，或许你在看到上面的例子后按照给出的例子大笔一挥，写出代码后，那么你很可能就已经凉凉。。。 首先我们应该考虑大部分...
一学就会---移除链表相同元素
weixin_62976968的博客
06-06 650
让你一看就会的 移除链表相同元素题解！
c语言实现链表中重复数据的删除(5)
Yannie's Blog
04-09 9575
对比与数组中我们删除重复元素有这么一些方法：
链表：单链表中重复元素的删除
qq_45828951的博客
03-09 693
数据结构实验之链表七：单链表中重复元素的删除 Problem Description 按照数据输入的相反顺序（逆位序）建立一个单链表，并将单链表中重复的元素删除（值相同的元素只保留最后输入的一个）。 Input 第一行输入元素个数 n (1 <= n <= 15)； 第二行输入 n 个整数，保证在 int 范围内。 Output 第一行输出初始链表元素个数； 第二行输出按照...
15.1-单链表中删除值相同的多余结点
小太阳晨曦
09-08 1214
单链表中删除值相同的多余结点
用C语言删除单链表中重复的元素
03-27
以下是用C语言删除单链表中重复元素的代码： ```c #include #include struct Node { int data; struct Node* next; }; void deleteDuplicates(struct Node* head) { struct Node *cur, *pre, *temp; cur = ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值