Freeing memory from dynamically allocated array of linked lists

Hi folks,
Having some frustrating issues trying to free memory from a dynamically allocated array of pointers to linked lists. I think the problem is in how I initialize the pointers to NULL. Is there a more elegant way to have the program recognize that the list is empty so it knows to create a head node for the linked list in the function 'add_end_stub_to_array'?

I ran the code through Valgrind and it says that memory is definitely lost from this array. Any help would be greatly appreciated.
Thanks!

This is the structure definition.

Code:

---

struct stub_edge {
      int loc_id;
      int anim_type;
      int mkt;
      struct stub_edge *next_node;
  };

---

Here is the code snippet from main allocating and deallocating memory to the array.

Code:

---

struct stub_edge **stub_list = (struct stub_edge **)malloc( sizeof(struct stub_edge *) * 12);
for (i = 0; i < 12; i++)
  {
    stub_list[i] = (struct stub_edge *)malloc(sizeof(struct stub_edge));
    stub_list[i] = NULL;
  }
 
stub_list = add_end_stub_to_array(end_stubs, stub_list);
destroy_end_stub_array(stub_list);

---

Here the function for adding nodes to the lists by reading through a dynamically allocated 2D array. (The end_stubs array is ordered by month and each linked list represents events occuring within the month).

Code:

---

struct stub_edge **add_end_stub_to_array(int **end_stubs, struct stub_edge **list)
{
  long int i = 0;
  int mon = 0;
 
  struct stub_edge *current_node1;
  struct stub_edge *new_node1;
   
  int break1 = 0;
  while(i < num_edges && break1 == 0 && mon < 12)
    { 
        current_node1 = list[mon];
        if(current_node1 == NULL && end_stubs[i][1] == mon)
            {
              current_node1 = (struct stub_edge*)malloc(sizeof( struct stub_edge ));         
              current_node1 -> loc_id = end_stubs[i][0];
              current_node1 -> anim_type = end_stubs[i][2];
              current_node1 -> mkt = end_stubs[i][5];
              current_node1 -> next_node = NULL;         
              i = i + 1;
              list[mon] = current_node1;
            }
        while( end_stubs[i][1] == mon && break1 == 0 )
            {
              new_node1 = (struct stub_edge*)malloc(sizeof( struct stub_edge ));         
              new_node1 -> loc_id = end_stubs[i][0];
              new_node1 -> anim_type = end_stubs[i][2];
              new_node1 -> mkt = end_stubs[i][5];
              new_node1 -> next_node = NULL;

              current_node1 -> next_node = new_node1;
              current_node1 = new_node1;
              i = i + 1;
              if(i == num_edges)
                  {
                    break1 = 1;
                    i = 0;
                  }
            }         
        mon = mon + 1;
    }
 
 return(list);           
}

---

Here is the function for freeing memory from the list.

Code:

---

void destroy_end_stub_array(struct stub_edge **list)
{ 
  if(list != NULL)
    { 
        int mon = 0; 
        struct stub_edge *current_node1;
        struct stub_edge *new_node1;

        for(mon = 0; mon < 12; mon++)
          {
            current_node1 = list[mon];
            while(current_node1 != NULL)
                {
                  new_node1 = current_node1 -> next_node;
                  free(current_node1);
                  current_node1 = new_node1;
                }
            free(list[mon]);
          }
    }

---

I think I just solved my own problem. I shouldn't have malloc'ed memory to the array pointers when initializing the array because I then lose that memory when I allocate a new head node to the list. (Face palm).