Перемещение связанного списка

Question

Я новичок в C, и теперь я пытаюсь изучить основы связанного списка. Следующий код - это только сегмент прохождения связанного списка.

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


struct node 
{ 
    int item; 
    struct node *next; 
}; 

int main() 
{ 
    struct node *start,*list; 
    int i; 
    start = (struct node *)malloc(sizeof(struct node)); 
    list = start; 
    start->next = NULL; 


    for(i=0;i<10;i++) 
    { 
     list->item = i; 
     printf("%p\t%p\n",start->next,list->next); 
     list->next = (struct node *)malloc(sizeof(struct node)); 
     list = list->next; 
    } 

    return 0; 
} 

Я смущен, что выход «Пуск-> следующая» не NULL, а твердый постоянный адрес. Но я назначил NULL для запуска-> next перед циклом for и только изменить компонент в «списке» (list-> item и list-> next), а не в компоненте «start». Итак, почему компонент в «старте» изменяется?

Answer 1

Помните, что у вас есть: list = start: Затем они оба указывают на один и тот же узел, и при условии, что они равны, list->next - это то же самое, что и start->next.

На for первой итерации start и list по-прежнему равны и start->next будет NULL, пока вы не назначите: list->next = .... После этого первого задания, start->next будет изменен, чтобы указать на malloced адрес. На следующих итерациях list указывает на другие места, а модификация list->next не влияет start->next.

---

Шаг за шагом: («узел X» имена, которые я даю узлов, выделенных таНос, они не являются переменными в вашей программе)

node 0: { .item = ?, .next = NULL } <---- start, list 

i = 0; 
list->item = i; 

node 0: { .item = 0, .next = NULL } <---- start, list 

list->next = malloc(...) 

node 0: { .item = 0, .next = &(node 1) } <---- start, list 
node 1: { .item = ?, .next = ?   } <---- start->next, list->next 

list = list->next 

node 0: { .item = 0, .next = &(node 1) } <---- start 
node 1: { .item = ?, .next = ?   } <---- start->next, list 

i = 1; 
list->item = i; 

node 0: { .item = 0, .next = &(node 1) } <---- start 
node 1: { .item = 1, .next = ?   } <---- start->next, list 

list->next = malloc(...) 

node 0: { .item = 0, .next = &(node 1) } <---- start 
node 1: { .item = 1, .next = &(node 2) } <---- start->next, list 
node 2: { .item = ?, .next = ?   } <---- list->next 

list = list->next; 

node 0: { .item = 0, .next = &(node 1) } <---- start 
node 1: { .item = 1, .next = &(node 2) } <---- start->next 
node 2: { .item = ?, .next = ?   } <---- list 

т.д.

Answer 2

Это происходит потому, что, если этот assignment-

list = start; 

list указывает на тот же адрес, по которому start указывает на то, что изменения, сделанные в этом месте, одинаковы для обоих указателей (поскольку они указывают на то же место памяти).

Это же как в этом примере (может быть более простым кодом) -

int a; 
int *p1,*p2; 
p1=&a; 
p2=p1; 
*p1=5; 
prinf("value : p1=%d p2=%d",*p1, *p2); 
/* Both the pointer will have same value as change is made at memory location */