Ashish Jamuda CS 331 DATA STRUCTURES & ALGORITHMS COURSE FINAL EXAM

Transcription

1 Ashish Jamuda CS 331 DATA STRUCTURES & ALGORITHMS COURSE FINAL EXAM Question 1: Given a directed graph, design an algorithm to find out whether there is a route between two nodes. This problem can be solved by just simple graph traversal, such as depth first search or breadth first search. We start with one of the two nodes and, during traversal, check if the other node is found. We should mark any node found in the course of the algorithm as already visited to avoid cycles and repetition of the nodes. public enum State Unvisited, Visited, Visiting; public static boolean search(graph g, Node start, Node end) LinkedList<Node> q = new LinkedList<Node>(); // operates as Stack for (Node u : g.getnodes()) u.state = State.Unvisited; start.state = State.Visiting; q.add(start); Node u; while(!q.isempty()) u = q.removefirst(); // i.e., pop() if (u!= null) for (Node v : u.getadjacent()) if (v.state == State.Unvisited) if (v == end) return true; v.state = State.Visiting; q.add(v); u.state = State.Visited; return false; Question 2: Implement a Priority Queue. class PriorityQ

2 // array in sorted order, from max at 0 to min at size-1 private int maxsize; private long[] quearray; private int nitems; public PriorityQ(int s) // constructor maxsize = s; quearray = new long[maxsize]; nitems = 0; public void insert(long item) // insert item int j; if(nitems==0) // if no items, quearray[nitems++] = item; // insert at 0 // if items, for(j=nitems-1; j>=0; j--) // start at end, if( item > quearray[j] ) // if new item larger, quearray[j+1] = quearray[j]; // shift upward // if smaller, break; // done shifting // end for quearray[j+1] = item; // insert it nitems++; // end (nitems > 0) // end insert() public long remove() // remove minimum item return quearray[--nitems]; public long peekmin() // peek at minimum item return quearray[nitems-1]; public boolean isempty() // true if queue is empty return (nitems==0); public boolean isfull()

3 // true if queue is full return (nitems == maxsize); // end class PriorityQ class PriorityQApp public static void main(string[] args) throws IOException PriorityQ thepq = new PriorityQ(5); thepq.insert(30); thepq.insert(50); thepq.insert(10); thepq.insert(40); thepq.insert(20); while(!thepq.isempty() ) long item = thepq.remove(); System.out.print(item + ); // 10, 20, 30, 40, 50 // end while System.out.println( ); // end main() // end class PriorityQApp Question 3: Determine the running time of QuickSort for Sorted input reverse -ordered input random input When all the elements are equal This solution is being written with the assumption that middle element of the array is chosen as the pivot. The answers differ based on the pivot selection as well. a. Sorted Input In the case of sorted input,the left and right pointers of the sub arrays pass each other with out a single swap in all the iterations. The problem is divided in to 2 equal problems in all but the base case of unit size array. Hence the recurrence relation for this case is T(N)=2*T(N/2)+O(N).Hence the complexity in this case is O(NlogN). b. reverse ordered input This case is identical to the previous case except that we have so many swaps in each iteration. The left and right pointers swap the content on each increment in their directions. This effects only the O(N) part of the recurrence relation that we have in the previous case. But as the swap is of complexity O(1), the complexity of each iteration remains the same. And the division of the array is still even. So the complexity doesn't change. Hence it is still O(NlogN). c. Random Input

4 Well there are theorems asserting that the complexity of quicksort on a random input is O(NlogN).We will prove it by considering evenly the chances of even and worst splits. Let's consider that good and bad splits alternate in the iterations, with good splits in the best case (N/2) and bad ones in the worst (N-1). So every two levels, the array's been cut in half,which means, it's still exponential reduction -- O(NlogN ). d. When all the elements are equal It is as good as the sorted array. So the complexity is O(NlogN). Question 4: How can we rewrite the Insertion Sort algorithm so that it sorts numbers from highest to lowest? To modify the Insertion Sort Algorithm so that it sorts from highest to lowest, we need to swap the next unsorted card to the left until we reach a smaller card. The modifications to the original algorithm are marked in italics, notice we must simply redefine "correct sorted position". Insertion Sort Algorithm (sorting highest to lowest) 1. Get a list of unsorted numbers 2. Set a marker for the sorted section after the first number in the list 3. Repeat steps 4 through 6 until the unsorted section is empty 4. Select the first unsorted number 5. Swap this number to the left until it arrives in the correct sorted position. (i.e. until the next number to the left is smaller or it has reached the head of the list.) 6. Advance the marker to the right one position 7. Stop Question 5: For 2 sorted arrays one with size X and another with size X+Y which has only Y elements. merge these arrays in to second array such that resultant array at end will be sorted. public class MergeApp /** args */ public static void main(string[] args) // TODO Auto-generated method stub int arraya[] = 23,47,81,95; int arrayb[] = 7,14,39,55,62,74; int arrayc[] = new int[10]; Merge(arrayA,4,arrayB,6,arrayC); Display(arrayC,10);

5 public static void Merge(int [] arraya, int sizea, int [] arrayb, int sizeb, int [] arrayc) int a = 0, b = 0, c = 0; while(a<sizea && b<sizeb) if(arraya[a] < arrayb[b]) arrayc[c++] = arraya[a++]; arrayc[c++] = arrayb[b++]; while(a < sizea) arrayc[c++] = arraya[a++]; while(b < sizeb) arrayc[c++] = arrayb[b++]; public static void Display(int[]arrayC, int sizec) for(int i = 0 ; i < sizec; ++i) System.out.println(arrayC[i]);