Analysis of Algorithms

Size: px

Start display at page:

Download "Analysis of Algorithms"

Dinah Green
6 years ago
Views:

1 Lab Manual Analysis of Algorithms S.E. Computer Sem IV

2 Index Table S r. N o. Tit le of Pr ogr amm ing Assignm ents 1. Recursive Binar y Sear ch 2. Recursive Mer ge Sort 3. Heap Sort 4. Random ized Q uick Sor t 5. Min M ax 6. Knapsack using gr eedy appr oach 7. P r i m s A l g o r i t h m 8. Dijkstra s Algorithm 9. Knapsack using dynam ic pr ogr am ming 10. Floyd War shall Algor ithm 1 1. Bellman-Ford Algorithm 12. nq ueens Problem 13. Graph Coloring 14. Opt im al Binary Search Tree 15. KM P patt er n m atching Algort hm

3 Experiment No. 1 Title Objective Algorithm Searching Method To study and Implement Binary search Algorithm binary_search(array,value) { first=0 last=array.size 1 while (first <= last) mid = (first + last) / 2 if (value > array[mid]) first = mid + 1 else if (value < array[mid]) last = mid - 1 else return true return false } Post Lab Assignment 1. An array contains the elements shown below. Using all search methods trace the number 20. At each loop iteration show the intermediate values 2. Formulate the analysis of sequential search and binary search.

4 Experiment No. 2 Title: Merge Sort Merge Sort Approach Divide Divide the n-element sequence to be sorted into two subsequences of n/2 elements each Conquer Sort the subsequences recursively using merge sort When the size of the sequences is 1 there is nothing more to do Combine Merge the two sorted subsequences Algorithm : Algorithm MERGE-S O R T (A, p, r) { if p < r then q (p + r)/2 MERGE-S O R T (A, p, q) MERGE-S O R T (A, q + 1, r) MERGE(A, p, q, r) } Algorithm MERGE(A, p, q, r) { //Check for base case //Divide //Conquer //Conquer //Combine //Compute n1 and n2 Copy the first n1 elements into L[1.. n1 + 1] and the next n2 elements into R[1.. n2 + 1] L[n1 + 1] ; R[n2 + 1]

5 i 1; j 1 for k p to r do if L[ i ] R[ j ] then A[k] L[ i ] i i + 1 else A[k] R[ j ] j j + 1 }// End of Algorithm Post Lab Assignment 1. What is the worst-case runtime of merge sort? Show the results of merge sort on the following list of numbers after the recursive calls, but before the merge:

6 Title: Heap Sort Experiment No. 3 Algorithm: function heapsort(a, count) is input: an unordered array a of length count (first place a in max-heap order) heapify(a, count) end := count-1 //in languages with zero-based arrays the children are 2*i+1 and 2*i+2 while end > 0 do (swap the root(maximum value) of the heap with the last element of the heap) swap(a[end], a[0]) (decrease the size of the heap by one so that the previous max value will stay in its proper placement) end := end - 1 (put the heap back in max-heap order) siftdown(a, 0, end) function heapify(a, count) is (start is assigned the index in a of the last parent node) start := (count - 1) / 2 while start 0 do (sift down the node at index start to the proper place such that all nodes below the start index are in heap order) siftdown(a, start, count-1) start := start - 1 (after sifting down the root all nodes/elements are in heap order) function siftdown(a, start, end) is input: end represents the limit of how far down the heap to sift. root := start while root * end do (While the root has at least one child) child := root * (root*2 + 1 points to the left child) swap := root (keeps track of child to swap with)

7 with) (check if root is smaller than left child) if a[swap] < a[child] swap := child (check if right child exists, and if it's bigger than what we're currently swapping if child+1 end and a[swap] < a[child+1] swap := child + 1 (check if we need to swap at all) if swap!= root swap(a[root], a[swap]) root := swap else return (repeat to continue sifting down the child now)

8 Title: Randomized Quick sort Experiment No. 4 Randomized Quick Sort In the randomized version of Quick sort we impose a distribution on input. This does not improve the worst-case running time independent of the input ordering. In this version we choose a random key for the pivot. Assume that procedure Random (a, b) returns a random integer in the range [a, b); there are b-a+1 integers in the range and procedure is equally likely to return one of them. The new partition procedure, simply implemented the swap before actually partitioning. Algorithm: RANDOMIZED_PARTITION (A, p, r) i RANDOM (p, r) Exchange A[p] A[i] return PARTITION (A, p, r) Now randomized quick sort call the above procedure in place of PARTITION RANDOMIZED_QUICKSORT (A, p, r) If p < r then q RANDOMIZED_PARTITION (A, p, r) RANDOMIZED_QUICKSORT (A, p, q) RANDOMIZED_QUICKSORT (A, q+1, r)

9 Experiment No. 5 Title: To find minimum and maximum using divide and conquer method. Algorithm and Theory; 1. Array a will be divided into two sub arrays of size n/2. 2. Compare larger of 1 st sub array with larger of 2 nd sub array, whichever is larger is the largest element of the array. 3. Do the same thing for the smallest number. 4. The procedure of dividing an array will continue till we get one or two elements in the array.

10 Title: Greedy Knapsack Experiment No. 6 Objective: To study and Implement Fractional Knapsack by using Greedy Method Algorithm: Greedy-fractional-knapsack (w, v, W) FOR i =1 to n do x[i] =0 weight = 0 while weight < W do i = best remaining item IF weight + w[i] W then x[i] = 1 weight = weight + w[i] else x[i] = (w - weight) / w[i] weight = W return x Post Lab Assignment 1. Analyze Greedy Knapsack 2. what are the strategies if Greedy method 3. Proof : Let the ratio v`/w` is maximal. This supposition implies that v`/w` v/w for any pair (v, w), so v`v / w > v for any (v, w). Now Suppose a solution does not contain the full w` weight of the best ratio. Then by replacing an amount of any other w with more w` will improve the value.

11 Experiment No. 7 Title: Write a program to demonstrate Prim s Algorithm Prim's algorithm is a greedy algorithm that finds a minimum spanning tree for a connected weighted undirected graph. This means it finds a subset of the edges that forms a tree that includes every vertex, where the total weight of all the edges in the tree is minimized. Prim's Algorithm Prim's algorithm is known to be a good algorithm to find a minimum spanning tree. Set i=0, S 0 = {u0>=s}, L(u0)=0, and L(v)=infinity for v < u0. If V = 1 then stop, otherwise go to step 2. For each v in V\Si, replace L(v) by min{l(v), dv}. If L(v) is replaced, put a label (L(v), ui) on v. Find a vertex v which minimizes {L(v): v in V\Si}, say ui+1. Let Si+1 = Si cup {ui+1}. Replace i by i+1. If i= V -1 then stop, otherwise go to step 2. The time required by Prim's algorithm is O( V ^2). It will be reduced to O( E log V ) if heap is used to keep {v in V\Si : L(v) < infinity}.

12 Experiment No. 8 Title: Write a program to demonstrate Dijkistra s Algorithm Dijkistra's algorithm The graph representing all the paths from one vertex to all the others must be a spanning tree - it must include all vertices. There will also be no cycles as a cycle would define more than one path from the selected vertex to at least one other vertex. For a graph,g = (V,E) where V is a set of vertices and E is a set of edges. The basic mode of operation is: 1. Initialise d and pi 2. Set S to empty, 3. While there are still vertices in V-S 4. Sort the vertices in V-S according to the current best estimate of their distance from the source, 5. Add u, the closest vertex in V-S, to S, 6. Relax all the vertices still in V-S connected to u

13 Experiment No. 9 Title: Write a program to demonstrate Knapsack using dynamic programming. Algorithm: 0/1 Knapsack DP-01K(v, w, n, W) { 1 for w = 0 to W 2 c[0,w] = 0 3 for i = 1 to n 4 c[i,0] = 0 5 for w = 1 to W 6 if w[i] <=w 7 then if v[i] + c[i-1,w-w[i]] 8 then c[i,w] = v[i] + c[i-1,w-w[i]] 9 else c[i,w] = c[i-1,w] }

14 Experiment No. 10 Title: Write a program to implement Shortest Path algorithm by using Floyd Warshall Algorithm. /* Assume a function edgecost(i,j) which returns the cost of the edge from i to j (infinity if there is none). Also assume that n is the number of vertices and edgecost(i,i) = 0 */ int path[][]; /* A 2-dimensional matrix. At each step in the algorithm, path[i][j] is the shortest path from i to j using intermediate vertices (1..k 1). Each path[i][j] is initialized to edgecost(i,j). */ procedure FloydWarshall () for k := 1 to n for i := 1 to n for j := 1 to n path[i][j] = min ( path[i][j], path[i][k]+path[k][j] );

15 Experiment No. 11 Title: Write a program to implement Shortest Path algorithm by using Bellman- Ford Algorithm. procedure BellmanFord(list vertices, list edges, vertex source) // This implementation takes in a graph, represented as lists of vertices // and edges, and modifies the vertices so that their distance and // predecessor attributes store the shortest paths. // Step 1: initialize graph for each vertex v in vertices: if v is source then v.distance := 0 else v.distance := infinity v.predecessor := null // Step 2: relax edges repeatedly for i from 1 to size(vertices)-1: for each edge uv in edges: // uv is the edge from u to v u := uv.source v := uv.destination if u.distance + uv.weight < v.distance: v.distance := u.distance + uv.weight v.predecessor := u // Step 3: check for negative-weight cycles for each edge uv in edges: u := uv.source v := uv.destination if u.distance + uv.weight < v.distance: error "Graph contains a negative-weight cycle"

16 Experiment No. 12 Title: Write a program to study and Implement N-Queue problem by using Backtracking method. Algorithm Nqueue(k,n) { /* Using Backtracking, this method prints all possible placements of nqueens on an nxn chess board so that they are non backtracking*/ for I:= 1 to n do { if( Place (k,i)) then { x[k] := I; if(k=n) then write(x[1..n]); else Nqueue(k+1,n); } } }

17 Experiment No. 13 Title: Write a program to implement graph coloring by using Backtracking method. Graph coloring: input : undirected graph G=(V,E) loop i<= no. of edges 1. set a color for node i 2. if color exists for any of the connected edges color=color+1 return color

18 Experiment No. 14 Title: Write a program to implement Optimal Binary Search Tree. Optimal binary search tree is a search tree where the average cost of looking up an item (the expected search cost) is minimized. We have the following procedure for determining R(i, j) and C(i, j) with 0 <= i <= j <= n: PROCEDURE COMPUTE_ROOT(n, p, q; R, C) begin for i = 0 to n do C (i, i) <- 0 W (i, i) <- q(i) for m = 0 to n do for i = 0 to (n m) do j <- i + m W (i, j) <- W (i, j 1) + p (j) + q (j) *find C (i, j) and R (i, j) which minimize the tree cost End The following function builds an optimal binary search tree FUNCTION CONSTRUCT(R, i, j) begin *build a new internal node N labeled (i, j) k <- R (i, j) if i = k then *build a new leaf node N labeled (i, i) else *N1 <- CONSTRUCT(R, i, k) *N1 is the left child of node N if k = (j 1) then *build a new leaf node N labeled (j, j) else *N2 <- CONSTRUCT(R, k + 1, j) *N2 is the right child of node N return N end

19 Experiment No. 15 Title: Write a program to implement Knuth Morris Pratt pattern matching algorithm. algorithm kmp_search: input: an array of characters, S (the text to be searched) an array of characters, W (the word sought) output: an integer (the zero-based position in S at which W is found) define variables: an integer, m 0 (the beginning of the current match in S) an integer, i 0 (the position of the current character in W) an array of integers, T (the table, computed elsewhere) while m+i is less than the length of S, do: if W[i] = S[m + i], if i equals the (length of W)-1, return m let i i + 1 otherwise, let m m + i - T[i], if T[i] is greater than -1, let i T[i] else let i 0 (if we reach here, we have searched all of S unsuccessfully) return the length of S

Department of Computer Science and Engineering Analysis and Design of Algorithm (CS-4004) Subject Notes

Page no: Department of Computer Science and Engineering Analysis and Design of Algorithm (CS-00) Subject Notes Unit- Greedy Technique. Introduction: Greedy is the most straight forward design technique.