PNL Learn

Algorithms and Data Structures

Think in Big O and solve the problems interviews actually ask.

The course that gets you through technical interviews. You will measure code in Big O by counting real operations, then write binary search without off-by-one bugs, insertion sort, merge sort and quicksort, and sort by keys with stability in mind. You will build stacks, queues and a linked list, solve problems with hash maps, sliding windows and two pointers, write a binary search tree and its traversals, walk graphs with BFS and DFS, use heaps for priority queues, the top k and Dijkstra's cheapest paths, and turn exponential recursions into fast ones with memoization and bottom-up tables. It ends with the classic interview problems, graded against edge cases and efficiency budgets, while you learn to talk through a solution the way interviewers expect.

IntermediatePython8 lessons96 exercisesAbout 8 h
Create a free account

What you will learn

  • Big O analysis
  • Binary search and bisect
  • Sorting algorithms
  • Stacks, queues and linked lists
  • Hash maps and sets
  • Two pointers and sliding windows
  • Trees, BFS and DFS
  • Heaps and Dijkstra
  • Memoization and dynamic programming
  • Interview problem solving

Lessons

  1. 1

    Big O

    Count the work your code does, name its growth rate, simplify it the way interviewers do, and spot the hidden loops inside everyday Python.

    13 exercises

  2. 2

    Searching and Sorting

    Binary search without off-by-one bugs, boundary searches and the bisect module, insertion sort and merge sort written by hand, and stable sorting with keys.

    13 exercises

  3. 3

    Stacks, Queues and Linked Lists

    Use a list as a stack and a deque as a queue, then build a linked list with O(1) append, search, removal and in-place reversal.

    12 exercises

  4. 4

    Hash Maps and Two Pointers

    Turn O(n^2) searches into O(n) passes with dicts and sets, frequency counts, fixed and growing sliding windows, and two pointers.

    14 exercises

  5. 5

    Recursion, Trees and Graphs

    Think recursively, build a binary search tree, traverse trees in pre-, in- and post-order, and explore graphs with depth-first and breadth-first search.

    14 exercises

  6. 6

    Heaps and Priority Queues

    Use heapq as a priority queue, break ties safely, keep the top k of a stream in O(k) memory, and find the cheapest route with Dijkstra's algorithm.

    11 exercises

  7. 7

    Divide and Conquer and Memoization

    Write quicksort and quickselect, avoid the quadratic pivot, turn recursion into a loop when it runs too deep, and solve overlapping subproblems with memoization and bottom-up tables.

    11 exercises

  8. 8

    Interview Problems

    Talk through a solution like a strong candidate, check a clever answer against brute force, then solve five classic interview problems against edge cases and efficiency budgets.

    8 exercises

How you practice

You practice in the browser and every exercise gives you feedback right away. This course uses these formats:

  • Code exercise: 43
  • Predict the output: 13
  • Fix the bug: 12
  • Type the answer: 7
  • Fill in the blank: 6
  • Multiple choice: 6
  • Match the pairs: 3
  • Select all that apply: 3
  • Reorder lines: 2
  • Spot the bug: 1

Aligned to

CS2023ACM / IEEE-CS / AAAISource
  • Software Development Fundamentals
    • SDF-AlgorithmsAlgorithms
  • Algorithmic Foundations
    • AL-FoundationalFoundational Data Structures and Algorithms
    • AL-StrategiesAlgorithmic Strategies
    • AL-ComplexityComplexity

Proto Node Labs is not affiliated with or endorsed by ACM / IEEE-CS / AAAI. Exam names are trademarks of their owners.