What does this Data Structures & Algorithms cheat sheet cover?

It has 10 sections: Complexity, Arrays, Lists, Stack Queue Hash, BST, Heaps, Graphs, Shortest Paths, Sorting and DP Recursion. Together they cover the topics a typical Data Structures & Algorithms exam tests, including Big-O analysis, arrays and linked lists, stacks and queues and hash tables.

Is the data structures cheat sheet free?

The first part is free to read on this page, with no account needed. The full sheet opens in the app with Unlimited ($4.99 a month or $19 for a semester), where you can edit it, print it or save it as a PDF. It is one US Letter page and prints cleanly in black and white or colour.

Can I bring this Data Structures & Algorithms cheat sheet to my exam?

Only if your course allows a note sheet, so check the syllabus. This one is a single US Letter page. If your exam allows a different size, such as a 3x5 or 4x6 index card or one page front and back, Cheat Sheet AI makes one at exactly that size from your own lecture notes.

The sheet was written by our engine from a standard course outline, then a second model fact-checked every formula and statement against it; it corrected 6 statements before publishing. Notation and emphasis vary between courses, so check it against your own lecture notes.

Can I make a Data Structures & Algorithms sheet from my own notes?

Yes. Upload your lecture slides, notes or study guide and Cheat Sheet AI writes a sheet in your course's notation, sized to exactly the space your exam allows. Your first sheets are free.

ComputingData Structures & Algorithms

Data Structures Cheat Sheet — 1-page PDF

Exam cheat sheet: asymptotic analysis, core DS, graph/shortest-path algs, sorting, DP, recursion. The whole course on one dense, printable page for your midterm or final, with every formula typeset and worked examples where they help.

Make this from your notes Unlock the full sheet

The first part is free below. See pricing →

For a specific exam: Data Structures & Algorithms Final exam study sheet.

1 pageUS Letter
10 sections11 topics
Free previewfull sheet with Unlimited

Preview of the one-page Data Structures & Algorithms cheat sheet: Exam cheat sheet: asymptotic analysis, core DS, graph/shortest-path algs, sorting, DP, recursion — the whole course, one page

On the sheet

What’s on it

The topics a typical Data Structures & Algorithms exam tests, all on the one page.

Big-O analysis
Arrays and linked lists
Stacks and queues
Hash tables
Binary search trees
Heaps and priority queues
Graphs: BFS, DFS
Dijkstra and shortest paths
Sorting algorithms comparison
Dynamic programming patterns
Recursion and master theorem

Free preview

The free part, as text

The free part of the sheet, section by section. Unlock the full sheet to read the rest, edit any block, and print it or save it as a PDF.

01Complexity

Asymptotic upper bound: $f (n) = O (g (n))$ iff $\exists c, n_{0} > 0$ s.t. $0 \leq f (n) \leq c g (n)$ for all $n \geq n_{0}$ .
Lower / tight bound: $f (n) = Omega (g (n))$ iff $0 le cg (n) l e f (n)$ eventually; $f (n) = Theta (g (n))$ iff both $O$ and $Omega$ .

Common growth

1 ≪ lo g n ≪ n ≪ n lo g n ≪ n^{2} ≪ 2^{n} ≪ n!

Asymptotic ordering.

Rules: drop constants; keep dominant term; nested loops multiply; sequential code adds then take max; if/else worst-case = max branch cost.

Case	Meaning	Use
Best	minimum over inputs	rare on exams unless asked
Average	expected cost	need distribution
Worst	max over inputs	default unless stated
Amortized	avg over sequence	dynamic arrays, union-find style analyses

02Lists

Operation	Singly list	Doubly list
Insert/delete at head	$O (1)$	$O (1)$
Insert/delete at tail	$O (n)$ unless tail ptr	$O (1)$ with tail ptr
Search	$O (n)$	$O (n)$
Delete given node	$O (n)$ to find prev	$O (1)$ if node known

Ex.Delete node after pointer $p$ in singly list?

Set $p.next = p.next.next$ ; time $O (1)$ if $p$ known.

03Stack Queue Hash

Stack: LIFO; ops: $push$ , $pop$ , $top$ .
Queue: FIFO; ops: $enqueue$ , $dequeue$ , front.

DS	Key ops	Typical impl
Stack	push/pop/top	array or list
Queue	enqueue/dequeue	circular array or list
Deque	push/pop both ends	doubly linked list or circular array

Hash table: Map key $\to$ slot via hash function $h (k)$ ; average $O (1)$ insert/search/delete under good hashing and bounded load factor.

04Heaps

Binary heap: Complete binary tree with heap-order: max-heap parent $\geq$ children; min-heap parent $\leq$ children.

Array indices

parent (i) = ⌊(i - 1) /2 ⌋, left (i) = 2 i + 1, right (i) = 2 i + 2

0-based array representation.

Operation	Binary heap
peek min/max	$O (1)$
insert	$O (lo g n)$
extract min/max	$O (lo g n)$
build-heap	$O (n)$

Priority queue: Abstract ADT supporting insert and delete-extreme; commonly implemented with heap.

Watch out:Heap is not sorted; only root is extreme. In array heap, traversal order is not key order.

05Graphs

Graph: $G = (V, E)$ ; directed or undirected; weighted edges may have costs.
BFS: Level-order traversal from source using queue; finds shortest path in unweighted graphs by #edges.

06Sorting

Alg	Best	Avg	Worst	Stable	In-place
Bubble	$O (n)$ w/ early stop	$O (n^{2})$	$O (n^{2})$	yes	yes
Selection	$O (n^{2})$	$O (n^{2})$	$O (n^{2})$	no	yes
Insertion	$O (n)$	$O (n^{2})$	$O (n^{2})$	yes	yes
Merge	$O (n lo g n)$	$O (n lo g n)$	$O (n lo g n)$	yes	no
Quick	$O (n lo g n)$	$O (n lo g n)$	$O (n^{2})$	no	yes
Heap	$O (n lo g n)$	$O (n lo g n)$	$O (n lo g n)$	no	yes

Stable: Equal keys keep relative order.
In-place: Uses $O (1)$ or $O (lo g n)$ extra space (course convention may vary).

Comparison sort lower bound: any comparison-based sort needs $Ω (n lo g n)$ in the worst case.

Ex.Need stable, guaranteed $O (n lo g n)$ ?

Merge sort.

Cheat sheet locked

Also on the full Data Structures & Algorithms sheet

8 more sections, with every definition, formula and worked example. Unlimited unlocks every full sheet in the library to edit, print or save as a PDF, and makes unlimited sheets from your own notes.

Complexity

Amortized

Arrays

Array
Dynamic array
Doubling

Lists

Singly linked list
Doubly linked list

Stack Queue Hash

Load factor

BST

Binary search tree
BST search

Graphs

Shortest Paths

Dijkstra
Relaxation
Shortest path tree

DP Recursion

Dynamic programming
Recursion
Master theorem

Unlock the full sheet $4.99 a month or $19 a semester

Or make this from your own notes

FAQ

Questions

About the Data Structures & Algorithms sheet and making your own.

What does this Data Structures & Algorithms cheat sheet cover?: It has 10 sections: Complexity, Arrays, Lists, Stack Queue Hash, BST, Heaps, Graphs, Shortest Paths, Sorting and DP Recursion. Together they cover the topics a typical Data Structures & Algorithms exam tests, including Big-O analysis, arrays and linked lists, stacks and queues and hash tables.
Is the data structures cheat sheet free?: The first part is free to read on this page, with no account needed. The full sheet opens in the app with Unlimited ($4.99 a month or $19 for a semester), where you can edit it, print it or save it as a PDF. It is one US Letter page and prints cleanly in black and white or colour.
Can I bring this Data Structures & Algorithms cheat sheet to my exam?: Only if your course allows a note sheet, so check the syllabus. This one is a single US Letter page. If your exam allows a different size, such as a 3x5 or 4x6 index card or one page front and back, Cheat Sheet AI makes one at exactly that size from your own lecture notes.
How accurate is it?: The sheet was written by our engine from a standard course outline, then a second model fact-checked every formula and statement against it; it corrected 6 statements before publishing. Notation and emphasis vary between courses, so check it against your own lecture notes.
Can I make a Data Structures & Algorithms sheet from my own notes?: Yes. Upload your lecture slides, notes or study guide and Cheat Sheet AI writes a sheet in your course's notation, sized to exactly the space your exam allows. Your first sheets are free.

Keep going

All 40 sheets are in the sheet library.

Your course, your notes, one page.

Make this from your notes

Upload your own Data Structures & Algorithms slides or notes and get a study sheet in your course’s notation. Your first sheet needs no account, and a free account adds one more. See pricing