You are on page 1of 2

Particular Space Complexity Time Complexity

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)
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