DESIGN & ANALYSIS OF

ALGORITHMS ASSIGNMENT
PANJAB UNIVERSITY
SSG-RC
INFORMATION TECHNOLOGY

SUBMITTED TO:
MR. GURPINDER SINGH

SUBMITTED BY:
Piyush Pathania
BE IT 5th SEM
SG-17814
 COMPARISON BETWEEN QUICK & MERGE SORT

BASIS FOR

COMPARISON QUICK SORT MERGE SORT

Worst case
complexity O(n2) O(nlogn)

It operates fine on any size of

Works well on It works well on smaller array array

It work faster than other sorting

algorithms for small data set It has a consistent speed on any

Speed of execution like Selection sort etc size of data

Additional storage
space requirement Less(In-place) More(not In-place)

Efficiency Inefficient for larger arrays More efficient

Sorting method Internal External

 BASIS FOR

COMPARISON QUICK SORT MERGE SORT

Stability Not Stable Stable

Preferred for for Arrays for Linked Lists

 BINARY SEARCH

 Binary search implements divide and conquer approach.

 The time complexity of binary search has O(log 2N).

 The best case time in binary search, it is for the middle element, i.e.,
O(1).

 worst case for searching an element is log2N number of comparison for

binary search.

 binary search can not be implemented directly on linked list.

 As we know Binary search requires the sorted array that is reason It

requires processing to insert at its proper place to maintain a sorted list.

 search algorithm is however tricky, and elements are necessarily arranged

in order.
 Dijkstra’s Algorithm

 Dijkstra’s Algorithm is one example of a single-source shortest or SSSP algorithm,

i.e., given a source vertex it finds shortest path from source to all other vertices.

 Time Complexity of Dijkstra’s Algorithm: O(E log V)

 We can use Dijkstra’s shortest path algorithm for finding all pair shortest paths by
running it for every vertex.

 time complexity of this would be O(VE Log V) which can go (V3 Log V) in worst case.

 Another important differentiating factor between the algorithms is their working

towards distributed systems. Unlike Dijkstra’s algorithm.

 Dijkstra’s algorithm don’t work for negative edges.

 It is greedy algorithm.
 Floyd Warshall

 Floyd Warshall Algorithm is an example of all-pairs shortest path algorithm, meaning

it computes the shortest path between all pair of nodes.

 Time Complexity of Floyd Warshall: O(V3)

 Lastly Floyd Warshall works for negative edge but no negative cycle.

 Floyd Warshall can be implemented in a distributed system, making it suitable for

data structures such as Graph of Graphs (Used in Maps).

 Kruskal’s Algorithms and Prim’s Algorithm
Factors Kruskal’s Algorithms
Steps in the  Select the shortest edge in a network
Algorithm  Select the next shortest edge which
does not create a cycle
 Repeat step 2 until all vertices have been
connected
 Kruskal’s Begins with forest and
merge into tree.
Algorithm  O(NlogN) comparison sort for edges.
Complexity
Analysis  Running Time= O(mlog n)
(m=edges,n=nodes)
 It usually only has to check a small
fraction of edges ,but in some cases (like
if there was a vertex connected to graph
by only one edge and it was the longest
edge) it would have to check all the
edges.
 This algorithm works best, of course
if the number of edges is kept to a
minimum.
Prim’s Algorithm
 Select any vertex
 Select the shortest edge
connected to that vertex
 Select the shortest edge
connected to any vertex already
connected
 Repeat step 3 until all vertices
have been connected
 Prim’s always stays as a tree.
 O(NlogN) search the least weight
edge for every vertices.
 Running Time = O(m+nlogn)
(m=edges, n=nodes)
 If a heap is not used, the run time
will be O(n^2) instead of O(m+n
log n).
 However, using a heap
complicates the code since we
are complicating the data
structure.
 Unlike Kruskal’s, it doesn’t need
to see all of the graph at once. It
can deal with it one piece at a
time. It also doesn’t need to
worry if adding an edge will
create a cycle since this
algorithm deals primarily with
the nodes, and not the edges.
Algorithm
// Returns the MST by Kruskal’s Algorithm // Returns the MST by Prim’s Algorithm
// Input: A weighted connected graph G = (V,E) // Input: A weighted connected
// Output: Set of edges comprising a MST graph G = (V,E)
sort the edges E by their weights // Output: Set of edges comprising a
ET ; MST
while |ET | + 1 < |V | do VT {any vertex in G}
e next edge in E ET ;
if Et [ {e} does not have a cycle then for i 1 to |V | − 1 do
ET ET [ {e} e minimum-weight edge (v, u)
return ET with v 2 VT and u 2 V − VT
VT VT [ {u}
ET ET [ {e}
return ET
 BELLMAN FORD

 Calculations for node n involves knowledge of link cost to all neighboring node plus

total cost to each neighbor.

 Each node can maintain a set of costs and path for every other node.

 Can exchange information from other neighbors.

 Can update cost and path based on.

 Worst case amount of computation to find shortage path lengths.

 Algo iterates up to n times.

 Each iteration is done for n-1 nodes.

 Minimization step requires considering up to n-1 alternatives.

 Complexity is O(n^3).
 Knapsack and Fractional Knapsack
Factors 0/1 Knapsack
 Given weights and values
About
of n items, put these items
in a knapsack of capacity
W to get the maximum
total value in the
knapsack.
 In other words, given two
integer arrays val[0..n-1]
and wt[0..n-1] which
represent values and
weights associated with n
items respectively.
Time  Time complexity of 0/1
Knapsack problem is
Complexity
O(nW)
Algorithm Knapsack (n, W)
1. for w = 0, W
2. do V [0,w] ← 0
3. for i=0, n
4. do V [i, 0] ← 0
Fractional Knapsack
 Fractions of items can be
taken rather than having
to make binary (0-1)
choices for each
item.Fractional Knapsack
Problem can be solvable
by greedy strategy
whereas 0 - 1 problem is
not.
 Compute the value
per pound Vi/Wi for
each item.
 Obeying a Greedy
Strategy, we take as
possible of the item with
the highest value per
pound.
 Fractional Knapsack
has time complexity
O(NlogN)
Fractional Knapsack (Array W
, Array V, int M)
1. for i <- 1 to size (V)
2. calculate cost[i] <- V[i]
/ W[i]
3. Sort-Descending (cost)
 5. for w = 0, W 4. i ← 1
6. do if (wi≤ w & vi + V [i-1, w 5. while (i <= size(V))
- wi]> V [i -1,W]) 6. if W[i] <= M
7. then V [i, W] ← vi + V [i - 1, 7. M ← M – W[i
w - wi] ]
8. else V [i, W] ← V [i - 1, w] 8. total ← total +
V[i];
9. if W[i] > M
10. i ← i+1