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

a905448839

此代码中去重返回出来的链表有问题 好像头节点变成了最后尾节点
比如链表1 1 2 2 3 4 5
返回出只有一个5
看了答案去重函数中应该是return head；
但是我想知道 因为x是指向了*head的地址 他们是一个链表
为什么返回x是尾节点 返回head是头节点呢？
（我有尝试去理解 因为在去重函数中  head一直没有产生变化 只在最开始被x指向了一次  所以一直是头节点
然后x节点位置 也就是每次循环x当前节点在向后推，推移到最后一个节点 所以返回出去的是最后一个节点
return出去的x也只是这个单链表的最后一个节点的指针地址？ 最开始我一直想成return出去的x是一个单链表。。所以我最开始的想法是错误的，现在的理解正确吗）

1. 
   
2. 
   
3. #include<stdio.h>
   
4. #include<stdlib.h>
   
5. 
   
6. struct Node
   
7. {
   
8.         int value;
   
9.         struct Node *next;
   
10. };
    
11. 
    
12. void printNode(struct Node *head);
    
13. void insertNode(struct Node **head, int value);
    
14. struct Node *deleteNode(struct Node *head);
    
15. 
    
16. 
    
17. void insertNode(struct Node **head, int value)
    
18. {
    
19.         struct Node *previous;//current上一个节点的指针
    
20.         struct Node *current;//当前位置   指向比value大的节点指针
    
21.         struct Node *new;
    
22.        
    
23.         current = *head;
    
24.         previous = NULL;
    
25.        
    
26.         while(current != NULL && current->value < value)
    
27.         {
    
28.                 previous = current;
    
29.                 current = current->next;
    
30.         }
    
31.         new = (struct Node *)malloc(sizeof(struct Node));
    
32.         if(new == NULL)
    
33.         {
    
34.                 printf("内存分配失败！\n");
    
35.                 exit(1);
    
36.         }
    
37.        
    
38.         new->value = value;
    
39.         //previous->next = new;  这个先不用写 后面要判断他是不是为NULL
    
40.         new->next = current;
    
41.        
    
42.         if(previous == NULL)//previous为NULL只有一种情况（因为把current赋值给previous 且current不为NULL才能赋值）
    
43.                             //所以current本身一进来就为NULL 空的单链表
    
44.         {
    
45.                 *head = new;//所以将*head指针修改为new    这个new是唯一一个节点
    
46. 
    
47.         }
    
48.         else
    
49.         previous->next = new;
    
50. 
    
51. 
    
52. }
    
53. 
    
54. void printNode(struct Node *head)
    
55. {
    
56.         struct Node *current;
    
57.        
    
58.         current = head;
    
59.         while(current != NULL)
    
60.         {
    
61.                 printf("%d ",current->value);
    
62.                 current = current->next;
    
63. 
    
64.         }
    
65.         putchar('\n');
    
66. 
    
67. }
    
68. 
    
69. struct Node *deleteNode(struct Node *head)
    
70. {
    
71.        
    
72.          if(head == NULL)
    
73.         {
    
74.             return head;
    
75.         }
    
76.         
    
77.         struct Node *x = head;
    
78. 
    
79.        
    
80.         while(x->next != NULL)
    
81.         {
    
82.                 if(x->value == x->next->value)
    
83.                 {
    
84.                         x->next = x->next->next;
    
85.                 }
    
86.                 else
    
87.                 {
    
88.                         x = x->next;
    
89.                 }
    
90.         }
    
91.        
    
92.         return x;
    
93. 
    
94. }
    
95. 
    
96. 
    
97. int main(void)
    
98. {
    
99.         struct Node *head = NULL;
    
100.         int input;
     
101.        
     
102.         while(1)
     
103.         {
     
104.                 printf("请输入一个整数（输入-1表示结束）：");
     
105.                 scanf("%d",&input);
     
106.                 if(input == -1)
     
107.                 {
     
108.                         break;       
     
109.                 }
     
110.                 insertNode(&head, input);
     
111.                
     
112.         }  
     
113.         printf("输入的单链表是：");
     
114.         printNode(head);
     
115.         printf("去重之后的单链表是：");
     
116.         printNode(deleteNode(head));
     
117.        
     
118.         return 0;
     
119. }
     
120. 
     
121. 
     
122. 
     

复制代码

最佳答案

月排行榜 / 总排行榜

isdkz

2023-4-11 20:56:41

您目前的理解是正确的。在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

您目前的理解是正确的。在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. }

复制代码

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

a905448839

isdkz 发表于 2023-4-11 20:56
您目前的理解是正确的。在deleteNode函数中，x和head指向同一个链表。

x在函数中用于遍历和更新链表，当 ...

那如果这个题不是开始让我以顺序录入链表，如果是随机的链表值 如
1 2 1 2 5 8 5 8 1 2 3 这样不是相邻的 该如何去重呢？

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 节点，就将其从链表中删除并释放内存。外层循环继续处理下一个节点，直到遍历完整个链表。

a905448839

isdkz 发表于 2023-4-11 21:37
如果链表中的元素是无序的，您可以使用双重循环遍历链表以去除重复元素。

下面是一个修改后的 deleteN ...

感谢！