[已解决]单链表求助，实在没办法了

WFR

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

typedef struct
{
        int data;
        struct  ListNode* Next;
}ListNode;
void InitList(ListNode *L)
{
        L->data = 0;
        L->Next = NULL;
}
void Insert(ListNode* L)
{
        int i = 0,j=1;
        ListNode* node = NULL;
        while (j)
        {
                printf("你要输入的数值：");
                scanf("%d", &i);
                node->data = i;
                node ->Next= L->Next;
                L->Next = node;
                printf("是否输入：");
                scanf("%d", &j);
               
        }
       
       
}

int Display(ListNode* L)
{       
        ListNode* node;
        node = L;
        printf("表中数据：");
        while (node->Next)
        {
               
                node = node->Next;
                printf("%d",node->data);
        }

        return 1;
}
int main(void)
{       
        ListNode *Head=(ListNode*)malloc(sizeof(ListNode));
        InitList(Head);
        Insert(Head);
        Display(Head);

        return 0;
}

出现了死循环

最佳答案

月排行榜 / 总排行榜

某一个“天”

2024-9-13 17:33:25

球最佳~

在Insert函数中未正确分配内存给新节点：
您在Insert函数中尝试使用node指针来存储新节点的数据，但node在分配内存之前是指向NULL的。这会导致访问空指针的成员，从而产生未定义行为（通常是崩溃）。
在Display函数中访问最后一个节点的Next指针：
在Display函数中，当node指向最后一个节点时，您尝试访问node->Next（这将是NULL），然后没有打印换行符或分隔符。这会导致输出在同一行连续显示，并且由于while循环的条件是node->Next，实际上最后一个元素不会被打印。
循环结束条件设置问题：
您的Insert函数中的循环结束条件依赖于用户输入0来退出循环，但您实际上读取的是j的值。这可能不是最佳实践，因为用户可能需要输入非零值来退出循环。不过，这本身不是导致死循环的原因，但可能导致逻辑混乱。

1. #include <stdio.h>  
   
2. #include <stdlib.h>  
   
3.   
   
4. typedef struct ListNode {  
   
5.     int data;  
   
6.     struct ListNode* Next;  
   
7. } ListNode;  
   
8.   
   
9. void InitList(ListNode *L) {  
   
10.     L->data = 0;  // 通常头节点的数据不使用  
    
11.     L->Next = NULL;  
    
12. }  
    
13.   
    
14. void Insert(ListNode* L) {  
    
15.     int i;  
    
16.     int j = 1;  
    
17.     while (j) {  
    
18.         printf("你要输入的数值（输入0结束）：");  
    
19.         scanf("%d", &i);  
    
20.         if (i == 0) {  
    
21.             j = 0;  
    
22.             continue;  
    
23.         }  
    
24.         ListNode* node = (ListNode*)malloc(sizeof(ListNode));  // 分配内存  
    
25.         if (!node) {  
    
26.             perror("内存分配失败");  
    
27.             exit(EXIT_FAILURE);  
    
28.         }  
    
29.         node->data = i;  
    
30.         node->Next = L->Next;  
    
31.         L->Next = node;  
    
32.     }  
    
33. }  
    
34.   
    
35. void Display(ListNode* L) {  
    
36.     ListNode* node = L->Next;  // 从头节点的下一个节点开始  
    
37.     printf("表中数据：");  
    
38.     while (node) {  
    
39.         printf("%d ", node->data);  
    
40.         node = node->Next;  
    
41.     }  
    
42.     printf("\n");  // 添加换行符  
    
43. }  
    
44.   
    
45. int main(void) {  
    
46.     ListNode *Head = (ListNode*)malloc(sizeof(ListNode));  
    
47.     if (!Head) {  
    
48.         perror("内存分配失败");  
    
49.         exit(EXIT_FAILURE);  
    
50.     }  
    
51.     InitList(Head);  
    
52.     Insert(Head);  
    
53.     Display(Head);  
    
54.   
    
55.     // 释放链表内存（可选，通常根据需要决定是否释放）  
    
56.     // 这里略去释放链表内存的代码，因为它可能会变得复杂  
    
57.   
    
58.     free(Head);  // 释放头节点内存  
    
59.     return 0;  
    
60. }

复制代码

注意：我添加了对malloc的返回值进行检查，以确保内存分配成功。在实际应用中，您可能还需要在适当的时候释放分配的内存，以避免内存泄漏。但请注意，在简单示例中，可能并不总是需要释放所有内存，因为这可能会使代码变得复杂。此外，我还修改了Display函数，使其从头节点的下一个节点开始遍历，并在打印完所有元素后添加一个换行符。

跳转到最佳答案楼层

FishC

您在插入节点时遇到了死循环的问题，主要原因是您在插入节点时没有正确地分配内存给新节点。以下是修正后的代码：

1. :main.c
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. 
   
5. typedef struct ListNode {
   
6.     int data;
   
7.     struct ListNode* Next;
   
8. } ListNode;
   
9. 
   
10. void InitList(ListNode *L) {
    
11.     L->data = 0;
    
12.     L->Next = NULL;
    
13. }
    
14. 
    
15. void Insert(ListNode* L) {
    
16.     int i = 0, j = 1;
    
17.     ListNode* node = NULL;
    
18.     while (j) {
    
19.         printf("你要输入的数值：");
    
20.         scanf("%d", &i);
    
21.         node = (ListNode*)malloc(sizeof(ListNode)); // 分配内存给新节点
    
22.         node->data = i;
    
23.         node->Next = L->Next;
    
24.         L->Next = node;
    
25.         printf("是否继续输入（0表示否，1表示是）：");
    
26.         scanf("%d", &j);
    
27.     }
    
28. }
    
29. 
    
30. int Display(ListNode* L) {
    
31.     ListNode* node = L->Next; // 从第一个有效节点开始
    
32.     printf("表中数据：");
    
33.     while (node) {
    
34.         printf("%d ", node->data);
    
35.         node = node->Next;
    
36.     }
    
37.     printf("
    
38. ");
    
39.     return 1;
    
40. }
    
41. 
    
42. int main(void) {
    
43.     ListNode *Head = (ListNode*)malloc(sizeof(ListNode));
    
44.     InitList(Head);
    
45.     Insert(Head);
    
46.     Display(Head);
    
47. 
    
48.     return 0;
    
49. }

复制代码

### 主要修改点：
1. 在 `Insert` 函数中，每次插入新节点时都需要分配内存给 `node`，即 `node = (ListNode*)malloc(sizeof(ListNode));`。
2. 在 `Display` 函数中，应该从 `L->Next` 开始遍历，而不是从 `L` 开始，因为 `L` 是头节点，通常不存储有效数据。

这样修改后，您的单链表插入和显示功能应该可以正常工作了。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

某一个“天”

球最佳~

在Insert函数中未正确分配内存给新节点：
您在Insert函数中尝试使用node指针来存储新节点的数据，但node在分配内存之前是指向NULL的。这会导致访问空指针的成员，从而产生未定义行为（通常是崩溃）。
在Display函数中访问最后一个节点的Next指针：
在Display函数中，当node指向最后一个节点时，您尝试访问node->Next（这将是NULL），然后没有打印换行符或分隔符。这会导致输出在同一行连续显示，并且由于while循环的条件是node->Next，实际上最后一个元素不会被打印。
循环结束条件设置问题：
您的Insert函数中的循环结束条件依赖于用户输入0来退出循环，但您实际上读取的是j的值。这可能不是最佳实践，因为用户可能需要输入非零值来退出循环。不过，这本身不是导致死循环的原因，但可能导致逻辑混乱。

1. #include <stdio.h>  
   
2. #include <stdlib.h>  
   
3.   
   
4. typedef struct ListNode {  
   
5.     int data;  
   
6.     struct ListNode* Next;  
   
7. } ListNode;  
   
8.   
   
9. void InitList(ListNode *L) {  
   
10.     L->data = 0;  // 通常头节点的数据不使用  
    
11.     L->Next = NULL;  
    
12. }  
    
13.   
    
14. void Insert(ListNode* L) {  
    
15.     int i;  
    
16.     int j = 1;  
    
17.     while (j) {  
    
18.         printf("你要输入的数值（输入0结束）：");  
    
19.         scanf("%d", &i);  
    
20.         if (i == 0) {  
    
21.             j = 0;  
    
22.             continue;  
    
23.         }  
    
24.         ListNode* node = (ListNode*)malloc(sizeof(ListNode));  // 分配内存  
    
25.         if (!node) {  
    
26.             perror("内存分配失败");  
    
27.             exit(EXIT_FAILURE);  
    
28.         }  
    
29.         node->data = i;  
    
30.         node->Next = L->Next;  
    
31.         L->Next = node;  
    
32.     }  
    
33. }  
    
34.   
    
35. void Display(ListNode* L) {  
    
36.     ListNode* node = L->Next;  // 从头节点的下一个节点开始  
    
37.     printf("表中数据：");  
    
38.     while (node) {  
    
39.         printf("%d ", node->data);  
    
40.         node = node->Next;  
    
41.     }  
    
42.     printf("\n");  // 添加换行符  
    
43. }  
    
44.   
    
45. int main(void) {  
    
46.     ListNode *Head = (ListNode*)malloc(sizeof(ListNode));  
    
47.     if (!Head) {  
    
48.         perror("内存分配失败");  
    
49.         exit(EXIT_FAILURE);  
    
50.     }  
    
51.     InitList(Head);  
    
52.     Insert(Head);  
    
53.     Display(Head);  
    
54.   
    
55.     // 释放链表内存（可选，通常根据需要决定是否释放）  
    
56.     // 这里略去释放链表内存的代码，因为它可能会变得复杂  
    
57.   
    
58.     free(Head);  // 释放头节点内存  
    
59.     return 0;  
    
60. }

复制代码

注意：我添加了对malloc的返回值进行检查，以确保内存分配成功。在实际应用中，您可能还需要在适当的时候释放分配的内存，以避免内存泄漏。但请注意，在简单示例中，可能并不总是需要释放所有内存，因为这可能会使代码变得复杂。此外，我还修改了Display函数，使其从头节点的下一个节点开始遍历，并在打印完所有元素后添加一个换行符。