[已解决]删除重复数据的节点，删除不干净

zhenhaowa66

void deleteIdentica_ListNode(PLIST list) {//删除重复数据的节点
        if (list == NULL) {
                perror("链表地址是NULL，即将退出程序！\n");
                exit(-1);
        }

        PNODE pFirst = list->Head.next; //指向链表第一个有真实数据的节点
        PNODE pindex = list->Head.next; //指向链表第一个有真实数据的节点
        PNODE pSecond = pFirst->next; //指向链表第二个有真实数据的节点
        PNODE delete = NULL;           //指向待删除的重复数据的节点

        for (int i = 0; i < list->M_size - 1; i++) { // list->M_size 链表的有效节点
               
                for (int j = i + 1; j < list->M_size; j++) {
                        if (pindex->data == pSecond->data) {
                                delete = pSecond;
                                pFirst->next = pSecond->next;
                                pSecond = pSecond->next;
                                free(delete);
                                list->M_size--;
                        }
                        else {
                                pSecond = pSecond->next;
                                pFirst = pFirst->next;
                        }
                       
                }
               
                pindex = pindex->next;
                pFirst = pindex;
                pSecond = pFirst->next;
        }
        return;
}

//  哪位大佬给看看程序有没有什么问题，为什么程序
运行后重复数据节点没有删除干净？
14592 1774 12583 32215 26879 1688 2288 2288 2288 2288 2288 2288 2288 2288 2288 2
288 8259 857 4989 11010
__________________________________
14592 1774 12583 32215 26879 1688 2288 2288 8259 857 4989 11010
__________________________________
程序运行了:30 毫秒!
系统日期：2021-11-8
系统时间：9-57-51
请按任意键继续. . .

最佳答案

月排行榜 / 总排行榜

jackz007

2021-11-8 10:40:50

        试试这个代码呢

1. void deleteIdentica_ListNode(PLIST list)
   
2. {
   
3.         PLIST p1 , p2 , p3                                       ;
   
4.         if(list) {
   
5.                 for(p1 = list ; p1 && p1 -> next ; p1 = p1 -> next) {   
   
6.                         for(p3 = p1 , p2 = p3 -> next ; p2 ; p2 = p3 -> next) {
   
7.                                 if(p2 -> data == p1 -> data) {
   
8.                                         p3 -> next = p2 -> next  ;
   
9.                                         free(p2)                 ;
   
10.                                 } else {
    
11.                                         p3 = p2                  ;
    
12.                                 }
    
13.                         }
    
14.                 }
    
15.         } else {
    
16.                 fprintf(stderr , "Error : Empty Data Link !\n" ) ;
    
17.         }
    
18. }

复制代码

跳转到最佳答案楼层

jackz007

        试试这个代码呢

1. void deleteIdentica_ListNode(PLIST list)
   
2. {
   
3.         PLIST p1 , p2 , p3                                       ;
   
4.         if(list) {
   
5.                 for(p1 = list ; p1 && p1 -> next ; p1 = p1 -> next) {   
   
6.                         for(p3 = p1 , p2 = p3 -> next ; p2 ; p2 = p3 -> next) {
   
7.                                 if(p2 -> data == p1 -> data) {
   
8.                                         p3 -> next = p2 -> next  ;
   
9.                                         free(p2)                 ;
   
10.                                 } else {
    
11.                                         p3 = p2                  ;
    
12.                                 }
    
13.                         }
    
14.                 }
    
15.         } else {
    
16.                 fprintf(stderr , "Error : Empty Data Link !\n" ) ;
    
17.         }
    
18. }

复制代码

zhenhaowa66

非常感谢！你的这个确实是精妙，可以删除干净，
这个代码我还是有些不太看得懂，需要些时间去消化；
可是我还是搞不明白我的那个代码问题出在哪里了；

zhenhaowa66

for(p1 = list ; p1 -> next ; p1 = p1 -> next) {   //这里p1->next 怎么理解啊
                        for(p3 = p1 , p2 = p3 -> next ; p2 ; p2 = p3 -> next) {//这个p2有什么作用，后面这个不是重复了吗？可以省略吗

jhq999

zhenhaowa66 发表于 2021-11-8 14:03
for(p1 = list ; p1 -> next ; p1 = p1 -> next) {   //这里p1->next 怎么理解啊
                        ...

第一个p1->next 判断条件，最后一个的next是NULL,就是假退出循环；
p2=p3->next和上面p1->next一样做为是否到了最后的循环条件,而且而循环体里p2和p1重复后，把p3和p2的next联系起来，然后释放p2

zhenhaowa66

jackz007 发表于 2021-11-8 10:40
试试这个代码呢

你这个代码好像还有点问题，我换了数据就行不通，崩了

jhq999

zhenhaowa66 发表于 2021-11-8 15:11
你这个代码好像还有点问题，我换了数据就行不通，崩了

1. for(p3 = p1 , p2 = p3 -> next ; p3->next ;p2 = p3 -> next)//试试，他没考虑到最后一个重复，这时p3->next=p2->next=NULL,而p2只是释放不为NULL,p2= p3 -> next=NULL再进入循环体必然崩

复制代码

编程就是不断的调试

jackz007

zhenhaowa66 发表于 2021-11-8 15:11
你这个代码好像还有点问题，我换了数据就行不通，崩了

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. typedef struct node {
   
5.         int data           ;
   
6.         struct node * next ;
   
7. } * PLIST                  ;
   
8. 
   
9. void show(PLIST head)
   
10. {
    
11.         if(head) {
    
12.                 for(int c = 0 ; head ; head = head -> next) {
    
13.                         if(c && ! (c % 8)) printf("\n")                          ;
    
14.                         else if(c) printf(" , ")                                 ;
    
15.                         printf("%5d" , head -> data)                             ;
    
16.                         c ++                                                     ;
    
17.                 }
    
18.         } else {
    
19.                 fprintf(stderr , "错误：链表为空！\n")                           ;
    
20.         }
    
21.         printf("\n")                                                             ;
    
22. }
    
23. 
    
24. PLIST add(PLIST * head)
    
25. {
    
26.         PLIST p , p1 , p2                                                        ;
    
27.         int d                                                                    ;
    
28.         if(* head) for(p1 = * head , p2 = NULL ; p1 ; p2 = p1 , p1 = p1 -> next) ;
    
29.         else p1 = p2 = NULL                                                      ;
    
30.         printf("输入节点数据 :\n ")                                              ;
    
31.         for(;; p2 = p) {
    
32.                 scanf("%d" , & d)                                                ;
    
33.                 if(d > 0) {                        
    
34.                         if(p = (PLIST) malloc(sizeof(struct node))) {
    
35.                                 p -> data = d                                    ;
    
36.                                 p -> next = NULL                                 ;
    
37.                                 if(p2) p2 -> next = p                            ;
    
38.                                 else * head = p                                  ;
    
39.                         } else {
    
40.                                 fprintf(stderr , "内存分配失败！\n")             ;
    
41.                                 * head = p                                       ;
    
42.                                 break                                            ;
    
43.                         }
    
44.                 } else {
    
45.                         break                                                    ;
    
46.                 }
    
47.         }
    
48.         return * head                                                            ;
    
49. }
    
50. 
    
51. void deleteIdentica_ListNode(PLIST list)
    
52. {
    
53.         PLIST p1 , p2 , p3                                       ;
    
54.         if(list) {
    
55.                 for(p1 = list ; p1 && p1 -> next ; p1 = p1 -> next) {   
    
56.                         for(p3 = p1 , p2 = p3 -> next ; p2 ; p2 = p3 -> next) {
    
57.                                 if(p2 -> data == p1 -> data) {
    
58.                                         p3 -> next = p2 -> next  ;
    
59.                                         free(p2)                 ;
    
60.                                 } else {
    
61.                                         p3 = p2                  ;
    
62.                                 }
    
63.                         }
    
64.                 }
    
65.         } else {
    
66.                 fprintf(stderr , "Error : Empty Data Link !\n" ) ;
    
67.         }
    
68. }
    
69. 
    
70. void destroy(PLIST head)
    
71. {
    
72.         PLIST p1 , p2           ;
    
73.         for(p2 = NULL , p1 = head ; p1 ; p1 = p2) {
    
74.                 p2 = p1 -> next ;
    
75.                 free(p1)        ;
    
76.         }
    
77. }
    
78. 
    
79. int main(void)
    
80. {
    
81.         PLIST head = NULL             ;
    
82.         add(& head)                   ;
    
83.         printf("\n")                  ;
    
84.         printf("去除重复前：\n")      ;
    
85.         show(head)                    ;
    
86.         deleteIdentica_ListNode(head) ;
    
87.         printf("去除重复后：\n")      ;
    
88.         show(head)                    ;
    
89.         destroy(head)                 ;
    
90. }

复制代码

        编译、运行实况：

1. D:\0002.Exercise\C>g++ -o x x.c
   
2. 
   
3. D:\0002.Exercise\C>x
   
4. 输入节点数据 :
   
5. 14592 1774 12583 32215 26879 1688 2288 2288 2288 2288 2288 2288 2288 2288 2288
   
6. 2288 8259 857 4989 11010 0
   
7. 
   
8. 去除重复前：
   
9. 14592 ,  1774 , 12583 , 32215 , 26879 ,  1688 ,  2288 ,  2288
   
10. 2288 ,  2288 ,  2288 ,  2288 ,  2288 ,  2288 ,  2288 ,  2288
    
11. 8259 ,   857 ,  4989 , 11010
    
12. 去除重复后：
    
13. 14592 ,  1774 , 12583 , 32215 , 26879 ,  1688 ,  2288 ,  8259
    
14.   857 ,  4989 , 11010
    
15. 
    
16. D:\0002.Exercise\C>

复制代码

        这个代码在输入的节点数据值小于 1 时结束输入。
        用这个代码测试你的数据，我倒是想知道，什么样的数据能让它崩溃！

zhenhaowa66

jackz007 发表于 2021-11-8 16:35
编译、运行实况：

        这个代码在输入的节点数据值小于 1 时结束输入。

谢谢你了，我开始测试了个极端的例子，山到只剩最后一个才崩掉的，只要有2个节点就不会崩

jackz007

zhenhaowa66 发表于 2021-11-8 16:42
谢谢你了，我开始测试了个极端的例子，山到只剩最后一个才崩掉的，只要有2个节点就不会崩

1.                 for(p1 = list ; p1 -> next ; p1 = p1 -> next) {   
   
2.                         for(p3 = p1 , p2 = p3 -> next ; p2 ; p2 = p3 -> next) {

复制代码

        第一句位于两个分号中间的 p1 -> next 等价于 p1 -> next != NULL，下面 for 语句中位于两个分号中间的 p2 同样是这个意思。
        指针的 NULL 就是指针 0 值，对应的逻辑值为 false。只要指针不是 NULL，就一定是 true。

jhq999

jackz007 发表于 2021-11-8 16:52
第一句位于两个分号中间的 p1 -> next 等价于 p1 -> next != NULL，下面 for 语句中位于两个 ...

14592 1774 12583 32215 26879 1688 2288 2288 2288 2288 2288 2288 2288 2288 2288
2288 8259 857 4989 11010 11010 0

1. for(p1 = list ; p1  ; p1 = p1 -> next) {   
   
2.                         for(p3 = p1 , p2 = p3 -> next ; p3->next ; p2 = p3 -> next)
   
3. {
   
4. .........
   
5. }
   
6. }

复制代码

jackz007

jhq999 发表于 2021-11-8 17:04
14592 1774 12583 32215 26879 1688 2288 2288 2288 2288 2288 2288 2288 2288 2288
2288 8259 857 49 ...

     2、8 楼的代码已经修正，请你再测。

jackz007

zhenhaowa66 发表于 2021-11-8 16:42
谢谢你了，我开始测试了个极端的例子，山到只剩最后一个才崩掉的，只要有2个节点就不会崩

      2、8 楼的代码已经修改了，就用你先前的极端例子测。

jhq999

jackz007 发表于 2021-11-8 17:27
2、8 楼的代码已经修正，请你再测。

献丑了,基本功比较差,居然以为赋初值后先条件后运算

zhenhaowa66

jackz007 发表于 2021-11-8 17:33
2、8 楼的代码已经修改了，就用你先前的极端例子测。

厉害了！确实是这样怎么搞都行

zhenhaowa66

jackz007 发表于 2021-11-8 16:52
第一句位于两个分号中间的 p1 -> next 等价于 p1 -> next != NULL，下面 for 语句中位于两个 ...

感谢耐心讲解！现在基本看明白了，之前没要见过这样的for语句，不知道还可以这样搞for语句

zhenhaowa66

jackz007 发表于 2021-11-8 17:27
2、8 楼的代码已经修正，请你再测。

现在我也搞清楚了我的代码为什么删不干净就是不应该j=i+1;直接j=0;就没有问题了
就用排序里面的冒泡法就可以解决了，
void deleteIdentica_ListNode(PLIST list) {//删除重复数据
        if (list == NULL) {
                perror("链表地址是NULL，即将退出程序！\n");
                exit(-1);
        }
        PNODE pFirst = list->Head.next; //指向链表第一个有真实数据的节点
        PNODE pSecond = pFirst->next; //指向链表第二个有真实数据的节点
        PNODE delete = NULL;           //指向待删除的重复数据的节点
        for (int i = 0; i < list->M_size - 1; i++) {
                for (int j = 0; j < list->M_size - i; j++); {
                        if (pFirst->data == pSecond->data) {
                                delete = pSecond;
                                pFirst->next = pSecond->next;
                                free(delete);
                                pSecond = pFirst->next;
                        }
                }

        }
        return;
}