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

a905448839

人造人 发表于 2023-6-19 10:13
没看懂，用代码说明你的问题吧

简单来说就是 在Merge函数里对传进来的L1  L2做节点位置的修改后，返回到main函数里L1 L2节点位置还是传入main函数之前的位置。但是在Merge函数里 直接对L1->Next = NULL做这个动作 是能够影响到main函数的 但是如果移动了节点做这样的动作 是无法影响到main函数的 是为什么呢？

人造人

对传进来的L1  L2做节点位置的修改
怎么个修改法？
返回到main函数里L1 L2节点位置还是传入main函数之前的位置
这个L1 L2节点位置是什么意思？
是L1 L2这两个指针指向的节点？还是整个链表？

但是如果移动了节点做这样的动作 是无法影响到main函数的
这个无法影响到main函数体现在哪里？

最好还是用代码说明问题，用文字叙述会有太多的变数

人造人

a905448839 发表于 2023-6-19 10:26
简单来说就是 在Merge函数里对传进来的L1  L2做节点位置的修改后，返回到main函数里L1 L2节点位置还是 ...

但是如果移动了节点做这样的动作 是无法影响到main函数的
可以修改呀

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 list_append(List L) {
    
23.     while(L->Next) L = L->Next;     // 修改L，让他指向最后面
    
24.     // 在最后面添加一个节点
    
25.     L->Next = malloc(sizeof(*L->Next));
    
26.     L->Next->Data = 456;
    
27.     L->Next->Next = NULL;
    
28. }
    
29. 
    
30. int main(void) {
    
31.     List L1 = malloc(sizeof(*L1));
    
32.     L1->Next = malloc(sizeof(*L1->Next));
    
33.     L1->Next->Data = 123;
    
34.     L1->Next->Next = NULL;
    
35.     Print(L1);
    
36.     list_append(L1);
    
37.     Print(L1);
    
38.     list_free(L1);
    
39.     return 0;
    
40. }
    
41. 
    
42. void Print(List L) {
    
43.     List p = L->Next;
    
44.     if(p) {
    
45.         List r;
    
46.         r = L;
    
47.         while(r->Next) {
    
48.             r = r->Next;
    
49.             printf("%d ", r->Data);
    
50.         }
    
51.     } else {
    
52.         printf("NULL");
    
53.     }
    
54.     printf("\n");
    
55. }
    

复制代码

人造人

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 list_append(List L, ElementType v) {
    
23.     while(L->Next) L = L->Next;     // 修改L，让他指向最后面
    
24.     // 在最后面添加一个节点
    
25.     L->Next = malloc(sizeof(*L->Next));
    
26.     L->Next->Data = v;
    
27.     L->Next->Next = NULL;
    
28. }
    
29. 
    
30. int main(void) {
    
31.     List L1 = malloc(sizeof(*L1));
    
32.     L1->Next = NULL;
    
33.     Print(L1);
    
34.     list_append(L1, 123);
    
35.     Print(L1);
    
36.     list_append(L1, 456);
    
37.     Print(L1);
    
38.     list_free(L1);
    
39.     return 0;
    
40. }
    
41. 
    
42. void Print(List L) {
    
43.     List p = L->Next;
    
44.     if(p) {
    
45.         List r;
    
46.         r = L;
    
47.         while(r->Next) {
    
48.             r = r->Next;
    
49.             printf("%d ", r->Data);
    
50.         }
    
51.     } else {
    
52.         printf("NULL");
    
53.     }
    
54.     printf("\n");
    
55. }
    

复制代码

a905448839

人造人 发表于 2023-6-19 11:00

写了个代码开验证  代码后面的备注是我错误的理解
我发现直接用传入函数的指针做移动 假设这个指针是p 无论移动到哪里或者不移动
对p做修改是无效的 比如p=NULL 但是对p->Next的修改是有效的 比如p->Next = NULL;

代码1对指针p直接做修改 无效：

1. #include<stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. struct sum {
   
5.     int a;
   
6.     struct sum  *Next;
   
7. };
   
8. 
   
9. struct sum* read( struct sum  *p);
   
10. void print(struct sum  *p);
    
11. void move( int i, struct sum  *p);//把这个链表第i个结构体里的下一个结构体指针设为NULL
    
12. void Nomove(struct sum  *p);
    
13. 
    
14. struct sum* read(struct sum* p)
    
15. {
    
16.     int i = 10;
    
17.     struct sum* head = p;
    
18.     while (i)
    
19.     {
    
20.         p->a = i;
    
21.         if (i == 1)
    
22.             p->Next = NULL;
    
23.         else
    
24.             p->Next = (struct sum*)malloc(sizeof(struct sum));
    
25.             
    
26.         p = p->Next;
    
27.         i--;
    
28.     }
    
29.     return head;
    
30. }
    
31. void print(struct sum  *p)
    
32. {
    
33.         printf("此时链表为：head->");
    
34.         while(p)
    
35.         {
    
36.                 printf("%d->",p->a);
    
37.                 p = p->Next;
    
38.         }
    
39.         printf("NULL\n");
    
40. }
    
41. 
    
42. void move(int i, struct sum  *p)//把这个链表第i个结构体里的下一个结构体指针设为NULL
    
43. {
    
44.         i = i-1;
    
45.         while(i--)
    
46.         p = p->Next; //直接用传进来的指针做移动节点
    
47. 
    
48.         p = NULL;
    
49. //        p->Next = NULL;
    
50. 
    
51.         //移动到i的位置后让p指向NULL 即i的位置p->Next = NULL
    
52.         //但是结束后回到main函数并没有影响整个链表
    
53.         //但是如果不移动节点 直接让传进来的指针为NULL 也不返回这个指针 能够影响到main函数的链表
    
54.         //如下
    
55.        
    
56. }
    
57. 
    
58. void Nomove(struct sum  *p)
    
59. {
    
60.         p = NULL;       
    
61. //        p->Next = NULL;
    
62.        
    
63. }
    
64. 
    
65. int main(void)
    
66. {
    
67.         struct sum *p;
    
68.         p = (struct sum*)malloc(sizeof(struct sum));
    
69.         p = read(p);
    
70.         print(p);
    
71.        
    
72.         move(4,p);
    
73.         print(p);
    
74. 
    
75.         Nomove(p);
    
76.         print(p);
    
77. 
    
78.         return 0;
    
79. }

复制代码

代码2对指针p->Next做修改 有效：

1. #include<stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. struct sum {
   
5.     int a;
   
6.     struct sum  *Next;
   
7. };
   
8. 
   
9. struct sum* read( struct sum  *p);
   
10. void print(struct sum  *p);
    
11. void move( int i, struct sum  *p);//把这个链表第i个结构体里的下一个结构体指针设为NULL
    
12. void Nomove(struct sum  *p);
    
13. 
    
14. struct sum* read(struct sum* p)
    
15. {
    
16.     int i = 10;
    
17.     struct sum* head = p;
    
18.     while (i)
    
19.     {
    
20.         p->a = i;
    
21.         if (i == 1)
    
22.             p->Next = NULL;
    
23.         else
    
24.             p->Next = (struct sum*)malloc(sizeof(struct sum));
    
25.             
    
26.         p = p->Next;
    
27.         i--;
    
28.     }
    
29.     return head;
    
30. }
    
31. void print(struct sum  *p)
    
32. {
    
33.         printf("此时链表为：head->");
    
34.         while(p)
    
35.         {
    
36.                 printf("%d->",p->a);
    
37.                 p = p->Next;
    
38.         }
    
39.         printf("NULL\n");
    
40. }
    
41. 
    
42. void move(int i, struct sum  *p)//把这个链表第i个结构体里的下一个结构体指针设为NULL
    
43. {
    
44.         i = i-1;
    
45.         while(i--)
    
46.         p = p->Next; //直接用传进来的指针做移动节点
    
47. 
    
48. //        p = NULL;
    
49.         p->Next = NULL;
    
50. 
    
51.         //移动到i的位置后让p指向NULL 即i的位置p->Next = NULL
    
52.         //但是结束后回到main函数并没有影响整个链表
    
53.         //但是如果不移动节点 直接让传进来的指针为NULL 也不返回这个指针 能够影响到main函数的链表
    
54.         //如下
    
55.        
    
56. }
    
57. 
    
58. void Nomove(struct sum  *p)
    
59. {
    
60. //        p = NULL;       
    
61.         p->Next = NULL;
    
62.        
    
63. }
    
64. 
    
65. int main(void)
    
66. {
    
67.         struct sum *p;
    
68.         p = (struct sum*)malloc(sizeof(struct sum));
    
69.         p = read(p);
    
70.         print(p);
    
71.        
    
72.         move(4,p);
    
73.         print(p);
    
74. 
    
75.         Nomove(p);
    
76.         print(p);
    
77. 
    
78.         return 0;
    
79. }

复制代码

为什么对p指针目前所指向的结构体做修改不行  对它下一个节点做修改却有效？

a905448839

人造人 发表于 2023-6-19 11:00

我想用一个二级指针a指向指针p

这样通过         *a = NULL; 来修改还是无法改变结果。。

1. void Nomove(struct sum  *p)
   
2. {
   
3. //        p = NULL;       
   
4. //        p->Next = NULL;
   
5.        
   
6.          struct sum** a = &p;
   
7.          
   
8.          *a = NULL;
   
9. }
   

复制代码

人造人

a905448839 发表于 2023-6-19 13:24
写了个代码开验证  代码后面的备注是我错误的理解
我发现直接用传入函数的指针做移动 假设这个指针是p  ...

一个是修改指针的指向
一个是修改指针指向的值
这两个是不一样的，你需要好好理解一下这两个的不同

1. #include <stdio.h>
   
2. 
   
3. int main(void) {
   
4.     int a = 123;
   
5.     int b = 456;
   
6.     int *p = NULL;
   
7.     p = &a;         // 修改指针p的指向
   
8.     *p = 789;       // 修改指针p指向的值
   
9.     p = &b;         // 修改指针p的指向
   
10.     *p = 100;       // 修改指针p指向的值
    
11.     printf("%d %d\n", a, b);
    
12.     return 0;
    
13. }
    

复制代码

人造人

a905448839 发表于 2023-6-19 13:32
我想用一个二级指针a指向指针p

这样通过         *a = NULL; 来修改还是无法改变结果。。

你这修改的是指针的指向，不是指针指向的值

1. sh-5.1$ cat main.c
   
2. #include <stdio.h>
   
3. 
   
4. int b = 456;
   
5. 
   
6. void func(int *p) {
   
7.     int **x = &p;
   
8.     *x = &b;        // 修改指针p的指向
   
9.     **x = 789;      // 修改指针p指向的值
   
10. }
    
11. 
    
12. int main(void) {
    
13.     int a = 123;
    
14.     func(&a);
    
15.     printf("%d %d\n", a, b);
    
16.     return 0;
    
17. }
    
18. sh-5.1$ ./main
    
19. 123 789
    
20. sh-5.1$
    

复制代码

sfqxx

不用gpt，hehe

a905448839

人造人 发表于 2023-6-19 17:23
一个是修改指针的指向
一个是修改指针指向的值
这两个是不一样的，你需要好好理解一下这两个的不同

谢谢！！