Question

I am juggling with two ways of free()‘ing malloc()‘ed memory in a linked list structure. Suppose I create a singly linked list with the following C code;

#include<stdio.h>
#include<stdlib.h>

struct node_type{
  int data;
  struct node_type *next;
  struct node_type *prev;
}
typedef struct node_type node; 
typedef struct node_type *list; 

void main(void){
  list head,node1,tail;
  head=(list)malloc(sizeof(node));
  tail=(list)malloc(sizeof(node));
  node1=(list)malloc(sizeof(node));
  head->next=node1;tail->prev=node1;
  node1->prev=head;node1->next=tail;node1->data=1;

  /*Method-1 for memory de-allocation*/
  free(head->next->next);
  free(head->next);
  free(head);

  /*OR*/

  /*Method-2 for memory de-allocation*/
  free(tail);
  free(node1);
  free(head);

  /*OR*/

  /*Method-3 for memory de-allocation*/
  free(node1);
  free(tail);
  free(head); 
}

Now, I have the following questions:

Q1) Which of the three methods of memory de-allocation shown in code above are correct/incorrect.

Q2) Is is necessary to follow any order in the free()‘ing memory as used in Methods 1 and 2 for memory de-allocation OR randomly free()‘ing memory is also fine?

Answer 1

All the methods you showed are correct, you should follow a specific order only when the pointer to an allocated memory exists only in another allocated memory, and you will lose it if you free the container first.

For example, for the allocation:

int ** ipp;
ipp = malloc(sizeof(int*));
*ipp = malloc(sizeof(int));

The correct free order will be:

free(*ipp);
free(ipp);

and not:

free(ipp);
free(*ipp); // *ipp is already invalid