Data Structures and Algorithms Roadmap
A complete beginner-to-advanced Data Structures and Algorithms roadmap built from the Gate Smashers playlist, covering arrays, searching, linked lists, stacks, recursion, queues, trees, balanced search trees and graph algorithms.
Learning outline
Expand a stage, choose a topic and start its Gate Smashers lectures.
01Foundations, Arrays & Search6 topics · 15 lectures0 / 15
▶DSA Roadmap & Foundations0 / 2 lectures
▶Arrays: Structure & Representation0 / 2 lectures
▶Linear & Binary Search0 / 2 lectures
▶Array Address Calculation0 / 3 lectures
▶Lower Triangular Matrix Addressing0 / 1 lectures
▶Array Problem-Solving Patterns0 / 5 lectures
02Linear Data Structures11 topics · 36 lectures0 / 36
▶Linked List Foundations0 / 3 lectures
▶Linked List Traversal & Insertion0 / 5 lectures
▶Linked List Deletion0 / 4 lectures
▶Doubly Linked Lists & Cycle Detection0 / 2 lectures
▶Stack Implementation0 / 5 lectures
▶Infix, Prefix & Postfix Notation0 / 3 lectures
▶Expression Conversion Using Stack0 / 3 lectures
▶Postfix Evaluation0 / 2 lectures
▶Recursion & Call Stack0 / 3 lectures
▶Queue Operations & Array Implementation0 / 5 lectures
▶Queue Using Linked List0 / 1 lectures
03Trees & Balanced Search Trees6 topics · 12 lectures0 / 12
▶Binary Tree Foundations0 / 1 lectures
▶Binary Search Tree Operations0 / 3 lectures
▶Tree Traversal & BST Practice0 / 2 lectures
▶AVL Trees & Rotations0 / 3 lectures
▶Complexity of Tree Structures0 / 1 lectures
▶Red-Black Trees0 / 2 lectures
04Graph Algorithms & Completion2 topics · 3 lectures0 / 3
▶Topological Sort in DAG0 / 1 lectures
▶Cycle Detection with DFS0 / 2 lectures
Topics covered in this roadmap
Use this stage-by-stage outline to understand the complete learning path before opening the interactive roadmap.
Foundations, Arrays & Search
DSA Roadmap & Foundations
Build the mental model for studying data structures: what data structures are, why they are used, and how the playlist is organized. This gives the vocabulary and learning sequence needed before working with concrete structures.
Arrays: Structure & Representation
Arrays store a finite ordered collection of homogeneous elements in contiguous memory. These videos cover declaration, initialization, indexing, dimensions and how one-dimensional and multidimensional arrays are represented.
Linear & Binary Search
Searching finds a target element within a collection. Linear search checks candidates one by one, while binary search repeatedly narrows a sorted search space and achieves much better logarithmic behavior.
Array Address Calculation
Array addressing converts an index into a memory address using the base address, element size and bounds. The mapped lessons extend this idea from 1D arrays to row-major addressing of 2D and 3D arrays.
Lower Triangular Matrix Addressing
A lower triangular matrix contains useful values on and below the main diagonal, allowing compact storage instead of reserving space for all n² positions. The lesson focuses on locating an element correctly in that compact representation.
Array Problem-Solving Patterns
These lessons move from raw array representation to common interview-style patterns: second-largest element, two pointers, maximum-sum subarray reasoning, sliding windows and duplicate removal. The emphasis is on recognizing when a structured traversal is better than repeated brute-force work.
Linear Data Structures
Linear Data Structures
This phase organizes structures whose elements are processed in a linear order. Linked lists, stacks and queues differ mainly in how they store elements and which positions their operations expose.
Linked Lists
Linked lists represent sequences through nodes connected by links. The branch covers structure, traversal, insertion, deletion, doubly linked lists and cycle detection.
Stacks & Recursion
Stacks restrict access to one end, making them useful for nested computation, expression handling and function calls. This branch combines stack implementation, expression applications and recursion because each relies on last-in, first-out behavior.
Queues
Queues process elements in first-in, first-out order. The branch covers core operations and both array-based and linked-list implementations.
Linked List Foundations
These lessons explain why linked lists are used, how they differ from arrays, and how a singly linked node is represented with a self-referential link. This establishes the pointer structure needed for every later list operation.
Linked List Traversal & Insertion
Traversal is the basic operation used to visit nodes and locate insertion positions. The mapped videos then build insertion at the beginning, at the end and after a specified node.
Linked List Deletion
Deletion removes nodes while keeping the remaining chain valid. These lessons cover deletion from the beginning, end, after a specified node, and removal of an entire singly linked list.
Doubly Linked Lists & Cycle Detection
A doubly linked list adds a previous link to support movement in both directions. Cycle detection addresses a different linked-list problem: identifying whether following next links eventually returns to an already visited region using a two-pointer strategy.
Stack Implementation
A stack follows LIFO order and exposes operations at a single top position. The mapped lessons implement PUSH and POP first with an array and then with a linked list.
Infix, Prefix & Postfix Notation
Arithmetic expressions can be written with operators between operands, before operands or after operands. These lessons establish the notation rules and manual conversion ideas needed before applying stack-based conversion algorithms.
Expression Conversion Using Stack
Stacks provide an algorithmic way to handle operator precedence while converting infix expressions. The videos cover stack-based prefix/postfix conversion and practice the exact decisions for operands, operators and parentheses.
Postfix Evaluation
Postfix expressions can be evaluated directly with an operand stack because operator order is explicit. The mapped examples reinforce when operands are pushed and how operator results are returned to the stack.
Recursion & Call Stack
Recursion solves a problem by invoking the same function on smaller instances, while loops repeat work through iteration. These lessons connect recursive calls to call-stack behavior and examine how recursive structure affects execution and time complexity.
Queue Operations & Array Implementation
A queue exposes insertion at the rear and removal from the front. These videos explain ENQUEUE, DEQUEUE, full/empty checks and the array-based bookkeeping needed to maintain queue state.
Queue Using Linked List
A linked-list queue represents queued elements as connected nodes rather than fixed array positions. The mapped lesson focuses on maintaining the references needed to enqueue efficiently while preserving FIFO order.
Trees & Balanced Search Trees
Trees & Balanced Search Trees
Trees organize data hierarchically rather than linearly. This phase moves from binary-tree terminology to BST operations, traversals, AVL balancing, complexity comparison and Red-Black trees.
Binary Tree Foundations
Binary trees introduce hierarchical node relationships and several structural classifications. The lesson distinguishes common forms such as full, complete and almost-complete binary trees so later search-tree properties are not confused with shape properties.
Binary Search Tree Operations
A Binary Search Tree adds an ordering rule to a binary tree so insertion, search-oriented traversal and deletion can use key comparisons. These lessons cover construction, deletion cases and the standard depth-first traversal orders on BSTs.
Balanced Search Trees
Balanced search trees keep search-tree height under control by repairing structural imbalance. This grouping separates AVL and Red-Black strategies from ordinary BST operations while retaining their shared ordered-tree foundation.
Tree Traversal & BST Practice
Traversal questions test whether the structural rules of a tree can be translated into preorder, inorder and postorder sequences. The mapped practice also applies BST properties in an exam-style problem rather than only demonstrating definitions.
AVL Trees & Rotations
AVL trees keep a Binary Search Tree height-balanced by monitoring balance after updates. The lessons explain AVL properties and the LL, RR, LR and RL rotations used while constructing balanced trees.
Complexity of Tree Structures
Tree operations depend heavily on height and structural guarantees. This lesson compares the time-complexity behavior of binary trees, BSTs, AVL trees and heaps so learners can connect shape and balancing to performance.
Red-Black Trees
Red-Black trees are self-balancing Binary Search Trees that enforce coloring constraints to bound height. The mapped videos introduce the invariants and then apply recoloring and rotations during insertion.
Graph Algorithms & Completion
Graph Algorithms
Graphs model relationships that are not restricted to a tree hierarchy. The final technical phase focuses on ordering vertices in a DAG and detecting cycles in both undirected and directed graphs using depth-first search.
Topological Sort in DAG
Topological sorting produces a linear ordering that respects the direction of every dependency edge in a directed acyclic graph. The lesson focuses on understanding when such an order exists and what the ordering condition means.
Cycle Detection with DFS
Cycle detection asks whether traversal can return to a previously active or visited part of a graph in a way that forms a closed path. These lessons show DFS-based reasoning separately for undirected and directed graphs because the parent/back-edge conditions are different.
Data Structures and Algorithms Roadmap Complete
You have reached the end of this playlist-based DSA roadmap, from core representations and linear structures through balanced trees and graph algorithms. Use this point as a checkpoint to revise weak branches and practice implementation problems across the structures covered.