The DSA Illusion: Why Most Data Structures Don’t Actually Exist

Md Sala Uddin — Sun, 29 Mar 2026 22:41:16 +0000

Beginner DSA Lesson #2

Overview

If you’re just starting out in C++ and DSA, you’ve probably seen a long list that looks like this:

Arrays, Linked Lists, Stacks, Queues, Trees, Graphs, Hash Tables, Sorting, Recursion…

When I first saw that, I thought:

“I have to learn and memorize all of these completely different things?”

It felt impossible.
But as I started planning my DSA study, I realized something that changed everything:

Most of these data structures aren’t new “things” at all….they’re just different ways of using the same two building blocks.

If you can see that clearly, DSA suddenly feels a lot less scary.

This lesson is just an overview.
You definitely don’t need to fully understand every word or code snippet right now.
The goal is just to plant the idea: there are two main building blocks, and everything else is built on top of them.

What’s Actually in Your Computer’s Memory?
Your computer stores data in RAM, and at the lowest level, there are basically two main ways data can live in memory:

Arrays

Think of an Array like a straight row of lockers in a gym.
Each locker sits directly next to the one before it.

In C++, that means all data is stored in one contiguous block of memory, one right after the other.

Linked Lists

A Linked List is like scattering pieces of paper all over a table, with each paper having a note that says, “See the next one over here.”

In C++, each piece of paper is a node, and it has a pointer to the next node.
That’s it.

At the hardware level, you’re either:

Packing data side‑by‑side (arrays), or

Scattering it and pointing from one piece to the next (linked lists).

Everything else you see (Stacks, Queues, Trees, Graphs) is built on top of these two ideas.

Don’t worry if this feels fuzzy.
We’ll make it crystal clear in the next few lessons, one tiny step at a time.

What Are Stacks, Queues, Trees, and Graphs?

Let’s demystify the “scary names” in plain English:

Stack
A Stack is like a stack of plates at a buffet: last one you put on, first one you take off. In C++, that’s: A physical structure (an Array or Linked List),With a rule: you can only add or remove from the top.

Queue
A Queue is like a line of people at Tim Hortons or McDonalds: first in line, first served.
In code, a Queue is A physical structure (like an Array or Linked List),With rules that let you only add at the back and remove from the front.

Tree
A Tree is like a family tree: one person can have two children.
In C++, a Tree is A Linked List where each node has two pointers instead of one, creating branches.

Graph
A Graph is like a social network: people can be connected to many other people, not just one or two. In C++, a Graph is: A bunch of nodes that link to many other nodes.

They’re not “new hardware.”
They’re rules and patterns you apply on top of Arrays and Linked Lists.

Again, you don’t need to fully get all of this today.
The goal is just to plant the idea that: Arrays and Linked Lists are your building blocks. Everything else is a pattern on top.

Quick C++ Glimpse (Don’t Overthink It)

You don’t need to fully understand the code today-just get a feel for it.

Array example (simple):


int arr[] = {10, 20, 30, 40};
// All values live in one continuous block in memory.

Node example (linked list idea):

struct Node {
int data;
Node* next; // pointer to the next node
};

You’ll see this kind of code again later, with much slower, step‑by‑step explanations.
For now, just remember:
Arrays and Linked Lists are your building blocks. Everything else is a pattern on top.

What’s Next in This Series

Now that you have the idea of big picture, that everything is just a pattern built on Arrays and Linked Lists it’s time to get our hands dirty with the actual tools.

> Before we can build these structures, we need to master the C++ “toolbox.” The basic C++ concepts you need to know for DSA…

In the next part of this journey, we’re diving into a few blog series on Essential C++ Concepts for DSA. We’ll break down everything from Arrays and Pointers to Structures, Classes, and Templates.

These are the literal building blocks you’ll use to turn these “scary names” into working code. See you in the next one!

If you’re scared or confused right now, that’s okay.

You’re not behind.
You’re exactly where you need to be to start learning DSA in a way that actually makes sense.

I Stopped Running From DSA. Here’s How I’m Hacking My Brain to Learn It in C++

Md Sala Uddin — Sat, 28 Mar 2026 22:30:48 +0000

Beginner DSA Lesson #1

Introduction

Why the best way to master Data Structures & Algorithms is to build in public, and how you can follow along.

Let’s be real for a second. If you are learning software development, there are three letters that probably make you want to close your laptop and walk away: D-S-A.

For a long time, Data Structures and Algorithms felt like an intimidating, invisible gatekeeper. Between grinding through my computer programming classes at School and balancing everyday life, it was always easier to put it on the back burner and just focus on building front-end projects.

But recently, I cleared my schedule, stepped away from my part time job, and made a non-negotiable decision: I am going all-in on mastering DSA using C++. No more avoiding the hard stuff.

And I am documenting every single step of the journey right here.

Why am I writing this?

If you read most tutorials on pointers, memory management, or time complexity, they are usually written by senior engineers who forgot what it feels like to be a beginner. They read like dense, dry textbooks.

I’m taking a different approach. I am in the trenches learning this right now.

I’ve realized that the ultimate cheat code to truly understanding complex logic is to translate it into plain English. By breaking down these concepts for you, I am forcing myself to eliminate any gaps in my own knowledge. We are going to demystify the scary stuff together.

How I’m Approaching DSA

I’m keeping my approach simple. Below are the methods I’m using to understand properly::

Learn, then explain
After learning a concept, I try to explain it in the simplest way possible. If I struggle to do that, I go back and review it.
Break topics down
Instead of trying to learn large topics at once, I break them into smaller parts.
For example, instead of “Linked Lists,” I focus on:
What a node is
How pointers connect nodes
How insertion works
Use C++ to understand the details
C++ forces you to deal with memory and pointers directly. It’s not always easy, but it makes things clearer over time.
Keep explanations simple
I’m not trying to sound technical. The goal is clarity. If something can’t be explained simply, it probably isn’t understood properly yet.

What I’ll Be Covering (Step by Step)

Here’s the rough path I’m following, from zero to “I can actually solve problems”:

Necessary C++ concepts with a DSA angle
(variables, memory, stack vs heap, pointers, references)
Recursion
(what it is, why it’s confusing, how to see the pattern)
Arrays, strings, and linked lists
(how data is stored, moved, and changed)
Stacks and queues
(simple structures that show up everywhere)
Trees and heaps
(how to store data in a “family tree” style structure)
Graphs
(networks like social media, roads, and connections)
Sorting, searching, hashing
(how to find and organize things efficiently)
Problem-solving patterns
(dynamic programming, backtracking, and other “big scary names” explained calmly)

Each topic will be split into tiny lessons so you never feel overwhelmed.

If You’re Also Scared of DSA
DSA can feel overwhelming at first. It definitely did for me. But avoiding it doesn’t make it easier. So I decided to stop putting it off and actually work through it, one concept at a time.

What helped was:

Admitting I was scared of it
Breaking it into small pieces
Letting myself be bad at it at first
You don’t need to be “smart enough” to learn this.
You just need to move slowly and consistently.

If you’re in the same place, you’re not behind. You’re just starting……like me.

If you’re in the same position, you’re not alone.

Forem: Md Sala Uddin