Eine verknüpfte Liste durchlaufen

Question

Ich bin neu in C und jetzt versuche ich, die Grundlagen der verknüpften Liste zu lernen. Der folgende Code ist nur das Segment, in dem eine verknüpfte Liste durchlaufen wird.

#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; 
} 

Ich bin verwirrt, dass die Ausgabe von „Start-> next“ nicht NULL ist, sondern eine feste Konstante Adresse. Aber ich habe NULL als Anfangs-> nächsten vor der for-Schleife zugewiesen und ändere nur die Komponente in "list" (list-> item und list-> next), nicht die Komponente in "start". Warum wird die Komponente in "Start" geändert?

Answer 1

Denken Sie daran, dass Sie haben: list = start: Sie zeigen dann beide auf den gleichen Knoten, und solange sie gleich sind, ist list->next das gleiche wie start->next.

Auf der for ersten Iteration start und list sind immer noch gleich und start->next NULL sein wird, bis Sie zu: list->next = .... Nach dieser ersten Zuweisung wird start->next so geändert, dass sie auf die Malloced-Adresse zeigt. Bei den nächsten Iterationen zeigt list auf andere Stellen und die Änderung list->next wirkt sich nicht auf start->next aus.

---

Schritt für Schritt: ("Knoten X" sind die Namen, die ich auf die von malloc Knoten geben, sie sind keine Variablen in Ihrem Programm)

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 

usw.

Answer 2

Diese da ist, wenn diese zuweisungs

list = start; 

list Punkte auf gleiche Adresse, an die start verweist auf, so dass die an dieser Stelle vorgenommenen Änderungen für beide Zeiger gleich sind (da sie auf denselben Speicherort zeigen).

Es ist das gleiche wie dieses Beispiel (vielleicht einfacher als Code) -

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 */