Linked Lists (very intro) InsertBack - c

Question

#include <stdio.h>
#include <stdlib.h>
struct node
{
int data;
struct node *next;
};
typedef struct node node;
node* insertFront(node* head, int d);
node* insertBack(node* head, int d);
void print(node* head);
int max(node* head);
int min(node* head);
int locInList(node* head, int x);
int main()
{
node* head = NULL;
node* temp = NULL;
head = malloc(sizeof(node));
head = insertBack(head, 5);
head = insertFront(head, 4);
head = insertFront(head, 3);
head = insertBack(head, 6);
head = insertBack(head, 7);
print(head);
printf("\nMax: %d\n", max(head));
printf("Min: %d\n", min(head));
printf("locInList 5: %d\n", locInList(head, 5));
printf("locInList 9: %d\n", locInList(head, 9));
return 0;
}
node* insertFront(node* head, int d)
{
node *tmp = NULL;
tmp = malloc(sizeof(node));
tmp->data = d;
tmp->next = head;
head = tmp;
return head;
}
node* insertBack(node* head, int d)
{
node *ptr;
ptr->data=d;
ptr->next = NULL;
if(head==NULL)
{
head->data=d;
head->next=NULL;
}
else
{
node *temp=head;
while(temp->next != NULL)
{
temp=temp->next;
}
temp->next=ptr;
}
return head;
}
void print(node* head)
{
node *tmp = head;
while(tmp != NULL)
{
printf("%d ", tmp->data);
tmp = tmp->next;
}
}
int max (node* head)
{
int max;
while (head != NULL)
{
if (max > head->data)
max = head->data;
}
return max;
}
int min (node* head)
{
int min;
while (head != NULL)
{
if (min < head->data)
min = head->data;
}
return min;
}
int locInList(node* head, int x)
{
}
I'm having trouble with my InsertBack function, I want to add the value of d to the end of head.
The current output I'm getting with this code is:
3 4 0 7 7 7 7 7 7 7...repeating
The output should look like this
34567
Max: 7
Min: 3
Any help would be appreciated. I'm also very new to linked lists. So any help would be very appreciated!!

Answer 1

Here
node* insertBack(node* head, int d)
{
node *ptr;
ptr->data=d; // Dereference uninitialized pointer !!
ptr->next = NULL; // Dereference uninitialized pointer !!
if(head==NULL)
{
head->data=d; // Dereference NULL pointer !!
head->next=NULL; // Dereference NULL pointer !!
}
you have a major problem. You don't allocate memory! So you are dereferencing an uninitialized pointer. That's bad.
Try:
node* insertBack(node* head, int d)
{
node *ptr = malloc(sizeof *ptr);
ptr->data=d;
ptr->next = NULL;
if(head==NULL) return ptr;
...

Answer 2

For starters this statement in the beginning of main
head = malloc(sizeof(node));
does not make sense. You created an uninitialized node. As a result the program already invokes undefined behavior if you will try to perform any operation with the list except freeing the allocated memory.
Remove this statement.
You forgot to allocate memory for a node in the function insertBack.
node* insertBack(node* head, int d)
{
node *ptr;
ptr->data=d;
ptr->next = NULL;
//...
Also the body of the if statement
if(head==NULL)
{
head->data=d;
head->next=NULL;
}
does not make sense.
If to leave the function declaration as is then its definition can look the following way
node * insertBack( node *head, int d )
{
node *ptr = malloc( sizeof( node ) );
ptr->data = d;
ptr->next = NULL;
if ( head == NULL )
{
head = ptr;
}
else
{
node *temp = head;
while ( temp->next != NULL )
{
temp = temp->next;
}
temp->next = ptr;
}
return head;
}
Also these functions
int max (node* head)
{
int max;
while (head != NULL)
{
if (max > head->data)
max = head->data;
}
return max;
}
int min (node* head)
{
int min;
while (head != NULL)
{
if (min < head->data)
min = head->data;
}
return min;
}
are invalid because at least variables max and min were not initialized. Moreover they have an infinite loop and for example the function max is not finding the maximum value in the list.:)
It would be better to declare them like for example this
int max ( node* head, int *value );
In this case the definition of the function max could look like
int max( node* head, int *value )
{
int success = head != NULL );
if ( success )
{
*value = head->data;
while ( ( head = head->next ) != NULL )
{
if ( *value < head->data ) *value = head->data;
}
}
return success;
}
and the function can be called like
int max_value;
if ( max( head, &max_value ) )
{
printf( "The maximum value is %d\n", max_value );
}
The function min could be declared and defined the same way.
If to leave the function declarations as is then you have at least initialize the variables to 0. For example
int max (node* head)
{
int max = head == NULL ? 0 : head->data;
for ( ; head != NULL; head = head->next )
{
if ( max < head->data ) max = head->data;
}
return max;
}
The similar way can be defined the function min. Though as I pointed out it is better when the functions are defined the way I showed above.
And do not forget to write a function that will free the all allocated memory.