Scribd
Upload
1K views2 pages

Space & Time Complexity Chart

The document compares the time and space complexity of various algorithms. It provides the complexities for operations like addition in an ordered list, linear search, binary search, insertion sort, merge sort, quick sort, bucket sort, Euclid's algorithm, hashing, ordered dictionaries, AVL trees, balanced binary search trees, heaps, tree traversals, knapsack problem, depth first search, Dijkstra's algorithm, all pairs shortest path, and minimum spanning tree algorithms like Kruskal and Prim's. For most algorithms, it specifies the best, worst and average time complexities.

Uploaded by

manan00
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
1K views2 pages

Space & Time Complexity Chart

The document compares the time and space complexity of various algorithms. It provides the complexities for operations like addition in an ordered list, linear search, binary search, insertion sort, merge sort, quick sort, bucket sort, Euclid's algorithm, hashing, ordered dictionaries, AVL trees, balanced binary search trees, heaps, tree traversals, knapsack problem, depth first search, Dijkstra's algorithm, all pairs shortest path, and minimum spanning tree algorithms like Kruskal and Prim's. For most algorithms, it specifies the best, worst and average time complexities.

Uploaded by

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

Particular Space Complexity Time Complexity

Addition in ordered list


O(log N) to find the position
O(1)
O(N) for elements shifting
Total O(log N) + O(N)
Linear Search O(1)
Best Case :- O(1)
Worst Case :- O(N)
Average Case :- O(N)
Binary Search O(1)
Best Case :- O(log (N))
Worst Case :-
Average Case :- O(logN)
Insertion Sort
O(1)
Worst Case :- O(N*N)
Note:- Insertion Sort is
online & requires
Random Access Average Case :- O(N*N)
Merge Sort
O(N) for both Worst &
Average case
Worst Case :- O(N*logN)
Note:- Merge Sort is
not full online &
doesnot requires
Random Access Average Case :- O(N*logN)
Quick Sort O(N)
Best Case :- O(1)
Worst Case :- O(1)
Average Case :- O(N*logN)
Bucket or Bin Sort
where K is the range
size and N is number of
elements O(K) O(N)
Euclid Algorithm O(log(x)) due to call stack O(log(x))
Hashing-Chaining
Algorithm
O(1+a) where a is load factor
which is n/m. Where n is
number of elements and m is
size of table. And O(n) for
worst case
Ordered Dictionary
is equals to height of tree
Height of empty tree is 0
Height of non empty tree is 1 +
max(height(left),height(right))
Height of Balanced tree is logN
Height of Unbalanced tree is N
Height of AVL tree is O(logN)
AVL Tree
O(h) where h is height which is
logN, so O(LogN)
Balanced BST O(N)
O(logN) for worst & average
case
Hashtable O(N)
O(1) for avg case and O(N) for
worst case
Heap (min heapify)

ceil(log N)
Heap (build heap) <=2N
HeapSort
O(N) for build heap + N*O(log
N) so O(N log N) total for worst
case
Depth First Tree
Traversal Height of tree O(N)
Breadth First Tree
Traversal
Max number of nodes in
two consecutive levels O(N)
Knapsack Greedy
Algorithm
O(n*log n) for ordering + O(log
n) for while loop + O(n) for
finding minimum & assigimg to
remaining weight. Hence total
is O(n*log n)
Depth First Search
O(V) where V is the visted
vertices
O(d(V)) is the time per vertex
and Sum of all vertices visted is
the total time
Dijkastra Algorithm
O(n*log n) for intializing queue
and 1 + deg (u) *log n for while
loop. Hence total is O(m*log n)
All pairs shortest path
algorithm
O(n*(m+n)*log n) & for dense
graph O(n cube *log n)
Minimum Spanning
Tree (Kruskal
Algorithm)
O(m*logm+L(m,n)) where
L(m,n) is the cost of all cluster
operations and cluster means
unordered link list of vertices
Minimum Spanning
Tree (Prim`s Jarnik
Algorithm) O((m+n)*log n)

You might also like