Why Linked List Is Better Than Array in Some Cases? A Personal Experience

When I first started learning programming, arrays felt like the ultimate tool. They were neat, organized, and easy to understand. If I needed to store 10 integers, I would just declare int arr[10]; and voilà, my data was ready to go. But as I worked on more complex projects, I began to see the limitations of arrays. That’s when I stumbled upon linked lists, and honestly, they changed how I thought about data structures.

In this article, I’ll share my personal journey with arrays and linked lists, the problems I encountered, and why sometimes a linked list is the better choice.

My First Encounter With the Problem

I remember working on a small project where I had to manage a dynamic list of users. At first, I thought:
“Easy! I’ll just use an array. I can always increase its size if needed.”

So, I started with something like this in C:

int users[100];

It worked… until I realized I didn’t know how many users I would need. What if there were more than 100? I could allocate a bigger array, but then came the issue of resizing.

In C, arrays have a fixed size once declared. If I needed more, I had to create a new array, copy everything over, and then delete the old one. It was messy and inefficient. That’s when I realized arrays are not flexible in terms of size.

Discovering Linked Lists

While searching for solutions, I came across linked lists. At first, they looked complicated. A structure pointing to another structure? It felt like overkill. But the more I dug into them, the more I realized how beautifully flexible they are.

Here’s a simple definition of a linked list node in C:

struct Node {
    int data;
    struct Node* next;
};

Unlike arrays, a linked list doesn’t need a fixed size. I could just keep adding nodes as needed. That solved my resizing problem perfectly.

Memory Management: The Real Eye-Opener

Another big moment for me was understanding how memory works in arrays vs. linked lists.

• Arrays require contiguous memory allocation. That means if I need an array of size 1000, the system has to find a big continuous chunk of memory for me. Not always easy when memory is fragmented.

• Linked lists, on the other hand, can store nodes anywhere in memory. Each node just needs to know where the next node is.

This was a game-changer for me because I was working on embedded systems with limited memory. Linked lists allowed me to utilize memory more efficiently without worrying about finding a huge contiguous block.

Insertions and Deletions: Where Arrays Lose

One particular bug made me truly appreciate linked lists. I had to repeatedly add and remove elements in the middle of my array. In arrays, this meant shifting all the elements after the insertion or deletion point.

For example, inserting into an array:

// Insert at index 2
for (int i = n; i > 2; i--) {
    arr[i] = arr[i-1];
}
arr[2] = newValue;
n++;

This operation was O(n) because of the shifting.

In contrast, with a linked list, inserting was just about adjusting a couple of pointers:

struct Node* newNode = malloc(sizeof(struct Node));
newNode->data = newValue;
newNode->next = current->next;
current->next = newNode;

That’s it! Constant time if you already have the pointer to the insertion spot.

From that moment, I knew: if my project required frequent insertions or deletions, linked list beats array hands down.

When Arrays Still Win

Of course, I don’t want to paint arrays as the villain here. Arrays are still extremely useful, especially when:

• You need fast random access (arrays allow direct indexing with arr[i], which is O(1)).

• The data size is known and fixed.

• Memory access patterns matter (arrays are cache-friendly).

I remember working on a sorting algorithm project. Arrays outperformed linked lists because accessing elements sequentially in memory was much faster. So arrays still had their place in my toolbox.

How I Use Linked Lists Today

Now, whenever I start a project, I ask myself a few questions:

• Will the data size change frequently? → Use linked list.

• Do I need quick insertions and deletions? → Linked list again.

• Do I need random access and speed? → Array wins here.

This thought process has saved me a lot of debugging headaches.

For example, when I worked on a simulation that required adding and removing “events” dynamically, a linked list was the perfect solution. I could push and pop events as they happened without worrying about resizing arrays.

Lessons Learned

From my journey, here’s what I learned:

1. Arrays are great for speed and fixed-size data.

2. Linked lists shine when flexibility and dynamic size are needed.

3. Don’t pick one blindly—understand your problem first.

It took me running into bugs, resizing issues, and slow insertions to truly appreciate linked lists. Once I understood their strengths, I started writing cleaner and more efficient programs.

If you’re just starting out in C/C++, arrays might feel like the only option. But when your programs grow and your data structures need to adapt, linked lists can be your best friend.

My advice? Experiment with both. Try implementing the same problem using arrays and then using linked lists. You’ll see firsthand why sometimes linked lists are the better choice.

For me, the turning point was realizing that data structures are like tools. Arrays are like a hammer—simple, powerful, but limited. Linked lists are like a Swiss army knife—flexible, versatile, and ready for complex tasks.

And in programming, having the right tool for the job makes all the difference.