Where is logical error in the given code? - c

Question

I am trying to add a new node to the linked list. Online tutorials(http://www.geeksforgeeks.org/linked-list-set-2-inserting-a-node/) uses a pointer to a pointer and I am not able to understand how it works. So I decided to write my own code but I am having a problem with the push() function. Here is the code.
#include <stdio.h>
#include <stdlib.h>
struct node{
int data;
struct node* next;
};
void print_list(struct node *head_ptr)
{
while(head_ptr!=NULL)
{
printf("%d->",head_ptr->data);
head_ptr = head_ptr->next;
}
}
void push(struct node *head_ptr, int data_val)
{
struct node *new_node = (struct node*)malloc(sizeof(struct node));
new_node -> data = data_val;
new_node->next = head_ptr;
head_ptr = new_node;
}
int main()
{
struct node *head = (struct node*)malloc(sizeof(struct node));
struct node *second = (struct node*)malloc(sizeof(struct node));
struct node *third = (struct node*)malloc(sizeof(struct node));
head -> data = 1;
head -> next = second;
second -> data = 2;
second -> next = third;
third -> data = 3;
third -> next = NULL;
print_list(head);
push(head,0);
printf("\n");
print_list(head);
return 0;
}
It compiles without error. However, the expected node with value 0 does not get inserted in the beginning of my linked list.
Current Output
1->2->3->
Expected Output
0->1->2->3->
Please help me get the required output without using pointer to a pointer in push() function. Also, share a link to a source which has a good explanation of pointer to a pointer and it relates to the linked list.

Answer 1

You are doing it wrong way.
The thing is when you pass head in push a copy of it is passed to push. The content of them are same. Now what you are doing?
Creating new node. Then you make changes to that copy of the variable. Then the function ends and the lifetime of that variable ends and so is the access to the allocated memory (creating memory leak). And the original head in main() still is same. That's why it prints 1-2-3.
Solution-1
head = push(head,0);
And
struct node* push(struct node *head_ptr, int data_val)
{
struct node *new_node = (struct node*)malloc(sizeof(struct node));
new_node -> data = data_val;
new_node->next = head_ptr;
head_ptr = new_node;
return head_ptr;
}
Solution-2
void push(struct node **head_ptr, int data_val)
{
struct node *new_node = (struct node*)malloc(sizeof(struct node));
new_node -> data = data_val;
new_node->next = *head_ptr;
*head_ptr = new_node;
}
And call it like
push(&head,0);
Explanation of solution-2
Now here you pass &head to the function meaning you pass the address of it to the function push(). Now in push() you have a variable named head which is a contains the address of the head. Now by dereferencing it you are basically the head of main()and any changes you make to *head will retain because you are changing to the actual variable, whose address was passed.
Explanation of solution-1
Here we don't pass the address. But rather we pass the content of the head variable of main(). Now you allocate memory and you get it's address. You make changes to it. And then you put in the next the address of the head and then you point head to the newnode. And you may ask so it changes the origibal head? Nope. that's why we return it and we store it in the originbal head in main().
Note:
The dynamically allocated memory is have lifetime beyond the scope of the function. That's why you can return it's address and there will not be any problem.
You don't need to cast the return type of malloc. That's not needed.
struct node *new_node = malloc(sizeof(struct node));
Or
more clearly
struct node *new_node = malloc(sizeof *new_node));
Also check the return value of malloc.
Free the dynamically allocated memory when you are done working with it.

Answer 2

Where is logical error in the given code?
In C function arguments are always "call by value".
A function can change the function arguments but this has no impact on the argument in the calling function. Example:
void x(int a)
{
a = a + 10;
printf("%d\n", a);
}
void y(void)
{
int b = 9;
x(b); /* Line 1 */
x(123); /* Line 2 */
}
The line a = a + 10; will have the effect that 19 and 133 are printed instead of 9 and 123.
However it will not have the effect that b is changed to 19 in "line 1"; for "line 2" it should be clear that such an effect is even impossible.
In your code the line head_ptr = ... has the same effect.
Please help me get the required output ...
As the C language does not provide real "call by reference" arguments you use pointers to variables as "call by value" arguments to simulate "call by reference" arguments:
void x(int *a)
{
(*a) = (*a) + 10;
printf("%d\n", *a);
}
...
x(&b);
Or, in your example:
/* Note the two "**"s in this line: */
void push(struct node **head_ptr, int data_val)
{
...
*head_ptr = new_node; /* Note the "*" */
}
...
push(&head,0);
Of course you can only pass variables to functions this way.

Answer 3

Everything in C is passed by value. Even the pointers
So
I have two pointers
void swap(char* first, char* second)
{
//take temp var and swap
}
main(){
char *first, *second;
first = 0x1;
second = 0x2;
printf("%x, %x", first, second);
swap(first, second);
printf("%x, %x", first, second);
}
this code will not swap the values, since in swap(), the locally created values on stack are being swapped.
Realize that pointers are behaving just like another normal variables there.
Yes but if you dereference them you can swap the values pointed by the pointers inside the swap().
Catch is: head you passed is passed by value, the push() function does its job but assignment to head is done LOCALLY.

Answer 4

***SOLVED***
#include <stdio.h>
#include <stdlib.h>
struct node{
int data;
struct node* next;
};
void print_list(struct node *head_ptr)
{
while(head_ptr!=NULL)
{
printf("%d->",head_ptr->data);
head_ptr = head_ptr->next;
}
}
void push(struct node *head_ptr, int data_val, ***struct node *new_node***)
{
new_node -> data = data_val;
new_node->next = head_ptr;
head_ptr = new_node;
}
int main()
{
struct node *head = (struct node*)malloc(sizeof(struct node));
struct node *second = (struct node*)malloc(sizeof(struct node));
struct node *third = (struct node*)malloc(sizeof(struct node));
***struct node *new_node = (struct node*)malloc(sizeof(struct node));***
head -> data = 1;
head -> next = second;
second -> data = 2;
second -> next = third;
third -> data = 3;
third -> next = NULL;
print_list(head);
push(head,0,new_node);
printf("\n");
print_list(***new_node***);
return 0;
}