(b) Give as accurate (Big-Oh) an analysis as you can of the expected running time of each algorithm.

Transcription

1 Problem DS (b) (e) Suppose you need to generate a random permutation of the first N integers. For example, 4, 3,, 5, 2 and 3,, 4, 2, 5 are legal permutation, but 5, 4,, 2, is not, because one number is duplicated and another 3 is missing. This routine is often used in simulation of algorithms. We assume the existence of a random number generator, RandInt(i, j), which generates integers between i and j with equal probability. Here are three algorithms:. Fill the array A from A[0] to A[N ] as follows: To fill A[i], generate random numbers until you get one that is not already in A[0], A[],..., A[i ]. 2. Same as algorithm (), but keep an extra array called Used array. When a random number, Ran, is first put in the array A, set Used[Ran] =. This means that when filling A[i] with a random number, you can test in one step to see whether the random number has been used, instead of the (possibly) i steps in the first algorithm. 3. Fill the array such that A[i] = i +. Then for( i=; i<n; i++) Swap( &A[i], &A[RandInt(0,i)]); (b) Give as accurate (Big-Oh) an analysis as you can of the expected running time of each algorithm. (e) What is the worst-case running time of each algorithm? Solution. (b) We assume that the running time for each call of RandInt(i, j) takes a constant time. For the first algorithm, the time to decide if a random number to be placed in A[i] has not been used earlier is O(i) because it needs to compare the result of A[i] generated by random number and every place before A[i] (i.e., between A[0] and A[i ]). The expected number of random numbers that need to be tried is N/(N i) and the probability of success is (N i)/n. Thus the expected number of independent trials is N/(N i). The time bound is thus N i=0 i N N N i < i=0 N 2 N N i = N 2 i=0 N i = N 2 N j= j = O(N 2 log N). The second algorithm saves a factor of i for each random number, and thus reduces the time bound to O(N log N) on average. The third algorithm is clearly linear. (e) The worst-case running time of algorithms and 2 cannot be bounded because there is always a finite probability that the program will not terminate by some given time T. The worst-case running time of the third algorithm is linear because its running time does not depend on the sequence of random numbers.

2 Problem DS-02- Given an efficient algorithm to determine if there exists an integer i such that A i = i in an array of integers A < A 2 < A 3 < < A N. What is the running time of your algorithm? Solution. Due to the facts that all integers in the array are distinct and permute in increasing order, we first give the following observation. For any given i between and N, if we check A i and obtain A i > i, then we have the result that A j j for all j > i (e.g., suppose we have A 5 = 8, it implies that A 6 9, A 7 0, A 8,... etc.) Oppositely, if A i < i, by the similar reasoning we have A j j for all j < i. Therefore, we can design the algorithm by using the binary search technique. #include<math.h> #include<stdio.h> int find(int A[], int N) int lower=, upper=n, mid; while (lower <= upper) mid = (lower+upper)/2; if (A[mid]>mid) upper = mid-; if (A[mid]<mid) lower = mid+; return mid; return NOT_FOUND; The worest-case running time of the program is O(log 2 N).

3 Problem DS-02-3 (a) (b) (a) Write a program to determine if a positive integer, N, is prime. (b) In terms of N, what is the worst-case running time of your program? (You should be able to do this in O( N).) Solution. (a) #include<math.h> #include<stdio.h> void main() int N,j,f=0; printf("please input a positive integer N for testing prime."); scanf("%d",&n); for(j=2; j<=sqrt(n); j++) if (N%j == 0) f=; break; if (f == 0) printf("n is a prime") printf("n is not a prime") (b) The worest-case running time of the program is O( N).

4 Problem DS-02-3 (c) (d) (e) (a) Write a program to determine if a positive integer, N, is prime. (b) In terms of N, what is the worst-case running time of your program? (You should be able to do this in O( N).) (c) Let B equal the number of bits in the binary representation of N. What is the value of B? (d) In therms of B, what is the worst-case running time of your program? (e) Compare the running times to determine if a 20-bits number and a 40-bits number are prime. Solution. For (a) and (b), see DS-02-3 (a) (b). (c) Since B = log 2 (N + ), we have B = O(log 2 N). (d) Since N 2 B, we have N (2 B ) /2 < 2 B/2. Thus, the worst-case running time of the algorithm is O(2 B/2 ). (e) Suppose that a 20-bit number can be tested in time T = O(2 20/2 ) = O(2 0 ). Then, a 40-bit number would require about T = O(2 40/2 ) = O(2 20 ) = T 2 time.

5 Supplementary Problem 02-0 Show directly that T (N) = N 2 + 3N 3 = Θ(N 3 ). That is, use the definitions of O and Ω to show that T (N) is in both O(N 3 ) and Ω(N 3 ). Proof. For proving T (N) = Θ(h(N)), we need to show that both T (N) = O(h(N)) and T (N) = Ω(h(N)). Since T (N) = N 2 + 3N 3, we consider h(n) = N 3. By definition, we can find c = 3, c 2 = 4, and n 0 = such that c h(n) T (N) c 2 h(n) holds. We verify as follows: T (N) = N 2 + 3N 3 4N 3 = O(N 3 ) if N n 0 = and T (N) = N 2 + 3N 3 3N 3 = Ω(N 3 ) if N n 0 = Thus, T (N) = Θ(N 3 ).

6 Supplementary Problem Using the definitions of O and Ω, show that T (N) = 6N N = O(N 3 ) but T (N) = 6N N Ω(N 3 ). Proof. To show T (N) = 6N N = O(N 3 ), by definition, we can find c = and n 0 = 9 such that 6N N < N 3 if N n 0 = 9. Thus, T (N) = O(N 3 ). On the other hand, for proving T (N) Ω(g(N)), we need to show that for any given positive constant c, there exists an integer n 0 > 0 such that T (N) < c g(n) when N n 0. We now consider T (N) = 6N N and g(n) = N 3. Then, for any given constant c > 0, we choose n 0 as follows: 9/c, if 0 < c < n 0 = 9, if c. It is easy to verify that 6N N < c N 3 if N n 0 (e.g., if c = 9/0, then n 0 = 0. In this case, 6N N < 9 0 N 3 if N n 0 = 0). Thus, T (N) Ω(N 3 ).

7 Supplementary Problem Given an algorithm for the following problem. Given a set of n distinct positive integers, partition the set into two subsets, each of size n/2, such that the difference between the sums of the integers in the two subsets is minimized. Determine the time complexity of your algorithm. You may assume that n is a multiple of 2.

8 Problem DS Swap two adjacent elements by adjusting only the pointers (and not the data) using: (a) singly linked lists (b) doubly linked lists. Solution. (a) Suppose that BeforeP points to the node before the two adjacent nodes that are to be swapped. void SwapTwoAdjacentNodes_Single(Position BeforeP, List L) Position P, AfterP; P = BeforeP->Next; AfterP = P->Next; P->Next = AfterP->Next; BeforeP->Next = AfterP; AfterP->Next = P; (b) Suppose that the declaration of node for doubly linked list is as follows: struct Node ElementType Element; Position Prev; Position Next; The following procedure can be used to swap node pointed by P and the node after P. void SwapTwoAdjacentNodes_Double(Position P, List L) Position BeforeP, AftertP; BeforeP = P->Prev; AfterP = P->Next; P->Next = AftertP->Next; BeforeP->Next = AfterP; AfterP->Next = P; P->Next->Prev = P; P->Prev = AfterP; AfterP->Prev = BeforeP;

9 Problem DS-03-6 (b) (d) Suppose we have an array-based list A[0... N ] and we want to delete all duplicates. LastPosition is initially N, but get smaller as elements are deleted. Consider the pseudocode program fragment in the following figure. The procedure Delete deletes the element in position j and collapses the list. for(i=0; i<lastposition; i++) j = i+; while(j<lastposition) if (A[i] == A[j]) Delete(j); j++; (b) Rewrite this procedure using general list operations. (d) what is the running time using a linked list implementation? Solution. (b) Suppose that L is a linked list and the function IsLast(P, L) can be used to test whether the position P is in the end of L in a constant time (See Page 47 for definition). Let P, Q, PrevQ be variables with type Position. P = L->Next; while(!islast(p,l)) PrevQ = P; while(!islast(prevq,l)) Q = PrevQ->Next; if (P->Element == Q->Element) PrevQ->Next = Q->Next; free(q) PrevQ = Q; Q = Q->Next; (d) It is trivial that the running time is O(N 2 ).

10 Problem DS-03-6 (e) Suppose we have an array-based list A[0... N ] and we want to delete all duplicates. LastPosition is initially N, but get smaller as elements are deleted. Consider the pseudocode program fragment in the following figure. The procedure Delete deletes the element in position j and collapses the list. for(i=0; i<lastposition; i++) j = i+; while(j<lastposition) if (A[i] == A[j]) Delete(j); j++; (e) Give an algorithm to solve this problem in O(N log N) time. Solution. adjacent). Sort the list, and make a scan to remove duplicates (which must now be void swap( int &a, int &b ) int temp = a; a = b; b = temp; void Quick_Sort( int p[], int left, int right ) int divided,i,j; if( left < right ) divided = left; do for( i=left+; p[i]<p[divided] && i<=right; i++ ); for( j=right; p[j]>p[divided] && j>=left; j-- ); if( i<j ) swap(p[i],p[j]); while( i<j ); swap( p[divided], p[j] ); Quick_Sort( p, left, j- ); Quick_Sort( p, j+, right );

11 void Remove_Duplicate( const int A[], int N ) Quick_Sort(A[],0,N-); int last = 0; for( k=; k<n; k++ ) if( A[last]!= A[k] ) A[last+] = A[k]; last = k; 2

12 Problem DS-03-7 An alternative to the deletion strategy we have given is to use lazy deletion. To delete an element, we merely mark it deleted (using an extra bit field). The number of deleted and nondeleted elements in the list is kept as part of the data structure. If there are as many deleted elements as nondeleted elements, we traverse the entire list, performing the standard deletion algorithm on all marked nodes. (a) List the advantages and disadvantages of lazy deletion. (b) Write routines to implement the standard linked list operations using lazy deletion. Solution. (a) The advantages are that it is simpler to code, and there is a possible savings if deleted keys are subsequently reinserted (in the same place). The disadvantage is that it uses more space, because each node needs an extra bit (which is typically a byte), and unused nodes are not freed. (b) Let the structure of nodes be defined as follows: struct Node ElementType Element; Position Next; char Marked; // set to if deleted, and 0 otherwise To check the number of deleted elements and the number of nondeleted elements, we define the following two variable. Initially, both variables are set to be zero. int Total_Count = 0; // the total number of elements in the list int Deleted_Count = 0; // the total number of deleted elements The following are the relevant functions: Position Find(ElementType X, List L) Position P = L->Next; while ( P!= NULL && (P->Element!= X P->Marked) ) P = P->Next; return P; int IsLast(Position P, List L) return P->Next == NULL;

13 void Lazy_Deletion(ElementType X, List L) Position P; P = Find( X, L); if (P) P->Marked = ; Delete_Count++; if( Total_Count - Deleted_Count == Deleted_Count ) // the number of deleted elements is the same as the number // of nondeleted elements in the list Deletion(List L); void Deletion(List L) Position P, Provious, TmpCell; Provious = L; P = L->Next; while (!IsLast(P,L) ) if ( P->Marked ) TmpCell = P; P = P->Next; Previous->Next = P; free( TmpCell ); Total_Count--; Delete_Count--; Provious = P; P = P->Next; 2

14 Problem DS-03-8 (b) following languages: (b) C languages (/* */, ( ), [ ], ). Solution. F are valid. Write a program to check for balancing symbols in the For the input C language file F, we suppose that all symbols appeared in Also, the function Read Next Symbol(F ) can be used to read the next symbol from the current reading position of F, and the status of end of file for F can be checked by using the function EOF(F ). In addition, we suppose that the stack used in the following program is similar to that defined in page 68 of the textbook excepting that the data type ElementType is replaced with Symbol. int Check_Balance(File F) Stack S = CreateStack(); Symbol sym = Read_Next_Symbol(F); while (!EOF(F) ) switch(sym) case /* : case ( : case [ : case : Push(sym, S); break; case */ : if (Top(S)== /* ) Pop(S); return false; break; case ) : if (Top(S)== ( ) Pop(S); return false; break; case ] : if (Top(S)== [ ) Pop(S); return false; break; case : if (Top(S)== ( ) Pop(S); return false; break; sym = Read_Next_Symbol(F); if ( IsEmpty(S) ) return true; return false;

15 Problem DS (a) Propose a data structure that supports the stack Push and Pop operations and a third operation FindMin, which returns the smallest element in the data structure, all in O() worst case time. Solution. We suppose that the stack used in the program has structure similar to that defined in page 68 of the textbook. The idea is the use of the so-called extended stack. Let E be our extended stack. We will implement E with two stacks. One stack, which we ll call S, is used to keep track of the P ush and P op operations, and the other, M, keeps track of the minimum. To implement P ush(x, E), we perform P ush(x, S). If X is smaller than or equal to the top element in stack M, then we also perform P ush(x, M). To implement P op(e), we perform P op(s). If X is equal to the top element in stack M, then we also P op(m). F indmin(e) is performed by examining the top of M. All these operations are clearly O(). struct StackRecord int Capacity; int TopOfStack; ElementType *Array; typedef struct StackRecord *Stack; struct ExtendedRecord Stack S; Stack M; typedef struct ExtendedRecord *ExtendedStack int IsFull(Stack S) return S->TopOfStack == S->Capacity - ; int IsEmpty(Stack S) return S->TopOfStack == -;

16 ElementType Top(stack M) if (!IsEmpty(M) ) return M->Array[M->TopOfStack]; retuen MaxValue; // return a maximum integer to avoid warning void Push(ElementType X, ExtendedStack E) if ( IsFull(E->S) ) Error( "Full stack" ); E->S->Array[++E->S->TopOfStack] = X; if ( X <= Top(E->M) ) E->M->Array[++E->M->TopOfStack] = X; ElementType Pop(ExtendedStack E) ElementType temp; //Push(X,E) //Push(X,S) //Push(X,M) //Pop(E) if ( IsEmpty(E->S) ) Error( "Empty stack" ); temp = E->S->Array[E->S->TopOfStack]; E->S->TopOfStack--; if (Top(E->M) == temp) E->M->TopOfStack-- return temp; //Pop(S) //Pop(M) ElementType FindMin(ExtendedStack E) if ( IsEmpty(E->M) ) Error( "Empty stack" ); return Top(E->M); 2

17 Problem DS A deque is a data structure consisting of a list of items, on which the following operations are possible: Puch(X,D): Insert item X on the front end of deque D. Pop(D): Remove the front item from deque D and return it. Inject(X,D): Insert item X on the rear end of deque D. Eject(D): Remove the rear item from deque D and return it. Write routines to support the deque that take O() time per operation. Solution. We suppose that the informations about the deque are stored in the following record: struct DequeRecord int Capacity; int Front; int Rear; ElementType *Array; ; typedef struct DequeRecord *Deque; For convenience, we always assume that there exists sufficient memory to support the design of the structure. We first need the following relevant functions: Deque CreateDeque(int MaxElements) Deque D; D = malloc( sizeof( struct DequeRecord ) ); D->Array = malloc( sizeof( ElementType ) * MaxElements ); D->Capacity = MaxElements; D->Front = D->Capacity / 2; D->Rear = D->Capacity / 2 - ; return D; We now give the functions Push(X,D), Pop(D), Inject(X,D) and Eject(D) as follows: void Push(ElementType X, Deque D) if ( D->Front == 0 ) Error( "Full deque" ); D->Front--; D->Array[D->Front] = X;

18 ElementType Pop(Deque D) ElementType temp; if ( D->Rear < D->Front ) Error( "Empty deque" ); temp = D->array[D->Front]; D->Front++; return temp; void Inject(ElementType X, Deque D) if ( D->Rear == D->Capacity - ) Error( "Full deque" ); D->Rear++; D->Array[D->Rear] = X; ElementType Eject(Deque D) ElementType temp; if ( D->Rear < D->Front ) Error( "Empty deque" ); temp = D->array[D->Rear]; D->Rear--; return temp; 2

19 Problem DS Suppose a binary tree has leaves l, l 2,..., l M at depths d, d 2,..., d M, respectively. Prove that M i= s d i and determine when the equality is true. Proof. Before the proof, we first give an example to see the inequality M i= s d i. Consider a tree with five leaves (i.e., M = 5) shown below. depth 0 depth depth 2 l l 4 l 5 depth 3 l 3 depth 4 l 2 Then, d = depth(l ) = 2, d 2 = depth(l 2 ) = 4, d 3 = depth(l 3 ) = 3, d 4 = depth(l 4 ) = 2, and d 5 = depth(l 5 ) = 2. Thus, 5 i= 2 d i = = = 5 6 For any tree T with M leaves, we denote by F (T ) = M i= s d i where d i = depth(l i ) for each leaf l i in T. The proof is by induction on the number of nodes in a tree. Clearly, in a tree T with no nodes, we have F (T ) = 0, and in a one-node tree T, the root is a leaf at depth zero, so F (T ) = and the claim is true. Suppose the result is true for all trees with at most N nodes. Consider any tree T with N + nodes. Without loss of generality, we assume that such a tree consists of a left subtree T L with k node and a right subtree T R with N k node. By the inductive hypothesis, F (T L ) and F (T R ). Because all leaves are one deeper with respect to the original tree T than with respect to the subtrees T L or T R, F (T ) = 2 F (T L) + 2 F (T R), proving the result. The equality is true if and only if there are no nodes with one child. If there is a node with one child, the equality cannot be true because adding the second child would increase the sum to higher than. If no nodes have one child, then we can find and remove two sibling leaves, creating a new tree. It is easy to see that this new tree has the same sum as the old. Applying this step repeatedly, we arrive at a single node, whose sum is. Thus the original tree had sum.

20 Problem DS-04-2 Suppose you want to perform an experiment to verify the problem that can be caused by random Insert/Delete pairs. Here is a strategy that is not perfectly random, but close enough. You build a tree with N elements by inserting N elements chosen at random from the range to M = αn. You than perform N 2 pairs of insertions followed by deletions. Assume the existence of a routine, RandomInteger(A, B), which returns a uniform random integer between A and B inclusive. (a) Explain how to generate a random integer between and M that is not already in the tree (so a random inset can be performed). In term of N and α, what is the running time of this operation? (b) Explain how to generate a random integer between and M that is already in the tree (so a random delete can be performed). In term of N and α, what is the running time of this operation? (c) What is a good choice of α? Why? Solution. (a) Keep a bit array B. If i is in the tree, then B[i] is true; otherwise, it is false. Repeatedly generate random integers until an unused one is found. If there are N elements already in the tree, then M N are not, and the probability of finding one of these is (M N)/M. Thus the expected number of trials is M/(M N) = α/(α ). (b) To find an element that is in the tree, repeatedly generate random integers until an already-used integer is found. The probability of finding one is N/M, so the expected number of trials is M/N = α. (c) The total cost for one insert and one delete is α/(α )+α = +α+. Setting α α = 2 minimizes this cost.

21 Problem DS-04-2 (a) How many bits are required per node to store the height of a node in an N-node AVL tree? (b) What is the smallest AVL tree that overflows an 8-bit height counter? Solution. (a) The answer is log( log N + ) bits. From pages 0 of the textbook, it tell us that the height of an AVL tree is at most roughly.44 log(n + 2).328, but in practice it is only slightly more than log N. Thus, the height of an AVL tree with N nodes is at about log N. It is well-known that the largest unsigned integer represented by k bits is 2 k. Thus, if log N = 2 k then k = log( log N + ). So, it requires log( log N + ) bits of memory to store an integer (i.e., the height) with the value log N. (b) Let h be the height of the smallest AVL tree that uses a k-bits counter to store its height, where k 8. From (a), we know that h = log N and log( log N + ) = k 8. Thus, we obtain log(h + ) 8, and it implies h 2 8 = 255. So, the desired AVL tree is an AVL tree with height at least 255.

22 Problem DS Two trees, T and T 2, are isomorphic if T can be transformed into T 2 by swapping left and right children of (some of the) nodes in T. For instance, the two trees in the following figure are isomorphic because they are the same if the children of A, B, and G, but not the other nodes, are swapped. A A B C C B D E G G E D F H H F (a) Give a polynomial time algorithm to decide if two trees are isomorphic. (b) What is the running time of your program (there is a linear solution)? Solution. (a) #define TRUE #define FALSE 0 int Isomorphic(BinaryTree T, BinaryTree T2) if ( T == NULL && T2 == NULL ) return TRUE; if ( T == NULL && T2!= NULL ) return FALSE; if ( T!= NULL && T2 == NULL) return FALSE; if (T->Element!= T2->Element ) return FALSE; return (Isomorphic(T->Left,T2->Left) && Isomorphic(T->Right,T2->Right)) (Isomorphic(T->Left,T2->Right) && Isomorphic(T->Right,T2->Left)); (b) The function shown above is clearly a linear time routine because in the worst case it does a traversal on both T and T 2 at most twice.