[已解决]（悬赏贴）求个大佬求助，帮我解答一下本题

a905448839

本题要求实现一个函数，将两个链表表示的递增整数序列合并为一个非递减的整数序列。

函数接口定义：

1. List Merge( List L1, List L2 );

复制代码

其中List结构定义如下：

1. typedef struct Node *PtrToNode;
   
2. struct Node {
   
3.     ElementType Data; /* 存储结点数据 */
   
4.     PtrToNode   Next; /* 指向下一个结点的指针 */
   
5. };
   
6. typedef PtrToNode List; /* 定义单链表类型 */

复制代码

L1和L2是给定的带头结点的单链表，其结点存储的数据是递增有序的；函数Merge要将L1和L2合并为一个非递减的整数序列。应直接使用原序列中的结点，返回归并后的带头结点的链表头指针。

裁判测试程序样例：

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. typedef int ElementType;
   
5. typedef struct Node *PtrToNode;
   
6. struct Node {
   
7.     ElementType Data;
   
8.     PtrToNode   Next;
   
9. };
   
10. typedef PtrToNode List;
    
11. 
    
12. List Read(); /* 细节在此不表 */
    
13. void Print( List L ); /* 细节在此不表；空链表将输出NULL */
    
14. 
    
15. List Merge( List L1, List L2 );
    
16. 
    
17. int main()
    
18. {
    
19.     List L1, L2, L;
    
20.     L1 = Read();
    
21.     L2 = Read();
    
22.     L = Merge(L1, L2);
    
23.     Print(L);
    
24.     Print(L1);
    
25.     Print(L2);
    
26.     return 0;
    
27. }
    
28. 
    
29. /* 你的代码将被嵌在这里 */

复制代码

我的代码：

1. List Merge( List L1, List L2 )
   
2. {
   
3.     List head,temp;
   
4.     head = temp = (List)malloc(sizeof(struct Node));
   
5.    
   
6.         L1 = L1->Next;
   
7.         L2 = L2->Next;
   
8. 
   
9. 
   
10.       while(L1 && L2)
    
11.      {
    
12.         if(L1->Data <= L2->Data)
    
13.         {
    
14.                 temp->Next = L1;
    
15.                 L1 = L1->Next;
    
16.         }
    
17.         else
    
18.         {
    
19.                 temp->Next = L2;
    
20.                 L2 = L2->Next;
    
21.         }
    
22.         temp = temp->Next;
    
23.     }
    
24.    
    
25.     if(L1)
    
26.     {
    
27.         while(L1)
    
28.         {
    
29.             temp->Next = L1;
    
30.             L1 = L1->Next;
    
31.             temp = temp->Next;
    
32.         }
    
33.         temp->Next = NULL;
    
34.     }
    
35.    
    
36.     else if(L2)
    
37.     {
    
38.          while(L2)
    
39.         {
    
40.             temp->Next = L2;
    
41.             L2 = L2->Next;
    
42.             temp = temp->Next;
    
43.         }
    
44.         temp->Next = NULL;
    
45.     }
    
46.     else
    
47.         temp->Next = NULL;
    
48. 
    
49.     //到这里L1 L2为NULL 运行到后面在main函数里打印出L1 L2为原始头节点。。
    
50. 
    
51. 
    
52.     return head;
    
53. }

复制代码

实例测试：

结果图片：



我在函数里通过传进去结构体指针L1 L2修改L1 L2的节点位置 最后返回head  最后在main函数里打印出来的链表却是原始节点 按照正常情况下  在Merge函数里 L1 L2都为NULL。

函数是传值操作，但是传入的L1 L2是结构体指针  所以传入的L1 L2应该是地址吧？那为什么在Merge函数里做的修改都没有用  那如果需要修改 要怎样才行呢？

比如在main函数里 a = 4;  int *p = a;  我把p传进一个函数里做修改，最后回到main函数里打印a的值 能够做修改  这里传递指针p和结构体指针有什么区别呢？ 为什么结构体指针传进去不能做修改呢？ 求解答 十分感谢！

最佳答案

月排行榜 / 总排行榜

人造人

2023-6-18 18:13:57

我确实没认真看题，^_^
我是先直接看的代码

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. typedef int ElementType;
   
5. typedef struct Node *PtrToNode;
   
6. 
   
7. struct Node {
   
8.     ElementType Data;
   
9.     PtrToNode Next;
   
10. };
    
11. 
    
12. typedef PtrToNode List;
    
13. 
    
14. List Read(); /* 细节在此不表 （也就是说提交的时候可以不考虑，不过还是要写的！） */
    
15. void Print(List L); /* 细节在此不表；空链表将输出NULL   （同上）*/
    
16. List Merge(List L1, List L2);
    
17. 
    
18. 
    
19. // 你是不是忘了写这个函数了？
    
20. void list_free(List L) {
    
21.     if(L) list_free(L->Next);
    
22.     free(L);
    
23. }
    
24. 
    
25. int main(void) {
    
26.     List L1, L2, L;
    
27.     L1 = Read();
    
28.     L2 = Read();
    
29.     L = Merge(L1, L2);
    
30.     Print(L);
    
31.     Print(L1);
    
32.     Print(L2);
    
33.     list_free(L);
    
34. 
    
35.     // 现在就可以free了
    
36.     list_free(L1);
    
37.     list_free(L2);
    
38.     // 要共用节点的话，这两个就只能单独释放了
    
39.     //free(L1);
    
40.     //free(L2);
    
41.     return 0;
    
42. }
    
43. 
    
44. /* 你的代码将被嵌在这里 */
    
45. List Read() {
    
46.     int n, i;
    
47.     scanf("%d", &n);
    
48.     //List L = (List)malloc(sizeof(PtrToNode)); /// 申请一个头结点
    
49.     //List L = malloc(sizeof(PtrToNode));       // 这是C语言，没必要强制转换
    
50.     //List L = malloc(sizeof(struct Node));     // 是PtrToNode还是struct Node？
    
51.     List L = malloc(sizeof(*L));                // 对吧？管他什么类型了
    
52.     L->Next = NULL;                           // 头指针为空
    
53.     if(n)                                     // 当n不是0时
    
54.     {
    
55.         List r = L; /// r是一个中间变量的节点
    
56.         for(i = 0; i < n; i++) {
    
57.             //List p = (List)malloc(sizeof(struct Node));
    
58.             List p = malloc(sizeof(*p));
    
59.             //scanf("%d", &(p->Data)); // 尾插法
    
60.             scanf("%d", &p->Data);  // 尾插法
    
61.             r->Next = p;
    
62.             r = p;
    
63.         }
    
64.         r->Next = NULL;
    
65.     }
    
66.     return L;
    
67. }
    
68. 
    
69. void Print(List L) {
    
70.     List p = L->Next;
    
71.     if(p) {
    
72.         List r;
    
73.         r = L;
    
74.         while(r->Next) {
    
75.             r = r->Next;
    
76.             printf("%d ", r->Data);
    
77.         }
    
78.     } else {
    
79.         printf("NULL");
    
80.     }
    
81.     printf("\n");
    
82. }
    
83. 
    
84. #if 0
    
85. // 好了，知道定义了
    
86. List Merge(List L1, List L2) {
    
87.     List L = malloc(sizeof(*L));
    
88.     L->Next = NULL;
    
89.     List *px = &L->Next;
    
90.     List p1 = L1->Next;
    
91.     List p2 = L2->Next;
    
92.     while(p1 && p2) {
    
93.         ElementType v;
    
94.         ElementType a = p1->Data;
    
95.         ElementType b = p2->Data;
    
96.         if(a < b) {
    
97.             v = a; p1 = p1->Next;
    
98.         } else {
    
99.             v = b; p2 = p2->Next;
    
100.         }
     
101.         *px = malloc(sizeof(**px));
     
102.         (*px)->Data = v;
     
103.         (*px)->Next = NULL;
     
104.         px = &(*px)->Next;
     
105.     }
     
106.     while(p1) {
     
107.         *px = malloc(sizeof(**px));
     
108.         (*px)->Data = p1->Data;
     
109.         (*px)->Next = NULL;
     
110.         p1 = p1->Next;
     
111.         px = &(*px)->Next;
     
112.     }
     
113.     while(p2) {
     
114.         *px = malloc(sizeof(**px));
     
115.         (*px)->Data = p2->Data;
     
116.         (*px)->Next = NULL;
     
117.         p2 = p2->Next;
     
118.         px = &(*px)->Next;
     
119.     }
     
120.     return L;
     
121. }
     
122. #else
     
123. List Merge(List L1, List L2) {
     
124.     List head, temp;
     
125.     //head = temp = (List)malloc(sizeof(struct Node));
     
126.     head = temp = malloc(sizeof(*head));
     
127. 
     
128.     List L1_bak = L1;
     
129.     List L2_bak = L2;
     
130. 
     
131.     L1 = L1->Next;
     
132.     L2 = L2->Next;
     
133. 
     
134.     while(L1 && L2) {
     
135.         if(L1->Data <= L2->Data) {
     
136.             temp->Next = L1;
     
137.             L1 = L1->Next;
     
138.         } else {
     
139.             temp->Next = L2;
     
140.             L2 = L2->Next;
     
141.         }
     
142.         temp = temp->Next;
     
143.     }
     
144. 
     
145.     if(L1) {
     
146.         while(L1) {
     
147.             temp->Next = L1;
     
148.             L1 = L1->Next;
     
149.             temp = temp->Next;
     
150.         }
     
151.         temp->Next = NULL;
     
152.     }
     
153.     else if(L2) {
     
154.         while(L2) {
     
155.             temp->Next = L2;
     
156.             L2 = L2->Next;
     
157.             temp = temp->Next;
     
158.         }
     
159.         temp->Next = NULL;
     
160.     } else
     
161.         temp->Next = NULL;
     
162. 
     
163.     // 到这里L1 L2为NULL 运行到后面在main函数里打印出L1 L2为原始头节点。。
     
164.     L1_bak->Next = NULL;
     
165.     L2_bak->Next = NULL;
     
166. 
     
167.     return head;
     
168. }
     
169. #endif
     

复制代码

跳转到最佳答案楼层

人造人

我确实没认真看题，^_^
我是先直接看的代码

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. typedef int ElementType;
   
5. typedef struct Node *PtrToNode;
   
6. 
   
7. struct Node {
   
8.     ElementType Data;
   
9.     PtrToNode Next;
   
10. };
    
11. 
    
12. typedef PtrToNode List;
    
13. 
    
14. List Read(); /* 细节在此不表 （也就是说提交的时候可以不考虑，不过还是要写的！） */
    
15. void Print(List L); /* 细节在此不表；空链表将输出NULL   （同上）*/
    
16. List Merge(List L1, List L2);
    
17. 
    
18. 
    
19. // 你是不是忘了写这个函数了？
    
20. void list_free(List L) {
    
21.     if(L) list_free(L->Next);
    
22.     free(L);
    
23. }
    
24. 
    
25. int main(void) {
    
26.     List L1, L2, L;
    
27.     L1 = Read();
    
28.     L2 = Read();
    
29.     L = Merge(L1, L2);
    
30.     Print(L);
    
31.     Print(L1);
    
32.     Print(L2);
    
33.     list_free(L);
    
34. 
    
35.     // 现在就可以free了
    
36.     list_free(L1);
    
37.     list_free(L2);
    
38.     // 要共用节点的话，这两个就只能单独释放了
    
39.     //free(L1);
    
40.     //free(L2);
    
41.     return 0;
    
42. }
    
43. 
    
44. /* 你的代码将被嵌在这里 */
    
45. List Read() {
    
46.     int n, i;
    
47.     scanf("%d", &n);
    
48.     //List L = (List)malloc(sizeof(PtrToNode)); /// 申请一个头结点
    
49.     //List L = malloc(sizeof(PtrToNode));       // 这是C语言，没必要强制转换
    
50.     //List L = malloc(sizeof(struct Node));     // 是PtrToNode还是struct Node？
    
51.     List L = malloc(sizeof(*L));                // 对吧？管他什么类型了
    
52.     L->Next = NULL;                           // 头指针为空
    
53.     if(n)                                     // 当n不是0时
    
54.     {
    
55.         List r = L; /// r是一个中间变量的节点
    
56.         for(i = 0; i < n; i++) {
    
57.             //List p = (List)malloc(sizeof(struct Node));
    
58.             List p = malloc(sizeof(*p));
    
59.             //scanf("%d", &(p->Data)); // 尾插法
    
60.             scanf("%d", &p->Data);  // 尾插法
    
61.             r->Next = p;
    
62.             r = p;
    
63.         }
    
64.         r->Next = NULL;
    
65.     }
    
66.     return L;
    
67. }
    
68. 
    
69. void Print(List L) {
    
70.     List p = L->Next;
    
71.     if(p) {
    
72.         List r;
    
73.         r = L;
    
74.         while(r->Next) {
    
75.             r = r->Next;
    
76.             printf("%d ", r->Data);
    
77.         }
    
78.     } else {
    
79.         printf("NULL");
    
80.     }
    
81.     printf("\n");
    
82. }
    
83. 
    
84. #if 0
    
85. // 好了，知道定义了
    
86. List Merge(List L1, List L2) {
    
87.     List L = malloc(sizeof(*L));
    
88.     L->Next = NULL;
    
89.     List *px = &L->Next;
    
90.     List p1 = L1->Next;
    
91.     List p2 = L2->Next;
    
92.     while(p1 && p2) {
    
93.         ElementType v;
    
94.         ElementType a = p1->Data;
    
95.         ElementType b = p2->Data;
    
96.         if(a < b) {
    
97.             v = a; p1 = p1->Next;
    
98.         } else {
    
99.             v = b; p2 = p2->Next;
    
100.         }
     
101.         *px = malloc(sizeof(**px));
     
102.         (*px)->Data = v;
     
103.         (*px)->Next = NULL;
     
104.         px = &(*px)->Next;
     
105.     }
     
106.     while(p1) {
     
107.         *px = malloc(sizeof(**px));
     
108.         (*px)->Data = p1->Data;
     
109.         (*px)->Next = NULL;
     
110.         p1 = p1->Next;
     
111.         px = &(*px)->Next;
     
112.     }
     
113.     while(p2) {
     
114.         *px = malloc(sizeof(**px));
     
115.         (*px)->Data = p2->Data;
     
116.         (*px)->Next = NULL;
     
117.         p2 = p2->Next;
     
118.         px = &(*px)->Next;
     
119.     }
     
120.     return L;
     
121. }
     
122. #else
     
123. List Merge(List L1, List L2) {
     
124.     List head, temp;
     
125.     //head = temp = (List)malloc(sizeof(struct Node));
     
126.     head = temp = malloc(sizeof(*head));
     
127. 
     
128.     List L1_bak = L1;
     
129.     List L2_bak = L2;
     
130. 
     
131.     L1 = L1->Next;
     
132.     L2 = L2->Next;
     
133. 
     
134.     while(L1 && L2) {
     
135.         if(L1->Data <= L2->Data) {
     
136.             temp->Next = L1;
     
137.             L1 = L1->Next;
     
138.         } else {
     
139.             temp->Next = L2;
     
140.             L2 = L2->Next;
     
141.         }
     
142.         temp = temp->Next;
     
143.     }
     
144. 
     
145.     if(L1) {
     
146.         while(L1) {
     
147.             temp->Next = L1;
     
148.             L1 = L1->Next;
     
149.             temp = temp->Next;
     
150.         }
     
151.         temp->Next = NULL;
     
152.     }
     
153.     else if(L2) {
     
154.         while(L2) {
     
155.             temp->Next = L2;
     
156.             L2 = L2->Next;
     
157.             temp = temp->Next;
     
158.         }
     
159.         temp->Next = NULL;
     
160.     } else
     
161.         temp->Next = NULL;
     
162. 
     
163.     // 到这里L1 L2为NULL 运行到后面在main函数里打印出L1 L2为原始头节点。。
     
164.     L1_bak->Next = NULL;
     
165.     L2_bak->Next = NULL;
     
166. 
     
167.     return head;
     
168. }
     
169. #endif
     

复制代码

歌者文明清理员

函数参数传递分为值传递和指针传递。对于基本类型的值传递，传入的是该值的副本，修改该副本不会对原始值造成影响；而对于指针类型的值传递，传入的是指针所指向地址的副本，这个副本指向同一个地址，因此可以通过该指针修改原始值。结构体指针也是指针类型，如果传入 Merge 函数的是 L1 和 L2 的指针，那么在函数内部修改 L1 和 L2 就可以作用到原始链表的头结点上了。可能你的问题出在 L1 和 L2 是值传递而非指针传递，导致在 Merge 函数中做的修改不能反映到 main 函数里。

sfqxx

在C语言中，函数参数的传递方式可以是值传递或地址传递。对于基本数据类型（如int、float等），采用值传递的方式，即将变量的值复制给形式参数，在函数内部对形参的修改不会影响到实参的值。而对于指针类型，采用地址传递的方式，即将实参的地址传递给形式参数，函数内部通过操作该地址所指向的内存，可以修改实参所指向的数据。

在你的代码中，`List`类型是指向结构体 `Node` 的指针类型，当你将 `L1` 和 `L2` 作为函数参数进行传递时，实际上是将它们的值（即结构体指针的地址）复制给了函数内部的形参 `L1` 和 `L2`。因此，在函数内部修改 `L1` 和 `L2` 的指向并不会影响原始的链表头节点。

要解决这个问题，可以考虑使用指向指针的指针（双重指针）来实现地址传递，以达到在函数内部修改链表头节点的目的。函数声明和定义需要做以下修改：

1. List Merge(List* L1, List* L2);

复制代码

在函数内部，通过对指针的间接引用，修改指针指向的值即可：

1. List Merge(List* L1, List* L2) {
   
2.     List head, temp;
   
3.     head = temp = (List)malloc(sizeof(struct Node));
   
4. 
   
5.     *L1 = (*L1)->Next;  // 修改L1指针指向的值，使其指向下一个节点
   
6.     *L2 = (*L2)->Next;  // 修改L2指针指向的值，使其指向下一个节点
   
7. 
   
8.     // 其他代码不变...
   
9. 
   
10.     return head;
    
11. }

复制代码

在函数调用时，传入 `&L1` 和 `&L2`，以传递它们的地址（即指向指针的指针）：

1. L = Merge(&L1, &L2);

复制代码

这样，在函数内部对 `L1` 和 `L2` 的操作就能够影响到原始的链表头节点了。

求最佳答案

a905448839

sfqxx 发表于 2023-6-18 18:21
在C语言中，函数参数的传递方式可以是值传递或地址传递。对于基本数据类型（如int、float等），采用值传递 ...

我只能在Merge函数里做修改，参数只能是这样List Merge( List L1, List L2 )，我该如何解决呢？

a905448839

sfqxx 发表于 2023-6-18 18:21
在C语言中，函数参数的传递方式可以是值传递或地址传递。对于基本数据类型（如int、float等），采用值传递 ...

将 `L1` 和 `L2` 作为函数参数进行传递时，实际上是将它们的值（即结构体指针的地址）复制给了函数内部的形参 `L1` 和 `L2`。 那么传递&L1和&L2 实际上是传递的什么呢？

a905448839

有人吗？

a905448839

1. List Merge( List L1, List L2 )
   
2. {
   
3.     List head,temp,TL1,TL2;
   
4.     head = temp = (List)malloc(sizeof(struct Node));
   
5.    
   
6.    
   
7.         TL1 = L1->Next;
   
8.         TL2 = L2->Next;
   
9. 
   
10. 
    
11.       while(TL1 && TL2)
    
12.      {
    
13.         if(TL1->Data <= TL2->Data)
    
14.         {
    
15.                 temp->Next = TL1;
    
16.                 TL1 = TL1->Next;
    
17.         }
    
18.         else
    
19.         {
    
20.                 temp->Next = TL2;
    
21.                 TL2 = TL2->Next;
    
22.         }
    
23.         temp = temp->Next;
    
24.     }
    
25.    
    
26.     if(TL1)
    
27.     {
    
28.         while(TL1)
    
29.         {
    
30.             temp->Next = TL1;
    
31.             TL1 = TL1->Next;
    
32.             temp = temp->Next;
    
33.         }
    
34.         temp->Next = NULL;
    
35.     }
    
36.    
    
37.     else if(TL2)
    
38.     {
    
39.          while(TL2)
    
40.         {
    
41.             temp->Next = TL2;
    
42.             TL2 = TL2->Next;
    
43.             temp = temp->Next;
    
44.         }
    
45.         temp->Next = NULL;
    
46.     }
    
47.     else
    
48.         temp->Next = NULL;
    
49. 
    
50.     //到这里L1 L2为NULL 运行到后面在main函数里打印出L1 L2为原始头节点。。
    
51. L1->Next = NULL;
    
52. L2->Next = NULL;
    
53. 
    
54.     return head;
    
55. }

复制代码

代码修改一下就可以了 真的希望有大佬出来解释一下

a905448839

@isdkz 能帮我看看吗？

陶远航

在C语言中，函数参数传递有两种方式：传值和传址。传值是将参数的值拷贝一份传入函数内部，对参数的修改不会影响原始值；而传址是将参数的内存地址传入函数内部，因此对参数的修改会直接反映到原始值上。

对于指针类型的参数，传递时一般是传递指针的值，即指针变量所指向的内存地址。这样做相当于传址，因为函数内部可以通过指针来访问原始值的内存地址，并对其值进行修改。

回到你的问题，你在Merge函数中对L1和L2指针的修改并不能影响main函数中的L1和L2的值，因为你修改的是指针变量本身的值，而非其指向的内存地址的值。要想在Merge函数中修改L1和L2的值，可以使用指向指针的指针或者指针的引用作为函数参数，这样可以实现对指针变量本身的修改，从而使得修改在函数外部可见。

以下是使用指针的指针实现对L1和L2的修改的示例代码：

1. List Merge( List* pL1, List* pL2 )
   
2. {
   
3.     List head,temp;
   
4.     head = temp = (List)malloc(sizeof(struct Node));
   
5.    
   
6.     List L1 = (*pL1)->Next;
   
7.     List L2 = (*pL2)->Next;
   
8. 
   
9.     while(L1 && L2)
   
10.     {
    
11.         if(L1->Data <= L2->Data)
    
12.         {
    
13.             temp->Next = L1;
    
14.             L1 = L1->Next;
    
15.         }
    
16.         else
    
17.         {
    
18.             temp->Next = L2;
    
19.             L2 = L2->Next;
    
20.         }
    
21.         temp = temp->Next;
    
22.     }
    
23.    
    
24.     if(L1)
    
25.     {
    
26.         while(L1)
    
27.         {
    
28.             temp->Next = L1;
    
29.             L1 = L1->Next;
    
30.             temp = temp->Next;
    
31.         }
    
32.         temp->Next = NULL;
    
33.     }
    
34.     else if(L2)
    
35.     {
    
36.         while(L2)
    
37.         {
    
38.             temp->Next = L2;
    
39.             L2 = L2->Next;
    
40.             temp = temp->Next;
    
41.         }
    
42.         temp->Next = NULL;
    
43.     }
    
44.     else
    
45.         temp->Next = NULL;
    
46. 
    
47.     *pL1 = head; // 修改 L1 指针的值，使其指向合并后的链表头
    
48.     (*pL2)->Next = NULL; // 将 L2 头节点的 Next 指针置为 NULL，防止出现错误
    
49. 
    
50.     return head;
    
51. }
    

复制代码

在main函数中，可以这样调用Merge函数：

1. L = Merge(&L1, &L2);

复制代码

注意，由于L1和L2都是带头结点的链表，所以在Merge函数返回之前要将它们的头节点的Next指针置为NULL，以免出现链接关系错乱的情况。

如果只能在Merge函数里做修改，那么最简单的方式是使用一个新的指针变量p指向head，然后在函数中修改p的值即可，这样就不会修改原始的L1和L2指针了。具体实现如下：

1. List Merge( List L1, List L2 )
   
2. {
   
3.     List head,temp,p;
   
4.     head = temp = (List)malloc(sizeof(struct Node));
   
5.     p = head; // 新增一个指针p，指向head
   
6.    
   
7.     L1 = L1->Next;
   
8.     L2 = L2->Next;
   
9. 
   
10.     while(L1 && L2)
    
11.     {
    
12.         if(L1->Data <= L2->Data)
    
13.         {
    
14.             p->Next = L1; // 使用p指针更新链表
    
15.             L1 = L1->Next;
    
16.         }
    
17.         else
    
18.         {
    
19.             p->Next = L2; // 使用p指针更新链表
    
20.             L2 = L2->Next;
    
21.         }
    
22.         p = p->Next;
    
23.     }
    
24.    
    
25.     if(L1)
    
26.     {
    
27.         while(L1)
    
28.         {
    
29.             p->Next = L1;
    
30.             L1 = L1->Next;
    
31.             p = p->Next;
    
32.         }
    
33.         p->Next = NULL;
    
34.     }
    
35.     else if(L2)
    
36.     {
    
37.         while(L2)
    
38.         {
    
39.             p->Next = L2;
    
40.             L2 = L2->Next;
    
41.             p = p->Next;
    
42.         }
    
43.         p->Next = NULL;
    
44.     }
    
45.     else
    
46.         p->Next = NULL;
    
47. 
    
48.     return head;
    
49. }

复制代码

调用方式与之前相同：

1. L = Merge(L1, L2);
   

复制代码

需要注意的是，在Merge函数中只要涉及到链表的插入、删除、移动等操作，都需要使用p指针来修改链表结构，以免影响原始的L1和L2指针。

a905448839

有没有一个不是人工智能回答的呀，有没有真人回答一下

本题我已测试过L1 L2是一个结构体指针 传进Merge函数里做修改 main函数打印也会改变  如图：

@小甲鱼 他们的回答都是通过L1 L2在Merge函数修改节点位置在main函数里是无法修改的  而在Merge函数里通过L1 L2头节点下一个指NULL时  在main函数里打印的NULL 能够被修改

a905448839

完整的测试代码

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. typedef int ElementType;
   
5. typedef struct Node *PtrToNode;
   
6. struct Node {
   
7.     ElementType Data;
   
8.     PtrToNode   Next;
   
9. };
   
10. typedef PtrToNode List;
    
11. 
    
12. List Read(); /* 细节在此不表     （也就是说提交的时候可以不考虑，不过还是要写的！）    */
    
13. void Print( List L ); /* 细节在此不表；空链表将输出NULL   （同上）*/
    
14. 
    
15. List Merge( List L1, List L2 );
    
16. 
    
17. int main()
    
18. {
    
19.     List L1, L2, L;
    
20.     L1 = Read();
    
21.     L2 = Read();
    
22.     L = Merge(L1, L2);
    
23.     Print(L);
    
24.     Print(L1);
    
25.     Print(L2);
    
26.     return 0;
    
27. }
    
28. 
    
29. /* 你的代码将被嵌在这里 */
    
30. List Read()
    
31. {
    
32.     int n,i;
    
33.     scanf("%d",&n);
    
34.     List L=(List)malloc(sizeof(PtrToNode));   ///申请一个头结点
    
35.     L->Next = NULL;        ///头指针为空
    
36.     if(n)    ///当n不是0时
    
37.     {
    
38.         List r=L;     ///r是一个中间变量的节点
    
39.         for(i=0;i<n;i++)
    
40.         {
    
41.             List p=(List)malloc(sizeof(struct Node));
    
42.             scanf("%d",&(p->Data));    ///尾插法
    
43.             r->Next = p;
    
44.             r = p;
    
45.         }
    
46.         r->Next = NULL;         
    
47.     }
    
48.     return L;
    
49. }
    
50. 
    
51. void Print( List L )
    
52. {
    
53.    List p=L->Next;
    
54.    if(p)
    
55.    {
    
56.        List r;
    
57.        r = L;
    
58.        while(r->Next)
    
59.        {
    
60.            r = r->Next;
    
61.            printf("%d ",r->Data);
    
62.        }
    
63.    }
    
64.    else
    
65.    {
    
66.        printf("NULL");
    
67.    }
    
68.    printf("\n");
    
69. }
    

复制代码

人造人

a905448839 发表于 2023-6-18 21:03
有没有一个不是人工智能回答的呀，有没有真人回答一下

本题我已测试过L1 L2是一个结构体指针 传进Merge ...

那就来个不是ai的回答

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. typedef int ElementType;
   
5. typedef struct Node *PtrToNode;
   
6. 
   
7. struct Node {
   
8.     ElementType Data;
   
9.     PtrToNode Next;
   
10. };
    
11. 
    
12. typedef PtrToNode List;
    
13. 
    
14. List Read(); /* 细节在此不表 （也就是说提交的时候可以不考虑，不过还是要写的！） */
    
15. void Print(List L); /* 细节在此不表；空链表将输出NULL   （同上）*/
    
16. List Merge(List L1, List L2);
    
17. 
    
18. 
    
19. // 你是不是忘了写这个函数了？
    
20. void list_free(List L) {
    
21.     if(L) list_free(L->Next);
    
22.     free(L);
    
23. }
    
24. 
    
25. int main(void) {
    
26.     List L1, L2, L;
    
27.     L1 = Read();
    
28.     L2 = Read();
    
29.     L = Merge(L1, L2);
    
30.     Print(L);
    
31.     Print(L1);
    
32.     Print(L2);
    
33.     list_free(L);
    
34.     list_free(L1);
    
35.     list_free(L2);
    
36.     return 0;
    
37. }
    
38. 
    
39. /* 你的代码将被嵌在这里 */
    
40. List Read() {
    
41.     int n, i;
    
42.     scanf("%d", &n);
    
43.     //List L = (List)malloc(sizeof(PtrToNode)); /// 申请一个头结点
    
44.     //List L = malloc(sizeof(PtrToNode));       // 这是C语言，没必要强制转换
    
45.     //List L = malloc(sizeof(struct Node));     // 是PtrToNode还是struct Node？
    
46.     List L = malloc(sizeof(*L));                // 对吧？管他什么类型了
    
47.     L->Next = NULL;                           // 头指针为空
    
48.     if(n)                                     // 当n不是0时
    
49.     {
    
50.         List r = L; /// r是一个中间变量的节点
    
51.         for(i = 0; i < n; i++) {
    
52.             //List p = (List)malloc(sizeof(struct Node));
    
53.             List p = malloc(sizeof(*p));
    
54.             //scanf("%d", &(p->Data)); // 尾插法
    
55.             scanf("%d", &p->Data);  // 尾插法
    
56.             r->Next = p;
    
57.             r = p;
    
58.         }
    
59.         r->Next = NULL;
    
60.     }
    
61.     return L;
    
62. }
    
63. 
    
64. void Print(List L) {
    
65.     List p = L->Next;
    
66.     if(p) {
    
67.         List r;
    
68.         r = L;
    
69.         while(r->Next) {
    
70.             r = r->Next;
    
71.             printf("%d ", r->Data);
    
72.         }
    
73.     } else {
    
74.         printf("NULL");
    
75.     }
    
76.     printf("\n");
    
77. }
    
78. 
    
79. // 定义是什么？
    
80. List Merge(List L1, List L2) {
    
81.     List L = malloc(sizeof(*L));
    
82.     L->Next = NULL;
    
83.     List *px = &L->Next;
    
84.     List p1 = L1->Next;
    
85.     while(p1) {
    
86.         *px = malloc(sizeof(**px));
    
87.         (*px)->Data = p1->Data;
    
88.         (*px)->Next = NULL;
    
89.         p1 = p1->Next;
    
90.         px = &(*px)->Next;
    
91.     }
    
92.     List p2 = L2->Next;
    
93.     while(p2) {
    
94.         *px = malloc(sizeof(**px));
    
95.         (*px)->Data = p2->Data;
    
96.         (*px)->Next = NULL;
    
97.         p2 = p2->Next;
    
98.         px = &(*px)->Next;
    
99.     }
    
100.     return L;
     
101. }
     

复制代码

人造人

稍微改一改

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. typedef int ElementType;
   
5. typedef struct Node *PtrToNode;
   
6. 
   
7. struct Node {
   
8.     ElementType Data;
   
9.     PtrToNode Next;
   
10. };
    
11. 
    
12. typedef PtrToNode List;
    
13. 
    
14. List Read(); /* 细节在此不表 （也就是说提交的时候可以不考虑，不过还是要写的！） */
    
15. void Print(List L); /* 细节在此不表；空链表将输出NULL   （同上）*/
    
16. List Merge(List L1, List L2);
    
17. 
    
18. 
    
19. // 你是不是忘了写这个函数了？
    
20. void list_free(List L) {
    
21.     if(L) list_free(L->Next);
    
22.     free(L);
    
23. }
    
24. 
    
25. int main(void) {
    
26.     List L1, L2, L;
    
27.     L1 = Read();
    
28.     L2 = Read();
    
29.     L = Merge(L1, L2);
    
30.     Print(L);
    
31.     Print(L1);
    
32.     Print(L2);
    
33.     list_free(L);
    
34.     list_free(L1);
    
35.     list_free(L2);
    
36.     return 0;
    
37. }
    
38. 
    
39. /* 你的代码将被嵌在这里 */
    
40. List Read() {
    
41.     int n, i;
    
42.     scanf("%d", &n);
    
43.     //List L = (List)malloc(sizeof(PtrToNode)); /// 申请一个头结点
    
44.     //List L = malloc(sizeof(PtrToNode));       // 这是C语言，没必要强制转换
    
45.     //List L = malloc(sizeof(struct Node));     // 是PtrToNode还是struct Node？
    
46.     List L = malloc(sizeof(*L));                // 对吧？管他什么类型了
    
47.     L->Next = NULL;                           // 头指针为空
    
48.     if(n)                                     // 当n不是0时
    
49.     {
    
50.         List r = L; /// r是一个中间变量的节点
    
51.         for(i = 0; i < n; i++) {
    
52.             //List p = (List)malloc(sizeof(struct Node));
    
53.             List p = malloc(sizeof(*p));
    
54.             //scanf("%d", &(p->Data)); // 尾插法
    
55.             scanf("%d", &p->Data);  // 尾插法
    
56.             r->Next = p;
    
57.             r = p;
    
58.         }
    
59.         r->Next = NULL;
    
60.     }
    
61.     return L;
    
62. }
    
63. 
    
64. void Print(List L) {
    
65.     List p = L->Next;
    
66.     if(p) {
    
67.         List r;
    
68.         r = L;
    
69.         while(r->Next) {
    
70.             r = r->Next;
    
71.             printf("%d ", r->Data);
    
72.         }
    
73.     } else {
    
74.         printf("NULL");
    
75.     }
    
76.     printf("\n");
    
77. }
    
78. 
    
79. // 好了，知道定义了
    
80. List Merge(List L1, List L2) {
    
81.     List L = malloc(sizeof(*L));
    
82.     L->Next = NULL;
    
83.     List *px = &L->Next;
    
84.     List p1 = L1->Next;
    
85.     List p2 = L2->Next;
    
86.     while(p1 && p2) {
    
87.         ElementType v;
    
88.         ElementType a = p1->Data;
    
89.         ElementType b = p2->Data;
    
90.         if(a < b) {
    
91.             v = a; p1 = p1->Next;
    
92.         } else {
    
93.             v = b; p2 = p2->Next;
    
94.         }
    
95.         *px = malloc(sizeof(**px));
    
96.         (*px)->Data = v;
    
97.         (*px)->Next = NULL;
    
98.         px = &(*px)->Next;
    
99.     }
    
100.     while(p1) {
     
101.         *px = malloc(sizeof(**px));
     
102.         (*px)->Data = p1->Data;
     
103.         (*px)->Next = NULL;
     
104.         p1 = p1->Next;
     
105.         px = &(*px)->Next;
     
106.     }
     
107.     while(p2) {
     
108.         *px = malloc(sizeof(**px));
     
109.         (*px)->Data = p2->Data;
     
110.         (*px)->Next = NULL;
     
111.         p2 = p2->Next;
     
112.         px = &(*px)->Next;
     
113.     }
     
114.     return L;
     
115. }
     

复制代码

人造人

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. typedef int ElementType;
   
5. typedef struct Node *PtrToNode;
   
6. 
   
7. struct Node {
   
8.     ElementType Data;
   
9.     PtrToNode Next;
   
10. };
    
11. 
    
12. typedef PtrToNode List;
    
13. 
    
14. List Read(); /* 细节在此不表 （也就是说提交的时候可以不考虑，不过还是要写的！） */
    
15. void Print(List L); /* 细节在此不表；空链表将输出NULL   （同上）*/
    
16. List Merge(List L1, List L2);
    
17. 
    
18. 
    
19. // 你是不是忘了写这个函数了？
    
20. void list_free(List L) {
    
21.     if(L) list_free(L->Next);
    
22.     free(L);
    
23. }
    
24. 
    
25. int main(void) {
    
26.     List L1, L2, L;
    
27.     L1 = Read();
    
28.     L2 = Read();
    
29.     L = Merge(L1, L2);
    
30.     Print(L);
    
31.     Print(L1);
    
32.     Print(L2);
    
33.     list_free(L);
    
34.     //list_free(L1);
    
35.     //list_free(L2);
    
36.     // 要共用节点的话，这两个就只能单独释放了
    
37.     free(L1);
    
38.     free(L2);
    
39.     return 0;
    
40. }
    
41. 
    
42. /* 你的代码将被嵌在这里 */
    
43. List Read() {
    
44.     int n, i;
    
45.     scanf("%d", &n);
    
46.     //List L = (List)malloc(sizeof(PtrToNode)); /// 申请一个头结点
    
47.     //List L = malloc(sizeof(PtrToNode));       // 这是C语言，没必要强制转换
    
48.     //List L = malloc(sizeof(struct Node));     // 是PtrToNode还是struct Node？
    
49.     List L = malloc(sizeof(*L));                // 对吧？管他什么类型了
    
50.     L->Next = NULL;                           // 头指针为空
    
51.     if(n)                                     // 当n不是0时
    
52.     {
    
53.         List r = L; /// r是一个中间变量的节点
    
54.         for(i = 0; i < n; i++) {
    
55.             //List p = (List)malloc(sizeof(struct Node));
    
56.             List p = malloc(sizeof(*p));
    
57.             //scanf("%d", &(p->Data)); // 尾插法
    
58.             scanf("%d", &p->Data);  // 尾插法
    
59.             r->Next = p;
    
60.             r = p;
    
61.         }
    
62.         r->Next = NULL;
    
63.     }
    
64.     return L;
    
65. }
    
66. 
    
67. void Print(List L) {
    
68.     List p = L->Next;
    
69.     if(p) {
    
70.         List r;
    
71.         r = L;
    
72.         while(r->Next) {
    
73.             r = r->Next;
    
74.             printf("%d ", r->Data);
    
75.         }
    
76.     } else {
    
77.         printf("NULL");
    
78.     }
    
79.     printf("\n");
    
80. }
    
81. 
    
82. #if 0
    
83. // 好了，知道定义了
    
84. List Merge(List L1, List L2) {
    
85.     List L = malloc(sizeof(*L));
    
86.     L->Next = NULL;
    
87.     List *px = &L->Next;
    
88.     List p1 = L1->Next;
    
89.     List p2 = L2->Next;
    
90.     while(p1 && p2) {
    
91.         ElementType v;
    
92.         ElementType a = p1->Data;
    
93.         ElementType b = p2->Data;
    
94.         if(a < b) {
    
95.             v = a; p1 = p1->Next;
    
96.         } else {
    
97.             v = b; p2 = p2->Next;
    
98.         }
    
99.         *px = malloc(sizeof(**px));
    
100.         (*px)->Data = v;
     
101.         (*px)->Next = NULL;
     
102.         px = &(*px)->Next;
     
103.     }
     
104.     while(p1) {
     
105.         *px = malloc(sizeof(**px));
     
106.         (*px)->Data = p1->Data;
     
107.         (*px)->Next = NULL;
     
108.         p1 = p1->Next;
     
109.         px = &(*px)->Next;
     
110.     }
     
111.     while(p2) {
     
112.         *px = malloc(sizeof(**px));
     
113.         (*px)->Data = p2->Data;
     
114.         (*px)->Next = NULL;
     
115.         p2 = p2->Next;
     
116.         px = &(*px)->Next;
     
117.     }
     
118.     return L;
     
119. }
     
120. #else
     
121. List Merge(List L1, List L2) {
     
122.     List head, temp;
     
123.     //head = temp = (List)malloc(sizeof(struct Node));
     
124.     head = temp = malloc(sizeof(*head));
     
125. 
     
126.     L1 = L1->Next;
     
127.     L2 = L2->Next;
     
128. 
     
129.     while(L1 && L2) {
     
130.         if(L1->Data <= L2->Data) {
     
131.             temp->Next = L1;
     
132.             L1 = L1->Next;
     
133.         } else {
     
134.             temp->Next = L2;
     
135.             L2 = L2->Next;
     
136.         }
     
137.         temp = temp->Next;
     
138.     }
     
139. 
     
140.     if(L1) {
     
141.         while(L1) {
     
142.             temp->Next = L1;
     
143.             L1 = L1->Next;
     
144.             temp = temp->Next;
     
145.         }
     
146.         temp->Next = NULL;
     
147.     }
     
148.     else if(L2) {
     
149.         while(L2) {
     
150.             temp->Next = L2;
     
151.             L2 = L2->Next;
     
152.             temp = temp->Next;
     
153.         }
     
154.         temp->Next = NULL;
     
155.     } else
     
156.         temp->Next = NULL;
     
157. 
     
158.     // 到这里L1 L2为NULL 运行到后面在main函数里打印出L1 L2为原始头节点。。
     
159. 
     
160.     return head;
     
161. }
     
162. #endif
     

复制代码

a905448839

人造人 发表于 2023-6-18 23:08
稍微改一改

感谢你的回复，真的很牛，不过这二级指针我越看越迷糊，我也free不了内存空间，我只能对Merge函数内容做出修改，参数也不能更改。main函数也不能动。我把你的代码copy过去测试了，我把测试结果发出来。




你的第一次回复 Merge函数代码 测试：

1. List Merge(List L1, List L2) {
   
2.     List L = malloc(sizeof(*L));
   
3.     L->Next = NULL;
   
4.     List *px = &L->Next;
   
5.     List p1 = L1->Next;
   
6.     while(p1) {
   
7.         *px = malloc(sizeof(**px));
   
8.         (*px)->Data = p1->Data;
   
9.         (*px)->Next = NULL;
   
10.         p1 = p1->Next;
    
11.         px = &(*px)->Next;
    
12.     }
    
13.     List p2 = L2->Next;
    
14.     while(p2) {
    
15.         *px = malloc(sizeof(**px));
    
16.         (*px)->Data = p2->Data;
    
17.         (*px)->Next = NULL;
    
18.         p2 = p2->Next;
    
19.         px = &(*px)->Next;
    
20.     }
    
21.     return L;
    
22. }

复制代码

你的第二次回复 Merge函数代码 测试：

1. List Merge(List L1, List L2) {
   
2.     List L = malloc(sizeof(*L));
   
3.     L->Next = NULL;
   
4.     List *px = &L->Next;
   
5.     List p1 = L1->Next;
   
6.     List p2 = L2->Next;
   
7.     while(p1 && p2) {
   
8.         ElementType v;
   
9.         ElementType a = p1->Data;
   
10.         ElementType b = p2->Data;
    
11.         if(a < b) {
    
12.             v = a; p1 = p1->Next;
    
13.         } else {
    
14.             v = b; p2 = p2->Next;
    
15.         }
    
16.         *px = malloc(sizeof(**px));
    
17.         (*px)->Data = v;
    
18.         (*px)->Next = NULL;
    
19.         px = &(*px)->Next;
    
20.     }
    
21.     while(p1) {
    
22.         *px = malloc(sizeof(**px));
    
23.         (*px)->Data = p1->Data;
    
24.         (*px)->Next = NULL;
    
25.         p1 = p1->Next;
    
26.         px = &(*px)->Next;
    
27.     }
    
28.     while(p2) {
    
29.         *px = malloc(sizeof(**px));
    
30.         (*px)->Data = p2->Data;
    
31.         (*px)->Next = NULL;
    
32.         p2 = p2->Next;
    
33.         px = &(*px)->Next;
    
34.     }
    
35.     return L;
    
36. }

复制代码

也许大佬你没有仔细看题  实现这个题目最后L1 L2指向的下一个节点是NULL  由于我的代码是通过传递进去的L1 L2指针来进行改动移动节点 导致回到主函数中去的时候好像没有改动到L1 L2节点位置 还依然是头节点 我看过一些题解是用两个局部变量的指针指向L1 L2 再来做这两个局部变量的指针移动节点 最后把L1 L2指向的下一个节点为NULL 有这样一段代码实现 我不明白的是 为什么用完局部变量的节点之后  最后L1->Next = NULL和L2->Next = NULL 是能够影响到外面main函数的L1 L2。而直接对L1 L2修改 直到L1 L2都为NULL时返回到main函数，main函数里的L1 L2依然为最开始头节点。

能够实现的代码 使用两个局部变量来移动节点  用temp来指向产生一个新的链表  最后让始终是L1 L2头结点下一个指向NULL  成功影响外面的main函数里的L1 L2：

1. List Merge( List L1, List L2 )
   
2. {
   
3.     List head,temp,TL1,TL2;
   
4.     head = temp = (List)malloc(sizeof(struct Node));
   
5.    
   
6.    
   
7.         TL1 = L1->Next;
   
8.         TL2 = L2->Next;
   
9. 
   
10. 
    
11.       while(TL1 && TL2)
    
12.      {
    
13.         if(TL1->Data <= TL2->Data)
    
14.         {
    
15.                 temp->Next = TL1;
    
16.                 TL1 = TL1->Next;
    
17.         }
    
18.         else
    
19.         {
    
20.                 temp->Next = TL2;
    
21.                 TL2 = TL2->Next;
    
22.         }
    
23.         temp = temp->Next;
    
24.     }
    
25.    
    
26.     if(TL1)
    
27.     {
    
28.         while(TL1)
    
29.         {
    
30.             temp->Next = TL1;
    
31.             TL1 = TL1->Next;
    
32.             temp = temp->Next;
    
33.         }
    
34.         temp->Next = NULL;
    
35.     }
    
36.    
    
37.     else if(TL2)
    
38.     {
    
39.          while(TL2)
    
40.         {
    
41.             temp->Next = TL2;
    
42.             TL2 = TL2->Next;
    
43.             temp = temp->Next;
    
44.         }
    
45.         temp->Next = NULL;
    
46.     }
    
47.     else
    
48.         temp->Next = NULL;
    
49. 
    
50.    
    
51. L1->Next = NULL;
    
52. L2->Next = NULL;
    
53. 
    
54.     return head;
    
55. }

复制代码

不能够实现的代码  对传进来L1 L2结构体指针操作  能够实现让两个链表合并成一个递增的顺序链表 但是L1 L2在Merge函数结束时为NULL 回到main函数却变成了最开始L1 L2的头指针：

1. List Merge( List L1, List L2 )
   
2. {
   
3.     List head,temp;
   
4.     head = temp = (List)malloc(sizeof(struct Node));
   
5.    
   
6.         L1 = L1->Next;
   
7.         L2 = L2->Next;
   
8. 
   
9. 
   
10.       while(L1 && L2)
    
11.      {
    
12.         if(L1->Data <= L2->Data)
    
13.         {
    
14.                 temp->Next = L1;
    
15.                 L1 = L1->Next;
    
16.         }
    
17.         else
    
18.         {
    
19.                 temp->Next = L2;
    
20.                 L2 = L2->Next;
    
21.         }
    
22.         temp = temp->Next;
    
23.     }
    
24.    
    
25.     if(L1)
    
26.     {
    
27.         while(L1)
    
28.         {
    
29.             temp->Next = L1;
    
30.             L1 = L1->Next;
    
31.             temp = temp->Next;
    
32.         }
    
33.         temp->Next = NULL;
    
34.     }
    
35.    
    
36.     else if(L2)
    
37.     {
    
38.          while(L2)
    
39.         {
    
40.             temp->Next = L2;
    
41.             L2 = L2->Next;
    
42.             temp = temp->Next;
    
43.         }
    
44.         temp->Next = NULL;
    
45.     }
    
46.     else
    
47.         temp->Next = NULL;
    
48. 
    
49.     //到这里L1 L2为NULL 运行到后面在main函数里打印出L1 L2为原始头节点。。
    
50. 
    
51. 
    
52.     return head;
    
53. }

复制代码

人造人

a905448839 发表于 2023-6-18 23:42
感谢你的回复，真的很牛，不过这二级指针我越看越迷糊，我也free不了内存空间，我只能对Merge函数内容做 ...

这里需要修改的是L->Next

L1 = L1->Next;
L1->Next = NULL;
这个修改的就是 L->Next->Next 了

1. L1 = L1->Next;
   
2. L1->Next = NULL;

复制代码

1. L->Next->Next = NULL;

复制代码

他俩一个意思

人造人

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. typedef int ElementType;
   
5. typedef struct Node *PtrToNode;
   
6. 
   
7. struct Node {
   
8.     ElementType Data;
   
9.     PtrToNode Next;
   
10. };
    
11. 
    
12. typedef PtrToNode List;
    
13. 
    
14. void Print(List L); /* 细节在此不表；空链表将输出NULL   （同上）*/
    
15. 
    
16. 
    
17. void list_free(List L) {
    
18.     if(L) list_free(L->Next);
    
19.     free(L);
    
20. }
    
21. 
    
22. void set_null(List a, List b) {
    
23. 
    
24.     a->Next->Next = NULL;
    
25. 
    
26.     b = b->Next;
    
27.     b->Next = NULL;
    
28. }
    
29. 
    
30. int main(void) {
    
31.     List L1, L2;
    
32.     L1 = malloc(sizeof(*L1));
    
33.     L1->Next = malloc(sizeof(*L1->Next));
    
34.     L1->Next->Data = 123;
    
35.     L2 = malloc(sizeof(*L2));
    
36.     L2->Next = malloc(sizeof(*L2->Next));
    
37.     L2->Next->Data = 456;
    
38.     set_null(L1, L2);
    
39.     Print(L1);
    
40.     Print(L2);
    
41.     list_free(L1);
    
42.     list_free(L2);
    
43.     return 0;
    
44. }
    
45. 
    
46. void Print(List L) {
    
47.     List p = L->Next;
    
48.     if(p) {
    
49.         List r;
    
50.         r = L;
    
51.         while(r->Next) {
    
52.             r = r->Next;
    
53.             printf("%d ", r->Data);
    
54.         }
    
55.     } else {
    
56.         printf("NULL");
    
57.     }
    
58.     printf("\n");
    
59. }
    

复制代码

a905448839

人造人 发表于 2023-6-18 18:13
我确实没认真看题，^_^
我是先直接看的代码

感谢你的回答 两种方式我都看了！ 最后还有一个小问题 在第二个Merge函数里最后L1_bak->Next = NULL;
    L2_bak->Next = NULL; 这里的L1_bak和L2_bak原本是L1 L2头结点位置  这里指向NULL 让main函数L1 L2的下一节点指向NULL了 的的确确影响到了 但是如果在Merge函数里移动L1 L2节点 或者移动L1_bak L2_bak节点 最后在移动的中途节点 或者在最后节点再把下一个节点指向NULL 就不会导致main函数里的L1 L2节点下一个指向为NULL 是原始的情况 是否在Merge函数里移动这些节点 不会导致main函数里的L1 L2节点位置改变 但是如果在Merge函数里直接做指向节点修改 不移动节点就会影响到main函数里的L1 L2指向吗？

人造人

a905448839 发表于 2023-6-19 10:12
感谢你的回答 两种方式我都看了！ 最后还有一个小问题 在第二个Merge函数里最后L1_bak->Next = NULL;
   ...

没看懂，用代码说明你的问题吧