Confusion in Free'ing a linked list structure in C

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

Answer 2

All of these methods work fine. You can free memory blocks allocated by malloc in whatever order you like.

Just imagine for a moment that the order in which you allocated memory had to be reversed when you freed it. If that was so you could never insert or delete items from the middle of a list. Your only available dynamically allocated data structure would be a push-down stack.

Answer 3

Here's a simple way to free a linked list, starting at the head. (Note, this assumes "next" will be NULL if you're at the end of the list.)

node * it = head;
while( NULL != it ) {
  node * tmp = it;
  it = it->next;
  free(tmp);
}