Question

Could someone please help me understand the concept of memory leaking and how specific data structures promote/prevent it (e.g. linked lists, arrays etc). I’ve been taught it twice by 2 different people a while ago – which has confused me slightly because of the differences in teaching methods.

Answer 1

Wikipedia has a good description on memory leaks. The defintion given there is:

A memory leak, in computer science (or leakage, in this context), occurs 
when a computer program consumes memory but is unable to release it back 
to the operating system.

For example, the following C function leaks memory:

void leaky(int n)
{
    char* a = malloc(n);
    char* b = malloc(n);
    // Do something with a
    // Do something with b
    free(a);
}

The above function leaks n bytes of memory as the programmer forgot to call free(b). What that means is that the operating system has n bytes less memory to satisfy further calls to malloc. If the program calls leaky many times, the OS may eventually run out of memory that it could allocate for other tasks.

As for the second part of your question, there is nothing intrinsic to data structures that makes them leak memory, but a careless implementation of a data structure could leak memory. As an example, consider the following function that deletes an element from a linked list:

// I guess you could figure out where memory is leaking and fix it.

void delete_element(ListNode* node, int key)
{
    if (node != NULL)
    {
        if (node->key == key)
        {
            if (node->prev != NULL) {
                // Unlink the node from the list.
                node->prev->next = node->next;
            }
        }
        else
        {
            delete_element(node->next, key);
        }  
    }
}