[已解决]爱学习的我又来啦！麻烦大佬帮忙看看！谢谢

isdkz

您目前的理解是正确的。在deleteNode函数中，x和head指向同一个链表。

x在函数中用于遍历和更新链表，当遍历完成时，x指向链表的尾节点。所以在函数中返回x时，实际上返回的是链表尾节点的指针地址。

而head始终指向链表的头节点，所以正确的返回值应该是head。

为了修复deleteNode函数，您应该在函数最后返回head，而不是x：

1. struct Node *deleteNode(struct Node *head)
   
2. {
   
3.     if(head == NULL)
   
4.     {
   
5.         return head;
   
6.     }
   
7.    
   
8.     struct Node *x = head;
   
9. 
   
10.     while(x->next != NULL)
    
11.     {
    
12.         if(x->value == x->next->value)
    
13.         {
    
14.             x->next = x->next->next;
    
15.         }
    
16.         else
    
17.         {
    
18.             x = x->next;
    
19.         }
    
20.     }
    
21.    
    
22.     return head;
    
23. }

复制代码

这样修改后，您的程序将能够正确地去除链表中的重复元素并输出结果。

isdkz

a905448839 发表于 2023-4-11 21:32
那如果这个题不是开始让我以顺序录入链表，如果是随机的链表值 如
1 2 1 2 5 8 5 8 1 2 3 这样不是相邻 ...

如果链表中的元素是无序的，您可以使用双重循环遍历链表以去除重复元素。

下面是一个修改后的 deleteNode 函数，它可以处理无序链表中的重复元素：

1. struct Node *deleteNode(struct Node *head)
   
2. {
   
3.     if(head == NULL)
   
4.     {
   
5.         return head;
   
6.     }
   
7.    
   
8.     struct Node *current = head;
   
9.     struct Node *inner_current, *prev;
   
10. 
    
11.     while (current != NULL)
    
12.     {
    
13.         inner_current = current->next;
    
14.         prev = current;
    
15.         while (inner_current != NULL)
    
16.         {
    
17.             if (current->value == inner_current->value)
    
18.             {
    
19.                 prev->next = inner_current->next;
    
20.                 free(inner_current);
    
21.                 inner_current = prev->next;
    
22.             }
    
23.             else
    
24.             {
    
25.                 prev = inner_current;
    
26.                 inner_current = inner_current->next;
    
27.             }
    
28.         }
    
29.         current = current->next;
    
30.     }
    
31.    
    
32.     return head;
    
33. }

复制代码

这个函数使用双重循环遍历链表。外层循环 (current) 从头节点开始，内层循环 (inner_current) 从 current 的下一个节点开始。

在内层循环中，如果找到与 current 节点值相同的 inner_current 节点，就将其从链表中删除并释放内存。外层循环继续处理下一个节点，直到遍历完整个链表。