₹0 for students · Certificate · Beginner

Data Structures in Python

6 mini courses, 27 lessons: Big-O, stacks, queues, linked lists, sorting, trees, heaps, hashing and graphs

Start free in the app

27 lessons · ~5 hours · 30-question final exam · pass mark 70%

About the course

What you’ll learn

The data structures every placement test and technical interview checks, taught from first principles with Python you run on your phone. Six one-hour mini courses take you from measuring how fast code is, through stacks, queues and linked lists, searching and sorting, trees and heaps, to hash tables and graphs. Every lesson starts from something you already use, shows the idea moving, lets you practise, and ends with an interview-style question. Already know some of it? Take the 5-minute skill check and skip what you know. Pass every lesson quiz and the final exam to earn a verifiable certificate.

Data structuresBig-O analysisStacks and queuesLinked listsSearching and sortingTrees and heapsHash tablesGraph searchProblem solvingPython

Part of the career track: Computer Science Foundations

How the certificate works

  1. Read each lesson’s study guide, then the full lesson and any notebooks or exercises.
  2. Pass every lesson quiz with 70% or more.
  3. Pass the final exam: 30 questions in 45 minutes.
  4. Get a certificate with a public verification link, and add it to LinkedIn.

Syllabus

27 lessons and 7 hands-on projects in 6 mini courses

Each mini course takes about an hour. Already know one? Test out in the app and skip it.

1. How fast is your code?

Tell fast code from slow code, and say why in Big-O.

1
Why Speed Matters
10 min · A data structure stores data so the operations you need are fast.
2
Counting Steps
10 min · Count basic steps instead of timing: counts depend only on the code and the input.
3
Big-O Families
12 min · O(1) constant, O(log n) halving, O(n) linear, O(n log n) good sorting, O(n²) nested loops, O(2ⁿ) every subset.
4
Memory Cost
10 min · Space complexity counts extra memory beyond the input, in Big-O.
5
Recursion
12 min · A recursive function calls itself on a smaller piece of the problem.
★
Project: Exam registration checkerHands-on project
25 min · 3 steps, checked as you go

2. Stacks and queues

Pick and use a stack, queue or deque for undo, matching, scheduling and parsing problems.

6
Python Lists as Arrays
10 min · A Python list is a dynamic array: items side by side in memory.
7
Stacks: Undo and the Back Button
10 min · A stack is LIFO: last in, first out.
8
Evaluating Expressions with a Stack
12 min · Infix puts operators between numbers; postfix puts them after (3 4 2 × +).
9
Queues and Circular Queues
10 min · A queue is FIFO: first in, first out.
10
Deques and Priority Queues
10 min · A deque supports O(1) add and remove at both ends.
★
Project: Notes app: undo, redo and a print queueHands-on project
30 min · 3 steps, checked as you go

3. Linked lists

Build, change and reverse linked lists, and know when they beat a Python list.

11
Nodes and Links
10 min · A linked list is a chain of nodes; each holds a value and a link to the next.
12
Insert and Delete
12 min · Insert after p: new.next = p.next, then p.next = new (order matters).
13
Doubly and Circular Lists
10 min · A doubly linked list has next and prev links: move both ways.
14
List or Linked List?
10 min · Arrays: O(1) indexing and cache-friendly looping; linked lists: O(1) changes at a held node, O(n) indexing.
★
Project: Music playlistHands-on project
35 min · 4 steps, checked as you go

4. Searching and sorting

Search sorted data in log time and explain how the main sorting algorithms work and compare.

15
Linear and Binary Search
12 min · Linear search checks items one by one: O(n), works on any data.
16
Bubble, Selection and Insertion Sort
12 min · Bubble, selection and insertion sort are O(n²).
17
Merge Sort
12 min · Merge sort splits in half, sorts each half recursively, then merges.
18
Quick Sort
12 min · Quick sort picks a pivot, partitions smaller items left and larger right, then recurses.
19
Picking the Right Sort
10 min · Use sorted() or list.sort(): O(n log n) and stable.
★
Project: Results portalHands-on project
35 min · 4 steps, checked as you go

5. Trees and heaps

Traverse trees, use binary search trees, and solve top-k problems with a heap.

20
Trees and Traversals
12 min · A tree has one root; every other node has one parent; leaves have no children.
21
Binary Search Trees
12 min · BST rule: left subtree smaller, right subtree larger, at every node.
22
Heaps
12 min · Min-heap: every parent is no larger than its children; the minimum is at the root.
23
Where Trees Show Up
10 min · File systems, HTML pages and syntax trees are trees.
★
Project: Search suggestionsHands-on project
35 min · 3 steps, checked as you go

6. Hashing and graphs

Use hash tables for fast lookups and walk graphs with BFS and DFS.

24
Hash Tables
12 min · A hash function turns a key into a number that picks a slot.
25
Collisions
10 min · A collision is two keys hashing to the same slot; it is unavoidable.
26
Graphs as Lists and Grids
12 min · A graph has vertices joined by edges; edges can be directed and weighted.
27
BFS and DFS
12 min · BFS explores in rings with a queue; it finds fewest-edge shortest paths.
★
Project: Metro route plannerHands-on project
35 min · 3 steps, checked as you go
★
Capstone: Campus delivery dispatcherHands-on project
60 min · 5 steps, checked as you go

Written by Vikosha. Lessons, questions and exercises are original. Further-reading links point to the Python documentation (docs.python.org) and to Open Data Structures by Pat Morin (opendatastructures.org, CC BY). Licence: Original Vikosha course. Further-reading links go to the official Python documentation and Open Data Structures (CC BY)..