Big-O Algorithm Complexity Cheat Sheet

Big-O Complexity Chart

!Pasted image 20240921162031.png

Common Data Structure Operations

Data Structure	Time Complexity								Space Complexity
	Average				Worst				Worst
	Access	Search	Insertion	Deletion	Access	Search	Insertion	Deletion
Array	`Θ(1)`	`Θ(n)`	`Θ(n)`	`Θ(n)`	`O(1)`	`O(n)`	`O(n)`	`O(n)`	`O(n)`
Stack	`Θ(n)`	`Θ(n)`	`Θ(1)`	`Θ(1)`	`O(n)`	`O(n)`	`O(1)`	`O(1)`	`O(n)`
Queue	`Θ(n)`	`Θ(n)`	`Θ(1)`	`Θ(1)`	`O(n)`	`O(n)`	`O(1)`	`O(1)`	`O(n)`
Heap			`Θ(log(n))`	`Θ(log(n))`					`O(n)`
Singly-Linked List	`Θ(n)`	`Θ(n)`	`Θ(1)`	`Θ(1)`	`O(n)`	`O(n)`	`O(1)`	`O(1)`	`O(n)`
Doubly-Linked List	`Θ(n)`	`Θ(n)`	`Θ(1)`	`Θ(1)`	`O(n)`	`O(n)`	`O(1)`	`O(1)`	`O(n)`
Skip List	`Θ(log(n))`	`Θ(log(n))`	`Θ(log(n))`	`Θ(log(n))`	`O(n)`	`O(n)`	`O(n)`	`O(n)`	`O(n log(n))`
Hash Table	`N/A`	`Θ(1)`	`Θ(1)`	`Θ(1)`	`N/A`	`O(n)`	`O(n)`	`O(n)`	`O(n)`
Binary Search Tree	`Θ(log(n))`	`Θ(log(n))`	`Θ(log(n))`	`Θ(log(n))`	`O(n)`	`O(n)`	`O(n)`	`O(n)`	`O(n)`
Cartesian Tree	`N/A`	`Θ(log(n))`	`Θ(log(n))`	`Θ(log(n))`	`N/A`	`O(n)`	`O(n)`	`O(n)`	`O(n)`
B-Tree	`Θ(log(n))`	`Θ(log(n))`	`Θ(log(n))`	`Θ(log(n))`	`O(log(n))`	`O(log(n))`	`O(log(n))`	`O(log(n))`	`O(n)`
Red-Black Tree	`Θ(log(n))`	`Θ(log(n))`	`Θ(log(n))`	`Θ(log(n))`	`O(log(n))`	`O(log(n))`	`O(log(n))`	`O(log(n))`	`O(n)`
Splay Tree	`N/A`	`Θ(log(n))`	`Θ(log(n))`	`Θ(log(n))`	`N/A`	`O(log(n))`	`O(log(n))`	`O(log(n))`	`O(n)`
AVL Tree	`Θ(log(n))`	`Θ(log(n))`	`Θ(log(n))`	`Θ(log(n))`	`O(log(n))`	`O(log(n))`	`O(log(n))`	`O(log(n))`	`O(n)`
KD Tree	`Θ(log(n))`	`Θ(log(n))`	`Θ(log(n))`	`Θ(log(n))`	`O(n)`	`O(n)`	`O(n)`	`O(n)`	`O(n)`

Arrays

Sorting Algorithms for Arrays

Algorithm	Time Complexity			Space Complexity
	Best	Average	Worst	Worst
Quicksort	`Ω(n log(n))`	`Θ(n log(n))`	`O(n^2)`	`O(log(n))`
Mergesort	`Ω(n log(n))`	`Θ(n log(n))`	`O(n log(n))`	`O(n)`
Timsort	`Ω(n)`	`Θ(n log(n))`	`O(n log(n))`	`O(n)`
Heapsort	`Ω(n log(n))`	`Θ(n log(n))`	`O(n log(n))`	`O(1)`
Bubble Sort	`Ω(n)`	`Θ(n^2)`	`O(n^2)`	`O(1)`
Insertion Sort	`Ω(n)`	`Θ(n^2)`	`O(n^2)`	`O(1)`
Selection Sort	`Ω(n^2)`	`Θ(n^2)`	`O(n^2)`	`O(1)`
Tree Sort	`Ω(n log(n))`	`Θ(n log(n))`	`O(n^2)`	`O(n)`
Shell Sort	`Ω(n log(n))`	`Θ(n(log(n))^2)`	`O(n(log(n))^2)`	`O(1)`
Bucket Sort	`Ω(n+k)`	`Θ(n+k)`	`O(n^2)`	`O(n)`
Radix Sort	`Ω(nk)`	`Θ(nk)`	`O(nk)`	`O(n+k)`
Counting Sort	`Ω(n+k)`	`Θ(n+k)`	`O(n+k)`	`O(k)`
Cubesort	`Ω(n)`	`Θ(n log(n))`	`O(n log(n))`	`O(n)`

Best Sorting

Merge sort has best/average/worst case Time complexity $O (n * l o g * n)$ and $O (n)$ space
Quick sort has worst as $O (n^{2})$ but improves on space $O (l o g (n))$
Python uses Timsort:

Algorithm	Time Complexity			Space Complexity
	Best	Average	Worst	Worst
Timsort	`Ω(n)`	`Θ(n log(n))`	`O(n log(n))`	`O(n)`

Common patterns on Array

Two pointers: $O (n \cdot k)$ , where $k$ is the work done at each iteration, includes sliding window
Building a prefix sum: $O (n)$
- Finding the sum of a subarray given a prefix sum: $O (1)$

Strings

Immutable, therefore any changes done creates a new string

	Time Complexity
Insert	$O (n)$
Access	$O (1)$
Concatenation	$O (n + m)$
Substring	$O (m)$

Common patterns on Strings

Two pointers: $O (n \cdot k)$ , where $k$ is the work done at each iteration, includes sliding window
Building a string from joining an array is $O (n)$

Linked Lists

Common patterns on Linked Lists

Reverse between position i and j: $O (j - i)$
Detect a cycle: $O (n)$ using fast-slow pointers or hash map

Misc

Sorting: $O (n \cdot \log n)$ , where $n$ is the size of the data being sorted
DFS and BFS on a graph: $O (n \cdot k + e)$ , where $n$ is the number of nodes, $e$ is the number of edges, if each node is handled in $O (1)$ other than iterating over edges
DFS and BFS space complexity: typically $O (n)$ , but if it's in a graph, might be $O (n + e)$ to store the graph
Dynamic programming time complexity: $O (n \cdot k)$ , where $n$ is the number of states and $k$ is the work done at each state
Dynamic programming space complexity: $O (n)$ , where $n$ is the number of states