Linked List reference pointers - linked-list

Question

I am learning linked list operations and have a question related to parameter passing.
Question 1:
I am creating a simple linked list with three values 1->2->3. And am trying to print it.
Below is my code. I am creating a node "first" in my main and am passing it to the method "createlinkedlist". I am using a pointer "head" and updating it within the method. But I see that the values of "head" are retained correctly outside the method "createlinkedlist". I dont understand how this is happening. I was thinking I should use referencial parameter passing like
void createLinkedList(struct node * & head) or void createLinkedList(struct node ** head)
instead of
void createLinkedList(struct node * head)
to get the correct values reflected outside the function. What am I missing here? Why am I able to see the correct values inside the printList method?
struct node
{
int data;
struct node * next;
};
void createLinkedList(struct node * head)
{
struct node * second = (node *)malloc(sizeof(node));
struct node * third = (node *)malloc(sizeof(node));
head->data = 1;
head->next = second;
second->data = 2;
second->next = third;
third->data = 3;
third->next = NULL;
}
void printList(struct node * first)
{
struct node * current = first;
while(current)
{
printf("%d",current->data);
current = current->next;
}
}
void main()
{
struct node * first = (node *)(malloc(sizeof(node)));
createLinkedList(first);
printList(first);
}
Question 2: I am using the same program as above , but adding a push function
void push(struct node *& first, int data)
{
struct node * newnode = (node*)malloc(sizeof(node));
newnode->data = data;
newnode->next = first;
first = newnode;
}
Now I see that unless I use a "&" for the first parameter in the push(), I am not able to see the updations in the printList method. It makes sense to me because we usually need to use a referncial parameter to make the local function changes seen outside the function. So if the list expects a referencial parameter here, why does it behave differently in the question 1 case.?
Pls. let me know.

Answer 1

Regarding Question 1)
You are not changing the pointer head in your createLinkedList method; you are changing the contents of the node that head points to. So of course you see that change after having called createLinkedList.
Regarding Question 2)
In the second case, you are actually adding a new node and you need to change the head pointer to point to the new head of the linked list, whereas in the first case, you keep the head of the list stable and add new nodes to the tail of the list. So you don't need to get the new address of the head of the list back to the caller, since the address of the head didn't change.
I would also create a node constructor function:
struct node * make_node(int data)
{
struct node * tmp = (node *)malloc(sizeof(node));
if (!tmp) {
/* error handling for malloc failure */
}
tmp->next = NULL;
tmp->data = data;
return tmp;
}
And another point:
If I were you, if I wrote a push function that added nodes to the head of the list, I would return the new head of the list explicitly:
struct node * push(const struct node * head, int data) {
struct node * fresh = make_node(data)
fresh->next = head;
return fresh;
}
Calling this like so:
struct node * head = make_node(1);
head = push(head, 2);
This is easier to understand than figuring out that push(head, 1) changes the head. But it's a question of style.

Answer 2

Change
struct node * first = (node *)(malloc(sizeof(node)));
struct node * second = (node *)(malloc(sizeof(node)));
struct node * third = (node *)(malloc(sizeof(node)));
parts to
struct node * first = (struct node *)(malloc(sizeof(struct node)));
struct node * second = (struct node *)(malloc(sizeof(struct node)));
struct node * third = (struct node *)(malloc(sizeof(struct node)));
. Since you initialized "node" without "typedef", "struct" needs to written before usage of "node" every time.

Answer 3

Since you're talking about references I'll assume you're using C++.
You would want to pass in struct node *& head if you're going to modify the pointer to head, but in your example you want to only modify the head node itself, and not the pointer to it, which is why you simply pass a pointer to it to let you look up the address. When you dereference the pointer via head->... you are looking up the location of head in memory and then moving to its data or next field. Alternatively, you could pass in the head as a reference: struct node & head, and modify things like head.data directly.
Your push needs to have either a reference to the first pointer (struct node *& first), or a pointer to the "first" pointer (struct node **first) so that you can actually modify the pointer itself. This is what's happening on the line:
first = newnode;
Alternatively, if you used struct node **first, you would do:
*first = newnode;
Both cases here for push are modifying a pointer to a struct node, as opposed to modifying a struct node itself.