DSA Tutorial

🔍

Stack Basics Stack Operations Stack Implementation Stack Collection Frameworks Balanced Parentheses Expression Evaluation Monotonic Stack Practice Problems

Queue Basics Queue Operations Queue Implementation Queue Collection Frameworks Circular Queue Deque Priority Queue Queue in BFS Practice Problems

Tree Basics & Terminologies Types of Trees Binary Tree Basics & Types Binary Tree DFS Traversals BFS / Level Order Traversal Binary Tree Operations Binary Tree Practice Problems BST Basics BST DFS Traversals BST BFS Traversal BST Operations BST Practice Problems Heap Trie Advanced Trees

Graph Basics and Terminologies Graph Representation Types of Graphs Breadth First Search (BFS)Depth First Search (DFS)Connected Components Cycle Detection Topological Sort Shortest Path Algorithms Dijkstra's Algorithm Minimum Spanning Tree Union Find (DSU)Practice Problems

Backtracking Basics Decision Tree Thinking Time & Space Complexity Subsets Permutations Combination Problems N-Queens Sudoku Solver Word Search Common Mistakes Practice Problems

DP Basics State Transition Thinking Memoization Tabulation Memoization vs Tabulation 1D Dynamic Programming 2D Dynamic Programming Knapsack Pattern Longest Common Subsequence (LCS)Longest Increasing Subsequence (LIS)Practice Problems

Two Pointers Sliding Window Fast & Slow Pointers Prefix Sum Hashing Pattern Binary Search Pattern Greedy Pattern Divide & Conquer Heap Pattern Monotonic Stack & Queue Practice Problems

Top 100 DSA Problems Blind 75 NeetCode 150 Pattern → Problem Map Easy → Medium Roadmap Medium → Hard Roadmap FAANG Question Bank Mock Interviews

Weekly Revision Plan Spaced Repetition Guide Mixed Problem Sets Mock Interview Schedule Self Assessment Checklist

What is Data Structure?

Imagine you're moving into a new apartment. You have hundreds of books, kitchen items, clothes, and documents. If you throw everything into one room with no system, finding your passport in a hurry becomes a nightmare.

Now imagine organizing things differently. Books go on shelves sorted by topic. Important documents go in labeled folders. Kitchen items go in the right drawers. Suddenly, finding anything takes seconds instead of hours.

That is exactly what a data structure does for your program.

A data structure is a way of organizing, storing, and managing data in memory so that your program can access and modify it efficiently. It is not about what data you store — it is about how you store it and how fast you can work with it.

Every program you have ever used — from Google Search to WhatsApp — relies on carefully chosen data structures underneath. Without them, even the simplest applications would be impossibly slow.

Why Do Data Structures Matter?

Here is a concrete example. Suppose you are building a contacts app with 10 million users. A user searches for "Rahul Sharma."

Without the right data structure, your program scans every single contact from the beginning — 10 million comparisons in the worst case. With the right data structure (like a Hash Map), it finds Rahul in roughly one step.

That difference is the entire point of learning data structures.

Choosing the wrong data structure does not just make code slow — it makes features impossible to build at scale. This is why interviewers at Amazon, Google, and Microsoft ask about data structures heavily. They want to know if you can build systems that work not just for 10 users, but for 10 million.

We need data structures to:

›Access data quickly without searching everything unnecessarily
›Save memory by storing data without waste
›Perform operations like insert, delete, and update efficiently
›Solve complex problems that would be impossible with unorganized data

What Gets Stored in a Data Structure?

Data structures store data values and define the relationship between those values, along with the operations you can perform on them.

Three things define every data structure:

›What it stores — integers, strings, objects, or other data structures
›How the data is arranged — sequential, hierarchical, connected, or key-value pairs
›What operations are supported — insert, delete, search, traverse, sort

Different problems call for different arrangements. A to-do list naturally fits an array. A contact book fits a hash map. A company org chart fits a tree. A social network's friend connections fit a graph.

Types of Data Structures

Data structures fall into two broad families.

Linear Data Structures

In linear structures, elements are arranged one after another in a sequence. Each element has a clear predecessor and successor (except the first and last).

Data Structure	Key Idea	Common Use
Array	Fixed-size, index-based access	Storing a list of scores, prices
Linked List	Nodes connected by pointers	Undo/redo history, music playlists
Stack	Last-In, First-Out (LIFO)	Browser back button, function call stack
Queue	First-In, First-Out (FIFO)	Print queue, task scheduling

Non-Linear Data Structures

In non-linear structures, elements connect to multiple other elements. The relationship is not one-dimensional.

Data Structure	Key Idea	Common Use
Tree	Hierarchical parent-child structure	File systems, HTML DOM, organization charts
Graph	Nodes connected by edges in any direction	Social networks, maps, recommendation engines
Heap	Specialized tree for priority access	Priority queues, scheduling algorithms
Trie	Tree optimized for string and prefix search	Search autocomplete, spell checkers

Key-Value Data Structures

These are specialized for fast lookup by a key.

Data Structure	Key Idea	Common Use
Hash Map	Key-value pairs with O(1) average lookup	Caching, frequency counting, databases
Hash Set	Unique values with O(1) average lookup	Duplicate detection, membership testing

Common Operations on Data Structures

Every data structure supports some version of these five fundamental operations:

›Insert — Add new data into the structure
›Delete — Remove existing data from the structure
›Search — Find specific data within the structure
›Update — Modify existing data in place
›Traverse — Visit all elements in a defined order

How efficiently each operation runs depends entirely on which data structure you choose. That efficiency is measured using Time and Space Complexity, which you will study in the next topics.

Your First Data Structure: Array

Let us start with the most fundamental data structure — an array. It stores elements in a fixed-size, indexed sequence where every element sits in a numbered slot starting from zero.

The example below stores a list of student scores and demonstrates the five core operations: access, update, insert, search, and traversal.

Java

Try it out

import java.util.ArrayList;
import java.util.Arrays;

public class DataStructureIntro {

    public static void main(String[] args) {
        // An array stores elements in a fixed-size, indexed sequence
        int[] scores = {85, 92, 78, 95, 60};

        // Access — retrieve a specific element by its index (0-based)
        System.out.println("First score: " + scores[0]);

        // Update — change an existing value at a given index
        scores[2] = 88;
        System.out.println("Updated third score: " + scores[2]);

        // Traverse — visit every element in order
        System.out.print("All scores: ");
        for (int score : scores) {
            System.out.print(score + " ");
        }
        System.out.println();

        System.out.println("Total scores: " + scores.length);
    }
}

Output:
First score: 85
Updated third score: 88
All scores: 85 92 88 95 60
Total scores: 5

Dry Run: What Actually Happens

Let us walk through the array operations step by step on [85, 92, 78, 95, 60].

Initial state:
Index:  0    1    2    3    4
Value: [85,  92,  78,  95,  60]

Step 1 — Access scores[0]:
  → Return value at index 0 → 85

Step 2 — Update scores[2] = 88:
  → Replace value at index 2 (was 78) with 88
Index:  0    1    2    3    4
Value: [85,  92,  88,  95,  60]

Step 3 — Traverse:
  → Visit index 0: print 85
  → Visit index 1: print 92
  → Visit index 2: print 88
  → Visit index 3: print 95
  → Visit index 4: print 60

Final output: 85 92 88 95 60

Every operation runs in O(1) for access and update, and O(n) for traversal. No element is skipped. No element is visited twice during traversal.

All Five Operations in Action

Now let us see all five core operations together — insert, delete, search, update, and traverse — using a dynamic list.

Java

Try it out

import java.util.ArrayList;
import java.util.Arrays;

public class ArrayOperations {

    public static void main(String[] args) {
        // Dynamic array allows flexible size management
        ArrayList<Integer> numbers = new ArrayList<>(Arrays.asList(10, 20, 30, 40, 50));
        System.out.println("Initial: " + numbers);

        // Insert — add a new value at the end
        numbers.add(60);
        System.out.println("After insert 60: " + numbers);

        // Delete — remove a specific value
        numbers.remove(Integer.valueOf(30));
        System.out.println("After delete 30: " + numbers);

        // Search — find the index of a value
        int index = numbers.indexOf(40);
        System.out.println("40 found at index: " + index);

        // Update — replace a value at a specific index
        numbers.set(1, 25);
        System.out.println("After update index 1 to 25: " + numbers);

        // Traverse — visit every element
        System.out.print("All elements: ");
        for (int num : numbers) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}

Output:
Initial: [10, 20, 30, 40, 50]
After insert 60: [10, 20, 30, 40, 50, 60]
After delete 30: [10, 20, 40, 50, 60]
40 found at index: 2
After update index 1 to 25: [10, 25, 40, 50, 60]
All elements: 10 25 40 50 60

How Data Structures Affect Performance

Every data structure has different performance characteristics. This is a preview — Time and Space Complexity get full dedicated sections ahead — but here is why the choice matters:

Operation	Array	Linked List	Hash Map	Binary Search Tree
Access by index	O(1)	O(n)	N/A	N/A
Search by value	O(n)	O(n)	O(1)	O(log n)
Insert at end	O(1)	O(1)	O(1)	O(log n)
Insert at beginning	O(n)	O(1)	N/A	N/A
Delete by value	O(n)	O(n)	O(1)	O(log n)

There is no single best data structure. Each one makes certain operations fast while slowing others down. Choosing the right one for the right job is the skill this entire course builds toward.

How to Choose the Right Data Structure

When you face a new problem, ask yourself these questions:

How will I access the data?

If you need fast access by position, use an Array. If you need to look something up by a key (like a name or ID), use a Hash Map.

How often will I add or remove data?

If insertions and deletions happen frequently at arbitrary positions, a Linked List handles this better than an array. If you mostly read data, arrays are fine.

Does the data have a natural order or hierarchy?

Sequential data fits linear structures. Hierarchical data like folder systems or org charts fits trees. Connected data like social networks fits graphs.

What is the most critical operation?

Last-in-first-out access needs a Stack. First-in-first-out access needs a Queue. Priority-based access needs a Heap.

Data Structures and Algorithms Working Together

A common beginner confusion: "Are data structures and algorithms the same thing?"

They are different but deeply connected.

A data structure is the container — how you organize data in memory.

An algorithm is the process — the step-by-step instructions to solve a problem using that data.

They work together. Sorting algorithms operate on arrays. Graph traversal algorithms operate on graph data structures. Binary search operates on sorted arrays. You cannot master algorithms without understanding the data structures they operate on, and you cannot pick the right data structure without knowing what operations your algorithm requires.

Real-World Data Structures in Production

You interact with data structures dozens of times every day without realizing it.

›Google Search uses tries and inverted indexes to return results in milliseconds across billions of web pages
›WhatsApp uses queues to deliver messages in order even when you are offline
›Spotify uses graphs to build related-artist recommendations based on listening patterns
›Your computer's file system uses a tree to organize folders and files hierarchically
›Browser history uses a stack so the back button returns you to the previous page
›GPS navigation uses graphs and shortest-path algorithms to calculate routes in real time

Every feature you use daily has a data structure decision behind it.

Common Mistakes Beginners Make

Treating data structure choice as an afterthought. Beginners often write working code first and never question whether they chose the right structure. A working solution that uses arrays everywhere might be correct but completely unusable in production at scale.

Memorizing structures without understanding why. Knowing that a hash map gives O(1) lookup is useless without understanding why — and when that guarantee breaks down due to hash collisions or resizing.

Ignoring edge cases. Empty inputs, a single element, duplicate values — these break naive implementations. Always ask: what happens when the input is empty? What if all values are the same?

Skipping built-ins in learning. You should absolutely use HashMap, ArrayList, and deque in production. But during learning, understanding what happens underneath is what separates a good developer from a great one.

Interview Questions

Q: What is a data structure, and why does it matter?

A data structure is a way of organizing and storing data in memory to enable efficient access and modification. It matters because the choice of data structure directly determines how fast your program runs and how much memory it uses. The wrong choice can make a feature unusable at scale.

Q: What is the difference between linear and non-linear data structures?

In linear data structures (arrays, linked lists, stacks, queues), elements are arranged sequentially — each element has at most one predecessor and one successor. In non-linear data structures (trees, graphs), elements can connect to multiple other elements, representing hierarchical or network relationships.

Q: Why would you choose a Hash Map over an Array for a search problem?

An array gives O(1) access by index but O(n) search by value — you may need to scan the entire array. A hash map gives O(1) average-case lookup by any key, making it far better for problems like frequency counting, caching, and deduplication where you search by value rather than by position.

Q: Can you name the five fundamental operations on any data structure?

Insert (add data), Delete (remove data), Search (find data), Update (modify data), and Traverse (visit all elements). Every data structure supports these operations but at different time complexities depending on how the data is organized.

FAQs

Do I need strong math skills to learn data structures?

Not deeply. You need a basic understanding of how counting and comparison work, and eventually how logarithms behave for complexity analysis. No calculus or advanced math is required for the vast majority of DSA topics.

Which language should I use to learn data structures?

Any of the four covered here — Java, Python, C++, JavaScript — works well. Python is the most beginner-friendly for reading logic. Java and C++ are common in interviews. JavaScript is practical for web developers. This course teaches all four in parallel so you can learn in your preferred language and compare across languages simultaneously.

Should I memorize all data structures before solving problems?

No. Learn a data structure's concept and core operations, then immediately solve problems using it. Memorization without application fades quickly. You build real intuition by seeing the same structure solve ten different problems in different contexts.

What is the difference between a static array and a dynamic array?

A static array has a fixed size defined at creation time. A dynamic array (like Python's list or Java's ArrayList) can grow automatically. Under the hood, dynamic arrays still use static arrays — they allocate a new larger array and copy elements over when space runs out.

Quick Quiz

Question 1: Which data structure would you choose to implement a browser's back button?

›A) Array
›B) Queue
›C) Stack
›D) Hash Map

Answer: C) Stack. The back button needs Last-In, First-Out behavior — the most recently visited page is the first one returned when you press back.

Question 2: What is the time complexity of accessing an element by index in an array?

›A) O(n)
›B) O(log n)
›C) O(1)
›D) O(n²)

Answer: C) O(1). Arrays store elements in contiguous memory. Knowing the starting address and the index, the element's exact memory address is computed directly — no traversal needed.

Question 3: Which of these is a non-linear data structure?

›A) Stack
›B) Queue
›C) Linked List
›D) Tree

Answer: D) Tree. A tree has a hierarchical structure where one node can connect to multiple children. Stacks, queues, and linked lists are all linear — elements connect in a single sequence.

In the next topic, you will explore What is an Algorithm? — learning how to measure and reason about the step-by-step processes that operate on these structures.

←

PreviousIntroduction to DSA

NextWhat is an Algorithm?

→