0% found this document useful (0 votes)
356 views

Know Thy Complexities!: Big-O Complexity Chart

The document provides a summary of big-O time complexities for common data structures and algorithms. It shows that operations on arrays and linked lists have linear time complexity O(n) on average. Search trees like binary search trees have logarithmic time complexity O(log n) for operations. Sorting algorithms like quicksort and mergesort have time complexity of O(n log n). Graph algorithms like Dijkstra's and Prim's algorithms have average time complexity of O(E log V) where E is edges and V is vertices.

Uploaded by

Yuvraj
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
356 views

Know Thy Complexities!: Big-O Complexity Chart

The document provides a summary of big-O time complexities for common data structures and algorithms. It shows that operations on arrays and linked lists have linear time complexity O(n) on average. Search trees like binary search trees have logarithmic time complexity O(log n) for operations. Sorting algorithms like quicksort and mergesort have time complexity of O(n log n). Graph algorithms like Dijkstra's and Prim's algorithms have average time complexity of O(E log V) where E is edges and V is vertices.

Uploaded by

Yuvraj
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 2

Know Thy Complexities!

www.bigocheatsheet.com

Big-O Complexity Chart


Excellent Good Fair Bad Horrible

O(n!) O(2^n)
O(n^2)

O(n log n)
Operations

O(n)

O(1), O(log n)

Elements

Common Data Structure Operations


Space
Data Structure Time Complexity
Complexity
Average Worst Worst
Access Search Insertion Deletion Access Search Insertion Deletion
Array O(1) O(n) O(n) O(n) O(1) O(n) O(n) O(n) O(n)

Stack O(n) O(n) O(1) O(1) O(n) O(n) O(1) O(1) O(n)

Queue O(n) O(n) O(1) O(1) O(n) O(n) O(1) O(1) O(n)

Singly-Linked List O(n) O(n) O(1) O(1) O(n) O(n) O(1) O(1) O(n)

Doubly-Linked List O(n) O(n) O(1) O(1) O(n) O(n) O(1) O(1) O(n)

Skip List O(log(n)) O(log(n)) O(log(n)) O(log(n)) O(n) O(n) O(n) O(n) O(n log(n))

Hash Table N/A O(1) O(1) O(1) N/A O(n) O(n) O(n) O(n)

Binary Search Tree O(log(n)) O(log(n)) O(log(n)) O(log(n)) O(n) O(n) O(n) O(n) O(n)

Cartesian Tree N/A O(log(n)) O(log(n)) O(log(n)) N/A O(n) O(n) O(n) O(n)

B-Tree O(log(n)) O(log(n)) O(log(n)) O(log(n)) O(log(n)) O(log(n)) O(log(n)) O(log(n)) O(n)

Red-Black Tree O(log(n)) O(log(n)) O(log(n)) O(log(n)) O(log(n)) O(log(n)) O(log(n)) O(log(n)) O(n)

Splay Tree N/A O(log(n)) O(log(n)) O(log(n)) N/A O(log(n)) O(log(n)) O(log(n)) O(n)

AVL Tree O(log(n)) O(log(n)) O(log(n)) O(log(n)) O(log(n)) O(log(n)) O(log(n)) O(log(n)) O(n)

KD Tree O(log(n)) O(log(n)) O(log(n)) O(log(n)) O(n) O(n) O(n) O(n) O(n)

Array Sorting Algorithms


Algorithm Time Complexity Space Complexity
Best Average Worst Worst
Quicksort O(n log(n)) O(n log(n)) O(n^2) O(log(n))

Mergesort O(n log(n)) O(n log(n)) O(n log(n)) O(n)

Timsort O(n) O(n log(n)) O(n log(n)) O(n)

Heapsort O(n log(n)) O(n log(n)) O(n log(n)) O(1)

Bubble Sort O(n) O(n^2) O(n^2) O(1)

Insertion Sort O(n) O(n^2) O(n^2) O(1)

Selection Sort O(n^2) O(n^2) O(n^2) O(1)

Tree Sort O(n log(n)) O(n log(n)) O(n^2) O(n)

Shell Sort
Shell Sort O(n log(n)) O(n(log(n))^2) O(n(log(n))^2) O(1)

Bucket Sort O(n+k) O(n+k) O(n^2) O(n)

Radix Sort O(nk) O(nk) O(nk) O(n+k)

Counting Sort O(n+k) O(n+k) O(n+k) O(k)

Cubesort O(n) O(n log(n)) O(n log(n)) O(n)

Graph Data Structure Operations


Data Structure Time Complexity
Storage Add Vertex Add Edge Remove Vertex Remove Edge Query
Adjacency list O(|V|+|E|) O(1) O(1) O(|V| + |E|) O(|E|) O(|V|)

Incidence list O(|V|+|E|) O(1) O(1) O(|E|) O(|E|) O(|E|)

Adjacency matrix O(|V|^2) O(|V|^2) O(1) O(|V|^2) O(1) O(1)

Incidence matrix O(|V| ⋅ |E|) O(|V| ⋅ |E|) O(|V| ⋅ |E|) O(|V| ⋅ |E|) O(|V| ⋅ |E|) O(|E|)

Heap Data Structure Operations


Data Structure Time Complexity
Find Max Extract Max Increase Key Insert Delete Merge
Binary Heap O(1) O(log(n)) O(log(n)) O(log(n)) O(log(n)) O(m+n)

Pairing Heap O(1) O(log(n)) O(log(n)) O(1) O(log(n)) O(1)

Binomial Heap O(1) O(log(n)) O(log(n)) O(1) O(log(n)) O(log(n))

Fibonacci Heap O(1) O(log(n)) O(1) O(1) O(log(n)) O(1)

Graph Algorithms
Algorithm Time Complexity Space Complexity
Average Worst Worst
Dijkstra's algorithm O(|E| log |V|) O(|V|^2) O(|V| + |E|)

A* search algorithm O(|E|) O(b^d) O(b^d)

Prim's algorithm O(|E| log |V|) O(|V|^2) O(|V| + |E|)

Bellman–Ford algorithm O(|E| ⋅ |V|) O(|E| ⋅ |V|) O(|V|)

Floyd-Warshall algorithm O(|V|^3) O(|V|^3) O(|V|^2)

Topological sort O(|V| + |E|) O(|V| + |E|) O(|V| + |E|)

You might also like