Skip to content
Insight CodeAcademy

Beginner to Advanced

Data Structures and Algorithms

A structured, pattern-first course that takes you from the fundamentals of complexity analysis to advanced graph and dynamic programming problems. You learn the reasoning that generalises, not a list of memorised solutions.

Duration
16 weeks
Modules
10
Topics
65
Format
Live and Recorded Classes

What you will be able to do

  • Analyse the time and space complexity of any piece of code with confidence
  • Recognise which of the core patterns a new problem belongs to within minutes
  • Implement every fundamental data structure from scratch and know when to reach for each
  • Break down dynamic programming problems into states and transitions systematically
  • Walk into a coding interview with a repeatable method instead of hoping you have seen the question

Who this is for

  • Working engineers preparing for product-company interviews
  • Self-taught developers with gaps in computer science fundamentals
  • Engineers who can solve problems they have seen before but freeze on new ones

Prerequisites

  • Comfort with any one programming language
  • Basic familiarity with loops, functions and arrays
  • No prior algorithms background required

Curriculum

10 modules, 65 topics, covered in depth.

  1. Module 1

    Foundations

    The measurement tools and basic structures every later module uses.

    • Time and space complexity, Big-O
    • Arrays and strings
    • Hash maps and hash sets
    • Linked lists
    • Stacks and queues
    • Monotonic stack

  2. Module 2

    Sorting

    How the core algorithms work, and sorting as a first step for harder problems.

    • Merge sort
    • Quick sort and partitioning
    • Counting sort and radix sort
    • Stability and custom comparators
    • Quickselect and the k-th element
    • Merge intervals and meeting rooms

  3. Module 3

    Two Pointers and Sliding Window

    Two techniques that replace nested loops: indices that move with purpose, and windows that expand and shrink.

    • Opposite-end pointers: pair sum
    • Same-direction pointers: removing duplicates
    • Fast and slow pointers, cycle detection
    • 3-Sum and k-Sum
    • Fixed-size windows
    • Variable windows: expand and shrink
    • Windows with a hash map: longest substring without repeats
    • Sliding window maximum with a deque
    • Prefix sums: when windows fail on negative numbers

  4. Module 4

    Binary Search

    Far more general than searching a sorted array.

    • Binary search on sorted arrays
    • First and last occurrence, lower and upper bound
    • Rotated sorted arrays
    • Binary search on the answer space
    • Searching in a 2D matrix
    • Avoiding off-by-one errors with loop invariants

  5. Module 5

    Recursion and Backtracking

    Building the mental model for problems that define themselves.

    • The call stack and base cases
    • Recursion trees and their complexity
    • Subsets, permutations and combinations
    • N-Queens and Sudoku
    • Pruning the search space
    • Converting recursion to iteration

  6. Module 6

    Trees

    Hierarchical data and the traversals behind every tree problem.

    • Traversals, recursive and iterative
    • Level-order traversal
    • Height, diameter and lowest common ancestor
    • Binary search trees: operations and validation
    • Balanced trees and why they matter
    • Tries and prefix search

  7. Module 7

    Heaps

    Priority-based access, and the problems that need it.

    • Heap property and array representation
    • Building a heap and its cost
    • Priority queues
    • Top-K problems
    • K-way merge
    • Streaming median with two heaps

  8. Module 8

    Graphs

    The structure that models the most real-world problems.

    • Graph representations
    • BFS and DFS
    • Grids as graphs
    • Topological sort
    • Union-Find
    • Shortest paths: Dijkstra and Bellman-Ford
    • Minimum spanning trees
    • Cycle detection

  9. Module 9

    Dynamic Programming

    Taught as a systematic method: define the state, find the transition, decide the order.

    • From recursion to memoisation to tabulation
    • 1D DP
    • 2D DP and grid problems
    • Knapsack variants
    • Longest common subsequence and edit distance
    • Longest increasing subsequence
    • DP on trees

  10. Module 10

    Interview Execution

    Knowing the answer is not the same as demonstrating it under pressure.

    • Structuring your thinking out loud
    • Clarifying requirements and edge cases
    • Writing clean code on a whiteboard or shared editor
    • Testing and debugging in an interview
    • Handling a problem you have never seen

Roles this prepares you for

  • Software Engineer
  • Senior Software Engineer
  • Backend Engineer
  • Full Stack Engineer

Frequently asked questions

Do I need a computer science degree to take this course?
No. The course starts from complexity analysis and assumes only that you can write code in some language. Many students are self-taught developers filling in fundamentals they never formally learned.
Which programming language is used?
Concepts are taught language-agnostically, with reference implementations provided. You can follow along in whichever language you will use in your interviews.
How much time do I need each week?
Plan for roughly eight hours a week across sixteen weeks. Most of that is problem solving rather than watching material, because the skill only develops through practice.
Is this course enough for FAANG-level interviews?
For the coding rounds, yes. Senior and staff roles also include system design rounds, which are covered in the DSA and System Design course.
How long do I get access?
You get one year of access to all course modules, plus six months of job support.