Final Examination. Algorithms & Data Structures II ( )

Transcription

1 Final Examination Algorithms & Data Structures II ( ) 1. (12%) What is the running time of the following algorithms? Assume the number of elements is N in Questions a-c, and the graph in Question d has E edges and V vertices. a. Worst case of Insert (one element) for a binary heap. b. Average case of quick sort. c. Best case of insertion sort. d. Worst case of Dijkstra shortest path algorithm. a. O(logN) b. O(NlogN) c. O(N) d. O( E + V 2 ) or O( E + V log V ) or O( V 2 ). 2. (13%) Calculate the worst case for an AVL tree that has N elements. You may want to use the following formula for Fibonacci numbers, ( Fib(n) 1 1+ ) n We look from another angle: given a height h, we investigate when the AVL tree has the minimal number of nodes? Let the AVL tree of height h that has minimal number of nodes be S h. The two subtrees of S h are subsequently S h 1 and S h 2. Therefore S h = S h 1 + S h 2 +1 S 0 = 1 and S 1 = 2 S h +1 = S h S h 2 +1 S 0 +1 = 2 and S 1 +1 = 3 S 0 +1 = Fib(3), S 1 +1 = Fib(4) Therefore, S h +1 = Fib(h+3) for h 1. By induction, S h+1 +1= S h +1+ S h 1 +1 = Fib(h+3)+Fib(h+2) = Fib(h+4) By using the formula for Fibonacci numbers, ( S h ) h+3

2 It follows h 1.44log S h. 3. (13%) Calculate the worst running time for quick sort. The running time of quicksort is equal to the running time of the two recursive calls plus the linear time spent in the partition. T(N) = T( S 1 )+T( S 2 )+cn where S 1 + S 2 = N 1. The equation gives the worst function when S 1 = 0 or S 2 = 0, namely, when the pivot is the smallest or the largest. The equation becomes (because T(0) = c ) T(N) = T(N 1)+cN Therefore Adding up, T(N 1) = T(N 2)+c(N 1) T(N 2) = T(N 3)+c(N 2)... T(2) = T(1)+2c T(N) = T(1)+c(2+ +(N 1)+N) = O(N 2 ) 4. (12%) Write code of DeleteMin(H) for a binary heap H. ElementType DeleteMin( PriorityQueue H ) int i, Child; ElementType MinElement, LastElement; if( IsEmpty( H ) ) Error( "Priority queue is empty" ); return H->Elements[ 0 ]; MinElement = H->Elements[ 1 ]; LastElement = H->Elements[ H->Size-- ]; for( i = 1; i * 2 <= H->Size; i = Child ) /* Find smaller child */ Child = i * 2; if( Child!= H->Size && H->Elements[ Child + 1 ] < H->Elements[ Child ] ) Child++;

3 /* Percolate one level */ if( LastElement > H->Elements[ Child ] ) H->Elements[ i ] = H->Elements[ Child ]; H->Elements[ i ] = LastElement; return MinElement; 5. (15%) Suppose an array only has two elements, 0 and 1, write a program that rearranges the elements so that the 0s are before 1s. Do not use a sorting algorithm (hint this is a partition problem). void Partition01( ElementType A[ ], int N ) int i, j; i = 0; j = N - 1; while ( i<j ) while( (i<n) && (A[ i ]==0) ) i++; while( (j>0) && (A[ j ] ==1) ) j--; if( i < j ) Swap( &A[ i ], &A[ j ] ); 6. (15%)Wrire code of mergesort for contiguous list (array implementation). void MSort( ElementType A[ ], ElementType TmpArray[ ], int Left, int Right ) int Center; if( Left < Right ) Center = ( Left + Right ) / 2; MSort( A, TmpArray, Left, Center ); MSort( A, TmpArray, Center + 1, Right ); Merge( A, TmpArray, Left, Center + 1, Right );

4 void Mergesort( ElementType A[ ], int N ) ElementType *TmpArray; TmpArray = malloc( N * sizeof( ElementType ) ); if( TmpArray!= NULL ) MSort( A, TmpArray, 0, N - 1 ); free( TmpArray ); FatalError( "No space for tmp array!!!" ); void Merge( ElementType A[ ], ElementType TmpArray[ ], int Lpos, int Rpos, int RightEnd ) int i, LeftEnd, NumElements, TmpPos; LeftEnd = Rpos - 1; TmpPos = Lpos; NumElements = RightEnd - Lpos + 1; /* main loop */ while( Lpos <= LeftEnd && Rpos <= RightEnd ) if( A[ Lpos ] <= A[ Rpos ] ) TmpArray[ TmpPos++ ] = A[ Lpos++ ]; TmpArray[ TmpPos++ ] = A[ Rpos++ ]; while( Lpos <= LeftEnd ) /* Copy rest of first half */ TmpArray[ TmpPos++ ] = A[ Lpos++ ]; while( Rpos <= RightEnd ) /* Copy rest of second half */ TmpArray[ TmpPos++ ] = A[ Rpos++ ]; /* Copy TmpArray back */ for( i = 0; i < NumElements; i++, RightEnd-- ) A[ RightEnd ] = TmpArray[ RightEnd ]; 7. (20%) (a). Write code for Dijkstra shortest path algorithm. (b). Modify Dijkstra s algorithm so that not only the shortest paths are calculated, but also for a vertex, how many shortest paths to it. (For both (a) and (b), you can use pseudocode like that in the textbook. You need to express the algorithm clearly, and English can only be used if it can be easily implemented. You will not get any points if you only say e.g., calculate

5 the number of shortest path ). (a). void Dijkstra( Graph G ) Vertex V,W; for ( ; ; ) V=smallest unknown distance vertex; if ( V==NotAVertex ) G[V].Known=True; for each W adjacent to V if (! G[W].Known ) if ( G[v].Dist+Cost[V,W] < G[W].Dist ) G[W].Dist = G[v].Dist+Cost[V,W]; G[W].Path=V; (b). void Dijkstra1( Graph G ) Vertex V,W; for ( ; ; ) V=smallest unknown distance vertex; if ( V==NotAVertex ) G[V].Known=True; for each W adjacent to V if (! G[W].Known ) if ( G[v].Dist+Cost[V,W] < G[W].Dist ) G[W].Dist = G[v].Dist+Cost[V,W]; G[W].Count=G[V].Count; G[W].Path=V; if ( G[v].Dist+Cost[V,W] == G[W].Dist ) G[W].Count=G[W].Count+G[V].Count;