Explanation of Simple Linked List Building code - c

Question

I am approaching to use this code for building singly linked list. I am pointing out the lines which get me bit confused .
struct node
{
int data;
struct node *next;
}*start=NULL; // point 1
void creat()
{
char ch;
do
{
struct node *new_node,*current;
new_node=(struct node *)malloc(sizeof(struct node));
printf("\nEnter the data : ");
scanf("%d",&new_node->data); //point 2
new_node->next=NULL; // point 3
if(start==NULL)
{
start=new_node;
current=new_node;
}
else
{
current->next=new_node;
current=new_node;
}
printf("\nDo you want to creat another : ");
ch=getche();
}while(ch!='n');
}
point1: What is the advantage declaring the structure node as a pointer?
point2: scanf("%d",&new_node->data);
Not getting the idea how the data is stored here to the 'data' field in context of pointer and structure?

Answer 1

How Linked lists are different from arrays? Consider the following points :
An array is a static data structure. This means the length of array cannot be altered at run time. While, a linked list is a dynamic data structure.
In an array, all the elements are kept at consecutive memory locations while in a linked list the elements (or nodes) may be kept at any location but still connected to each other.
So considering the purpose of dynamic creation of linked list we do not know how many nodes user will create.
Therefore in this case to allocate memory dynamically, pointers are used.
Using pointers will give you the memory location
for your struct.
The purpose of scanf() is to accept the data and store it into the memory location. Here you are accepting an interger value for your data into struct which is named as new_node. So assume your new_node is something like:
new_node = {int data | struct node *next} Here you want to accept the value for your integer field data
There for the scanf will store what ever value you will type into the address location of new_node's data.
Here "1" represents your new_node->data accepted and "NULL" is
new_node->next the pointer to next node.

Answer 2

0a) pointers only save memory addresses, the compiler relies on your declaration to determine how much memory from that address (from *ptr to *ptr + size) is considered part of the object.
0b) within the struct node, you are saving the address of the 'next' node instead of saving the values of the 'next' node. this means at any time there's only one copy of each node.
1) }*start=NULL; is a short-hand way of declaring a struct node pointer called start with initialized value NULL, which means its pointing at nothing.
2a) Declaring pointers of type struct node lets the compiler know that after the pointer it can expect sizeof(struct node) amount of memory behind it to be readable. Obviously you have to malloc that memory beforehand otherwise errors will occur. Finally, the "ptr->data" is equivalent to "(*ptr).data", which dereferences the pointer and then asks for the data element of the struct node.
2b) the form of
int x;
scanf("%d",&x);
passes the &x(address of x) to the function, which reads an int and puts it AT address pointed to by &x. so &ptr->data is basically == address of data.

Answer 3

point1: What is the advantage declaring the structure node as a pointer?
You can use pointer to structure as function argument rather than structure itself so as to avoid making copy of struct. As when you pass a struct compiler makes a copy of that struct.
point2: scanf("%d",&new_node->data);
Arrow Operator(->) is used to access members of structures by pointer variable.
Here in above scanf statement new_node is the pointer variable which is accessing member data of the structure.
This operation is similar to the Dot Operator(.) where we access members of structure using ordinary structure variable.