[已解决]求大佬帮我看下这个c语言链表哪出问题了

微恋晨曦

1. #include<stdio.h>
   
2. #include<stdlib.h>
   
3. typedef int Elemtype;
   
4. typedef struct LNode                                //定义一个结构体
   
5. {
   
6.     Elemtype data;                                   //结点的数据域
   
7.     struct LNode *next;                              //节点的指针域
   
8. }LNode , *LinkList;                                  //指针类型
   
9. 
   
10. int InitList(LinkList L)                            //带有头节点的单链表的初始化
    
11. {
    
12.     L= (LinkList)malloc(sizeof(LNode));            
    
13.     if (!L)                                          //储存分配失败退出
    
14.     {
    
15.         printf("分配内存失败！\n");
    
16.         exit(0);
    
17.     }
    
18.     L->next = NULL;                                 //空表长度为null                  
    
19.     return 0;
    
20. }
    
21. 
    
22. int LengthList(LinkList L)                    //计算链表长度
    
23. {
    
24.     int length = 0;
    
25.     LinkList p;
    
26.     p = L->next;
    
27.     while (p)
    
28.     {
    
29.         length++;
    
30.         p = p->next;
    
31.     }
    
32.     return length;
    
33. }
    
34. 
    
35. int GetElem(LinkList L, int i, Elemtype e)            //用e返回L中第i个元素值
    
36. {
    
37.     LinkList p;                                     //初始化，p指向首元结点，计数器j=1
    
38.     int j = 1;
    
39.     p = L->next;                                    //顺序链表向后扫描，直到p为空或者p指向第i个元素
    
40.     while (p && j < i)
    
41.     {
    
42.         p = p->next;                                //p指向下一个元素
    
43.         ++j;
    
44.     }
    
45.     if (!p || j > i)                              //i不合法
    
46.     {
    
47.         printf("查询不到该元素！\n");
    
48.         return 0;
    
49.     }
    
50.     e = p->data;                                   
    
51.     return 0;
    
52. }
    
53. 
    
54. 
    
55. void CreateList_F(LinkList L,int n)            //头插法创建一个单链表，n为要插入的元素个数
    
56. {
    
57.     int i;
    
58.     LinkList p;
    
59.     L = (LinkList)malloc(sizeof(LNode));
    
60.     L->next = NULL;
    
61.     printf("请输入您要插入元素的个数：");
    
62.     scanf("%d", &n);
    
63.     printf("请输入你要插入的元素值(用空格隔开)：");
    
64.     for (i = n; i >0;--i)
    
65.     {
    
66.         p = (LNode*)malloc(sizeof(LNode));
    
67.         scanf_s("%d", &p->data);
    
68.         p->next = L->next;
    
69.         L->next = p;
    
70.     }
    
71.      
    
72. }
    
73. 
    
74. int InsertList_L(LinkList L, int i, Elemtype e)            //在L中第i个位置插入元素e
    
75. {
    
76.     LinkList p, s;
    
77.     int j = 0;
    
78.     p = L;
    
79.     while (p && j < i)                                  //寻找第i-1结点
    
80.     {                                                      
    
81.         p = p->next;
    
82.         ++j;
    
83.     }
    
84.     if (!p || j > i) exit(1);                         //i大于表长+1或者小于1
    
85.     s = (LinkList)malloc(sizeof(LNode));               //生成新结点s
    
86.     s->data = e;                                      //将结点的数据域置为e
    
87.     s->next = p->next;                                 //将结点s插入L中
    
88.     p->next = s;
    
89.     return 0;
    
90. }
    
91. 
    
92. int DeleteList_L(LinkList L, int i)                //删除L中第i个元素，并用e返回其值
    
93. {
    
94.     LinkList p, q;
    
95.     int j = 0;
    
96.     p = L;
    
97.     printf("请输入要删除的结点位置：");
    
98.      
    
99.     while (p->next && j < i-1)                  //寻找第i个结点，并令p指向其前驱
    
100.     {
     
101.         p = p->next;
     
102.         ++j;
     
103.     }
     
104.     if (!(p->next) || j > i) exit(1);            //删除位置不合理
     
105.     q = p->next;                                 //临时保存被删除结点的地址以备释放
     
106.     p->next = q->next;                           //改变删除结点的前驱结点指针域
     
107.     free(q); //释放
     
108.    return 0;
     
109. }
     
110. 
     
111. void ShowList(LinkList L)                    //打印整个链表
     
112. {
     
113.     LinkList p;
     
114.     p = L->next;
     
115.     if (p == NULL)
     
116.     {
     
117.         printf("这是一个空链表！\n");
     
118.     }
     
119.     printf("单链表");
     
120.     while (p)
     
121.     {
     
122.         printf(" -> %d", p->data);
     
123.         p = p->next;
     
124.     }
     
125.     printf("\n");
     
126. }
     
127. 
     
128. main()
     
129. {
     
130.   LinkList L;
     
131.   int n;
     
132.   int i,k;
     
133.   printf("单链表的操作：\n");
     
134.   printf("\t1.头插法建立单链表\n");
     
135.   printf("\t2.输出单链表\n");   
     
136.   printf("\t3.删除结点\n");
     
137.   printf("\t4.退出\n");
     
138.   do
     
139.   {
     
140. 
     
141.       printf("选择所需功能: ");
     
142.       scanf("%d",&k);
     
143.       switch(k)
     
144.       {
     
145.           case 1:CreateList_F( L, n);
     
146.                   break;
     
147.          case 2:printf("单链表为：\n");
     
148.                  ShowList(L);
     
149.                   break;
     
150.    
     
151.           case 3:
     
152.                   DeleteList_L( L, i);
     
153.                   break;
     
154.          
     
155.           case 4:printf("退出");
     
156.               exit(0);
     
157.             default:printf("输入错误\n");
     
158.               exit(0);
     
159.         }
     
160.     }while(1);
     
161. }

复制代码

最佳答案

小会

2021-5-30 20:02:06

删除和显示输出链表函数，增加对空链表的判断及反馈，供参考：

1. int DeleteList_L(LinkList L, int i)                //删除L中第i个元素，并用e返回其值
   
2. {
   
3.     LinkList p, q;
   
4.     int j = 0;
   
5.     p = L;
   
6.     if(L == NULL){
   
7.        printf("这是一个空链表！\n");
   
8.        return -1;
   
9.     }
   
10.     //printf("请输入要删除的结点位置：");
    
11. 
    
12.     while (p->next && j < i-1)                  //寻找第i个结点，并令p指向其前驱
    
13.     {
    
14.         p = p->next;
    
15.         ++j;
    
16.     }
    
17.     if (!(p->next) || j > i) exit(1);            //删除位置不合理
    
18.     q = p->next;                                 //临时保存被删除结点的地址以备释放
    
19.     p->next = q->next;                           //改变删除结点的前驱结点指针域
    
20.     free(q); //释放
    
21.     return 0;
    
22. }
    
23. 
    
24. void ShowList(LinkList L)                    //打印整个链表
    
25. {
    
26.     LinkList p;
    
27.     if (L == NULL)
    
28.     {
    
29.         printf("这是一个空链表！\n");
    
30.         return;
    
31.     }
    
32.     printf("单链表");
    
33.     p = L->next;
    
34.     while (p)
    
35.     {
    
36.         printf(" -> %d", p->data);
    
37.         p = p->next;
    
38.     }
    
39.     printf("\n");
    
40. }

复制代码

跳转到最佳答案楼层

星烨

1. int InitList(LinkList L)                           
   
2. {
   
3.     L= (LinkList)malloc(sizeof(LNode));             //修改形参没有用处，离开这个函数形参就结束存在了
   
4.     if (!L)                                         
   
5.     {
   
6.         printf("分配内存失败！\n");
   
7.         exit(0);
   
8.     }
   
9.     L->next = NULL;                                 
   
10.     return 0;
    
11. }

复制代码

王增海

1. #include<stdio.h>
   
2. #include<stdlib.h>
   
3. 
   
4. typedef int Elemtype;
   
5. typedef struct LNode                                //定义一个结构体
   
6. {
   
7.     Elemtype data;                                   //结点的数据域
   
8.     struct LNode *next;                              //节点的指针域
   
9. }LNode , *LinkList;                                  //指针类型
   
10. 
    
11. int InitList(LinkList L)                            //带有头节点的单链表的初始化
    
12. {
    
13.     L= (LinkList)malloc(sizeof(LNode));
    
14.     if (!L)                                          //储存分配失败退出
    
15.     {
    
16.         printf("分配内存失败！\n");
    
17.         exit(0);
    
18.     }
    
19.     L->next = NULL;                                 //空表长度为null
    
20.     return 0;
    
21. }
    
22. 
    
23. int LengthList(LinkList L)                    //计算链表长度
    
24. {
    
25.     int length = 0;
    
26.     LinkList p;
    
27.     p = L->next;
    
28.     while (p)
    
29.     {
    
30.         length++;
    
31.         p = p->next;
    
32.     }
    
33.     return length;
    
34. }
    
35. 
    
36. int GetElem(LinkList L, int i, Elemtype e)            //用e返回L中第i个元素值
    
37. {
    
38.     LinkList p;                                     //初始化，p指向首元结点，计数器j=1
    
39.     int j = 1;
    
40.     p = L->next;                                    //顺序链表向后扫描，直到p为空或者p指向第i个元素
    
41.     while (p && j < i)
    
42.     {
    
43.         p = p->next;                                //p指向下一个元素
    
44.         ++j;
    
45.     }
    
46.     if (!p || j > i)                              //i不合法
    
47.     {
    
48.         printf("查询不到该元素！\n");
    
49.         return 0;
    
50.     }
    
51.     e = p->data;
    
52.     return 0;
    
53. }
    
54. 
    
55. 
    
56. void CreateList_F(LinkList *L,int n)            //头插法创建一个单链表，n为要插入的元素个数
    
57. {
    
58.     int i;
    
59.     LinkList p;
    
60.     (*L) = (LinkList)malloc(sizeof(LNode));
    
61.     (*L)->next = NULL;
    
62.     printf("请输入您要插入元素的个数：");
    
63.     scanf("%d", &n);
    
64.     printf("请输入你要插入的元素值(用空格隔开)：");
    
65.     for (i = n; i >0;--i)
    
66.     {
    
67.         p = (LNode*)malloc(sizeof(LNode));
    
68.         //scanf_s("%d", &p->data);
    
69.         scanf("%d", &p->data);
    
70.         p->next = (*L)->next;
    
71.         (*L)->next = p;
    
72.     }
    
73. 
    
74. }
    
75. 
    
76. int InsertList_L(LinkList L, int i, Elemtype e)            //在L中第i个位置插入元素e
    
77. {
    
78.     LinkList p, s;
    
79.     int j = 0;
    
80.     p = L;
    
81.     while (p && j < i)                                  //寻找第i-1结点
    
82.     {
    
83.         p = p->next;
    
84.         ++j;
    
85.     }
    
86.     if (!p || j > i) exit(1);                         //i大于表长+1或者小于1
    
87.     s = (LinkList)malloc(sizeof(LNode));               //生成新结点s
    
88.     s->data = e;                                      //将结点的数据域置为e
    
89.     s->next = p->next;                                 //将结点s插入L中
    
90.     p->next = s;
    
91.     return 0;
    
92. }
    
93. 
    
94. int DeleteList_L(LinkList L, int i)                //删除L中第i个元素，并用e返回其值
    
95. {
    
96.     LinkList p, q;
    
97.     int j = 0;
    
98.     p = L;
    
99.     //printf("请输入要删除的结点位置：");
    
100. 
     
101.     while (p->next && j < i-1)                  //寻找第i个结点，并令p指向其前驱
     
102.     {
     
103.         p = p->next;
     
104.         ++j;
     
105.     }
     
106.     if (!(p->next) || j > i) exit(1);            //删除位置不合理
     
107.     q = p->next;                                 //临时保存被删除结点的地址以备释放
     
108.     p->next = q->next;                           //改变删除结点的前驱结点指针域
     
109.     free(q); //释放
     
110.     return 0;
     
111. }
     
112. 
     
113. void ShowList(LinkList L)                    //打印整个链表
     
114. {
     
115.     LinkList p;
     
116.     p = L->next;
     
117.     if (p == NULL)
     
118.     {
     
119.         printf("这是一个空链表！\n");
     
120.     }
     
121.     printf("单链表");
     
122.     while (p)
     
123.     {
     
124.         printf(" -> %d", p->data);
     
125.         p = p->next;
     
126.     }
     
127.     printf("\n");
     
128. }
     
129. 
     
130. //main()
     
131. int main()
     
132. {
     
133.     LinkList L;
     
134.     int n;
     
135.     int i,k;
     
136.     printf("单链表的操作：\n");
     
137.     printf("\t1.头插法建立单链表\n");
     
138.     printf("\t2.输出单链表\n");
     
139.     printf("\t3.删除结点\n");
     
140.     printf("\t4.退出\n");
     
141.     do
     
142.     {
     
143. 
     
144.         printf("选择所需功能: ");
     
145.         scanf("%d",&k);
     
146.         switch(k)
     
147.         {
     
148.             case 1:CreateList_F(&L, n);
     
149.                    break;
     
150.             case 2:printf("单链表为：\n");
     
151.                    ShowList(L);
     
152.                    break;
     
153. 
     
154.             case 3:
     
155.                    printf("请输入要删除的结点位置: ");
     
156.                    scanf("%d", &i);
     
157.                    DeleteList_L( L, i);
     
158.                    break;
     
159. 
     
160.             case 4:printf("退出");
     
161.                    exit(0);
     
162.             default:printf("输入错误\n");
     
163.                     exit(0);
     
164.         }
     
165.     }while(1);
     
166. }

复制代码

供参考～

小会

删除和显示输出链表函数，增加对空链表的判断及反馈，供参考：

1. int DeleteList_L(LinkList L, int i)                //删除L中第i个元素，并用e返回其值
   
2. {
   
3.     LinkList p, q;
   
4.     int j = 0;
   
5.     p = L;
   
6.     if(L == NULL){
   
7.        printf("这是一个空链表！\n");
   
8.        return -1;
   
9.     }
   
10.     //printf("请输入要删除的结点位置：");
    
11. 
    
12.     while (p->next && j < i-1)                  //寻找第i个结点，并令p指向其前驱
    
13.     {
    
14.         p = p->next;
    
15.         ++j;
    
16.     }
    
17.     if (!(p->next) || j > i) exit(1);            //删除位置不合理
    
18.     q = p->next;                                 //临时保存被删除结点的地址以备释放
    
19.     p->next = q->next;                           //改变删除结点的前驱结点指针域
    
20.     free(q); //释放
    
21.     return 0;
    
22. }
    
23. 
    
24. void ShowList(LinkList L)                    //打印整个链表
    
25. {
    
26.     LinkList p;
    
27.     if (L == NULL)
    
28.     {
    
29.         printf("这是一个空链表！\n");
    
30.         return;
    
31.     }
    
32.     printf("单链表");
    
33.     p = L->next;
    
34.     while (p)
    
35.     {
    
36.         printf(" -> %d", p->data);
    
37.         p = p->next;
    
38.     }
    
39.     printf("\n");
    
40. }

复制代码