Scribd
Upload
11 views

ADA Algorithms

Uploaded by

arugunta.cs22
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
11 views

ADA Algorithms

Uploaded by

arugunta.cs22
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 6

1.

Topological Sort by Source Removal:

ALGORITHM TopologicalSortUsingSourceRemoval(n, a[0..n-1][0..n-1])


//Performs topological sort using source removal method
//Input: Integer n (number of vertices), adjacency matrix a[0..n-1][0..n-1]
//Output: Array soln[0..n-1] containing topologically sorted vertices

//Calculate in-degrees of all vertices


for j ← 0 to n-1 do
sum ← 0
for i ← 0 to n-1 do
sum ← sum + a[i][j]
indegree[j] ← sum

//Initialize stack with vertices of in-degree 0


top ← -1
for i ← 0 to n-1 do
if indegree[i] = 0 then
top ← top + 1
s[top] ← i

//Perform topological sort


si ← 0
while top ≠ -1 do
u ← s[top]
top ← top - 1
soln[si] ← u
si ← si + 1
for i ← 0 to n-1 do
if a[u][i] = 1 then
indegree[i] ← indegree[i] - 1
if indegree[i] = 0 then
top ← top + 1
s[top] ← i

//Output sorted array soln

2. Topological Sort by DFS:

ALGORITHM TopologicalSortUsingDFS(n, a[0..n-1][0..n-1])


//Performs topological sort using DFS method
//Input: Integer n (number of vertices), adjacency matrix a[0..n-1][0..n-1]
//Output: Array res[0..n-1] containing topologically sorted vertices

//Initialize visited array and result array


for i ← 0 to n-1 do
vis[i] ← 0
j←0
//Perform DFS on unvisited nodes
for i ← 0 to n-1 do
if vis[i] = 0 then
dfs(i, n, a)

//DFS traversal to visit nodes and record topological order


procedure dfs(u, n, a[0..n-1][0..n-1])
vis[u] ← 1
for i ← 0 to n-1 do
if a[u][i] = 1 and vis[i] = 0 then
dfs(i, n, a)
res[j] ← u
j←j+1

//Output the result in reverse order


for i ← n-1 down to 0 do
print res[i]

3. Merge Sort:

ALGORITHM Mergesort(A[0..n−1])
//Sorts array A[0..n − 1]by recursive mergesort
//Input: An array A[0..n − 1]of orderable elements
//Output: Array A[0..n − 1]sorted in nondecreasing order
if n>1
copy A[0.. n/2 −1]to B[0.. n/2 −1]
copy A[ n/2 ..n−1]to C[0.. n/2 −1]
Mergesort(B[0.. n/2 −1])
Mergesort(C[0.. n/2 −1])
Merge(B, C, A) //see below

ALGORITHM Merge(B[0..p −1],C[0..q −1],A[0..p +q −1])


//Merges two sorted arrays into one sorted array
//Input: Arrays B[0..p − 1]and C[0..q − 1]both sorted
//Output: Sorted array A[0..p + q − 1]of the elements of B and C
i ←0; j ←0; k←0
while i<p and j<q do
if B[i]≤ C[j]
A[k]←B[i]; i ←i +1
else
A[k]←C[j]; j ←j +1
k ←k+1
if i =p
copy C[j..q − 1]to A[k..p + q −1]
else
copy B[i..p − 1]to A[k..p + q −1]

4. Quick Sort:
ALGORITHM Quicksort(A[l..r])
//Sorts a subarray by quicksort
//Input: Subarray of array A[0..n − 1], defined by its left and right indices l and r
//Output: Subarray A[l..r] sorted in nondecreasing order
if l < r
s ← Partition(A[l..r]) // s is a split position
Quicksort(A[l..s − 1])
Quicksort(A[s + 1..r])

ALGORITHM HoarePartition(A[l..r])
//Partitions a subarray by Hoare’s algorithm, using the first element as a pivot
//Input: Subarray of array A[0..n − 1], defined by its left and right indices l and r (l < r)
//Output: Partition of A[l..r], with the split position returned as this function’s value
p ← A[l]
i ← l; j ← r + 1
repeat
repeat i ← i + 1 until A[i] ≥ p
repeat j ← j - 1 until A[j] ≤ p
swap(A[i], A[j])
until i ≥ j
swap(A[i], A[j]) //undo last swap when i ≥ j
swap(A[l], A[j])
return j

5. Heap Sort:

ALGORITHM heapBottomUp(H[1..n])
// Constructs a heap from elements of a given array by the bottom-up algorithm
// Input: An array H[1..n] of orderable items
// Output: A heap H[1..n]

for i ← n/2 downto 1 do


k ← i; v ← H[k]
heapMade ← 0

while not heapMade and 2 * k ≤ n do


j←2*k

if j < n then
if H[j] < H[j + 1] then
j←j+1

if v ≥ H[j] then
heapMade ← 1
else
H[k] ← H[j]
k←j
H[k] ← v

ALGORITHM heapSort(H[1..n])
// Sorts an array using heap sort
// Input: An array H[1..n] of orderable items
// Output: Array H[1..n] sorted in non-decreasing order

heapBottomUp(H, n)

for i ← n downto 2 do
swap(H[1], H[i])
n←n-1
heapBottomUp(H, n)

6. 0-1 Knapsack Problem:

ALGORITHM Knapsack(W, wt[], val[], n)


// Solves the 0/1 Knapsack problem using dynamic programming
// Input:
// W: Maximum weight capacity of the knapsack
// wt[1..n]: Array of weights of items
// val[1..n]: Array of values of items
// n: Number of items
// Output:
// Maximum value that can be obtained without exceeding the weight capacity W

1. Initialize a 2D array K[n+1][W+1] with zeros.


2. for i ← 1 to n do
3. for w ← 1 to W do
4. if wt[i] > w
5. K[i][w] ← K[i-1][w]
6. else
7. K[i][w] ← max(val[i] + K[i-1][w-wt[i]], K[i-1][w])
8. return K[n][W]

7. Floyd's Algorithm for All pairs Shortest Path:

ALGORITHM Floyd(W[1..n,1..n])
// Implements Floyd’s algorithm for the all-pairs shortest-paths problem
// Input: The weight matrix W of a graph with no negative-length cycle
// Output: The distance matrix of the shortest paths’ lengths

D ← W // Make a copy of the weight matrix W (if necessary)


for k ← 1 to n do
for i ← 1 to n do
for j ← 1 to n do
D[i, j] ← min(D[i, j], D[i, k] + D[k, j])
return D
8. Prims for MST:

ALGORITHM Prim(G)
// Prim’s algorithm for constructing a minimum spanning tree
// Input: A weighted connected graph G = (V, E)
// Output: ET, the set of edges composing a minimum spanning tree of G

VT ← {v0} // Initialize the set of tree vertices with any vertex (here v0)
ET ← ∅ // Initialize the set of edges in the minimum spanning tree as empty
for i ← 1 to |V| - 1 do
Find a minimum-weight edge e* = (v*, u*) among all edges (v, u) such that v is in VT and u is in V - VT
VT ← VT ∪ {u*}
ET ← ET ∪ {e*}
return ET

9. Fractional Knapsack:

ALGORITHM FractionalKnapsack(W, v, n, C)
// Solves the Fractional Knapsack problem using greedy method
// Input: Array W of item weights, array v of item values, number of items n, and knapsack capacity C
// Output: Maximum value that can be obtained

1. Compute the value-to-weight ratio v[i] / W[i] for each item i


2. Sort items based on the value-to-weight ratio in non-increasing order
3. Initialize current weight W_curr = 0 and current value V_curr = 0
4. for i ← 1 to n do
5. if W_curr + W[i] <= C then
6. W_curr ← W_curr + W[i]
7. V_curr ← V_curr + v[i]
8. else
9. fraction ← (C - W_curr) / W[i]
10. V_curr ← V_curr + v[i] * fraction
11. break
12. return V_curr

10. Dijkastra for MST:

ALGORITHM Dijkstra(G, src)


// Dijkstra’s algorithm for single-source shortest paths and its vertex src
// Input: A weighted connected graph G = (V, E) with non-negative weights
// Output: Shortest path distances dist[] from src to each vertex and their paths

Initialize dist[], parent[], and visited[] arrays


dist[src] = 0, parent[src] = -1
for each vertex v in V
if v ≠ src
dist[v] = INT_MAX, parent[v] = -1
visited[v] = 0

for count from 0 to |V|-1


u = vertex with minimum dist[] value, not yet visited
Mark u as visited
Update dist[] values of adjacent vertices v of u
if v is not visited and there is an edge from u to v and
dist[u] + weight(u, v) < dist[v]
dist[v] = dist[u] + weight(u, v)
parent[v] = u

Print shortest path distances and paths from src to each vertex

You might also like