Algorithm. Counting Sort Analysis of Algorithms

Transcription

1 Algorithm Coutig Sort Aalysis of Algorithms

2 Assumptios: records Coutig sort Each record cotais keys ad data All keys are i the rage of 1 to k Space The usorted list is stored i A, the sorted list will be stored i a additioal array B Uses a additioal array C of size k

3 Coutig sort Mai idea: 1. For each key value i, i = 1,,k, cout the umber of times the keys occurs i the usorted iput array A. Store results i a auxiliary array, C 2. Use these couts to compute the offset. Offset i is used to calculate the locatio where the record with key value i will be stored i the sorted output list B. The offset i value has the locatio where the last key i. Whe would you use coutig sort? How much memory is eeded?

4 Coutig Sort Iput: A [ 1.. ], A[J] {1,2,..., k } Output: B [ 1.. ], sorted Uses C [ 1.. k ], auxiliary storage Coutig-Sort( A, B, k) 1. for i 1 to k 2. do C[i ] 0 3. for j 1 to legth[a] 4. do C[A[ j ] ] C[A[ j ] ] for i 2 to k 6. do C[i ] C[i ] +C[i -1] 7. for j legth[a] dow 1 8. do B [ C[A[ j ] ] ] A[ j ] 9. C[A[ j ] ] ] C [A[ j ] ] -1

5 A k = 4, legth = 6 C after lies 1-2 C after lies 3-4 Coutig-Sort( A, B, k) 1. for i 1 to k 2. do C[i ] 0 3. for j 1 to legth[a] 4. do C[A[ j ] ] C[A[ j ] ] for i 2 to k 6. do C[i ] C[i ] +C[i -1] C after lies 5-6

6 A for j legth[a] dow 1 8. do B [ C[A[ j ] ] ] A[ j ] 9. C[A[ j ] ] ] C [A[ j ] ] -1 B <-1-> < > < > C

7 Algorithm Aalysis

8 The Executio Time of Algorithms Each operatio i a algorithm (or a program) has a cost. Each operatio takes a certai of time. cout = cout + 1; take a certai amout of time, but it is costat A sequece of operatios: cout = cout + 1; Cost: c 1 sum = sum + cout; Cost: c 2 Total Cost = c 1 + c 2

9 The Executio Time of Algorithms (cot.) Example: Simple If-Statemet Cost Times if ( < 0) c1 1 absval = - c2 1 else absval = ; c3 1 Total Cost <= c1 + max(c2,c3)

10 The Executio Time of Algorithms (cot.) Example: Simple Loop Cost Times i = 1; c1 1 sum = 0; c2 1 while (i <= ) { c3 +1 i = i + 1; c4 sum = sum + i; c5 } Total Cost = c1 + c2 + (+1)*c3 + *c4 + *c5 The time required for this algorithm is proportioal to

11 The Executio Time of Algorithms (cot.) Example: Nested Loop Cost Times i=1; c1 1 sum = 0; c2 1 while (i <= ) { c3 +1 j=1; c4 while (j <= ) { c5 *(+1) sum = sum + i; c6 * j = j + 1; c7 * } i = i +1; c8 } Total Cost = c1 + c2 + (+1)*c3 + *c4 + *(+1)*c5+**c6+**c7+*c8 The time required for this algorithm is proportioal to 2

12 Geeral Rules for Estimatio Loops: The ruig time of a loop is at most the ruig time of the statemets iside of that loop times the umber of iteratios. Nested Loops: Ruig time of a ested loop cotaiig a statemet i the ier most loop is the ruig time of statemet multiplied by the product of the sized of all loops. Cosecutive Statemets: Just add the ruig times of those cosecutive statemets. If/Else: Never more tha the ruig time of the test plus the larger of ruig times of S1 ad S2.

13 Defiitio of the Order of a Algorithm Defiitio: Algorithm A is order f() deoted as O(f()) if costats k ad 0 exist such that A requires o more tha k*f() time uits to solve a problem of size 0. The requiremet of 0 i the defiitio of O(f()) formalizes the otio of sufficietly large problems. I geeral, may values of k ad ca satisfy this defiitio.

14 Order of a Algorithm If a algorithm requires 2 3*+10 secods to solve a problem size. If costats k ad 0 exist such that k* 2 > 2 3*+10 for all 0. the algorithm is order 2 (I fact, k is 3 ad 0 is 2) 3* 2 > 2 3*+10 for all 2. Thus, the algorithm requires o more tha k* 2 time uits for 0, So it is O( 2 )

15 A Compariso of Growth-Rate Fuctios

16 A Compariso of Growth-Rate Fuctios (cot.)

17 Growth-Rate Fuctios O(1) Time requiremet is costat, ad it is idepedet of the problem s size. O(log 2 ) Time requiremet for a logarithmic algorithm icreases icreases slowly as the problem size icreases. O() Time requiremet for a liear algorithm icreases directly with the size of the problem. O(*log 2 ) Time requiremet for a *log 2 algorithm icreases more rapidly tha a liear algorithm. O( 2 ) Time requiremet for a quadratic algorithm icreases rapidly with the size of the problem. O( 3 ) Time requiremet for a cubic algorithm icreases more rapidly with the size of the problem tha the time requiremet for a quadratic algorithm. O(2 ) As the size of the problem icreases, the time requiremet for a expoetial algorithm icreases too rapidly to be practical.

18 Growth-Rate Fuctios If a algorithm takes 1 secod to ru with the problem size 8, what is the time requiremet (approximately) for that algorithm with the problem size 16? If its order is: O(1) O(log 2 ) O() T() = 1 secod T() = (1*log 2 16) / log 2 8 = 4/3 secods T() = (1*16) / 8 = 2 secods O(*log 2 ) T() = (1*16*log 2 16) / 8*log 2 8 = 8/3 secods O( 2 ) O( 3 ) T() = (1*16 2 ) / 8 2 = 4 secods T() = (1*16 3 ) / 8 3 = 8 secods O(2 ) T() = (1*2 16 ) / 2 8 = 2 8 secods = 256 secods

19 Properties of Growth-Rate Fuctios 1. We ca igore low-order terms i a algorithm s growth-rate fuctio. If a algorithm is O( ), it is also O( 3 ). We oly use the higher-order term as algorithm s growth-rate fuctio. 2. We ca igore a multiplicative costat i the higher-order term of a algorithm s growth-rate fuctio. If a algorithm is O(5 3 ), it is also O( 3 ). 3. O(f()) + O(g()) = O(f()+g()) We ca combie growth-rate fuctios. If a algorithm is O( 3 ) + O(4), it is also O( ) So, it is O( 3 ). Similar rules hold for multiplicatio.

20 Some Mathematical Facts Some mathematical equalities are: 2 2 1) *( i i 3 6 1) 1)*(2 *( i i i i

21 Growth-Rate Fuctios Example1 Cost Times i = 1; c1 1 sum = 0; c2 1 while (i <= ) { c3 +1 i = i + 1; c4 sum = sum + i; c5 } T() = c1 + c2 + (+1)*c3 + *c4 + *c5 = (c3+c4+c5)* + (c1+c2+c3) = a* + b So, the growth-rate fuctio for this algorithm is O()

22 } T() Growth-Rate Fuctios Example2 Cost Times i=1; c1 1 sum = 0; c2 1 while (i <= ) { c3 +1 j=1; c4 while (j <= ) { c5 *(+1) sum = sum + i; c6 * j = j + 1; c7 * } i = i +1; c8 = c1 + c2 + (+1)*c3 + *c4 + *(+1)*c5+**c6+**c7+*c8 = (c5+c6+c7)* 2 + (c3+c4+c5+c8)* + (c1+c2+c3) = a* 2 + b* + c So, the growth-rate fuctio for this algorithm is O( 2 )

23 Growth-Rate Fuctios Example3 Cost Times for (i=1; i<=; i++) c1 +1 for (j=1; j<=i; j++) c2 for (k=1; k<=j; k++) c3 x=x+1; c4 j1 j1 k 1 j ( j 1) j j1 k 1 ( k 1) k T() = c1*(+1) + c2*( j 1) ) + c3* ( k 1) ) + c4*( k ) j1 j ( ( j1 k 1 = a* 3 + b* 2 + c* + d So, the growth-rate fuctio for this algorithm is O( 3 ) j j1 k 1

24 Growth-Rate Fuctios Recursive Algorithms void haoi(it, char source, char dest, char spare) { if ( > 0) { haoi(-1, source, spare, dest); cout << "Move top disk from pole " << source << " to pole " << dest << edl; haoi(-1, spare, dest, source); } } Cost c1 c2 c3 c4 The time-complexity fuctio T() of a recursive algorithm is defied i terms of itself, ad this is kow as recurrece equatio for T(). To fid the growth-rate fuctio for a recursive algorithm, we have to solve its recurrece relatio.

25 Growth-Rate Fuctios Haoi Towers What is the cost of haoi(, A, B, C )? whe =0 T(0) = c1 whe >0 T() = c1 + c2 + T(-1) + c3 + c4 + T(-1) = 2*T(-1) + (c1+c2+c3+c4) = 2*T(-1) + c recurrece equatio for the growth-rate fuctio of haoi-towers algorithm Now, we have to solve this recurrece equatio to fid the growth-rate fuctio of haoi-towers algorithm

26 Growth-Rate Fuctios Haoi Towers (cot.) There are may methods to solve recurrece equatios, but we will use a simple method kow as repeated substitutios. T() = 2*T(-1) + c = 2 * (2*T(-2)+c) + c = 2 * (2* (2*T(-3)+c) + c) + c = 2 3 * T(-3) + ( )*c (assumig >2) whe substitutio repeated i-1 th times = 2 i * T(-i) + (2 i )*c whe i= = 2 * T(0) + ( )*c 1 i0 = 2 i * c1 + ( 2)*c = 2 * c1 + ( 2-1 )*c = 2 *(c1+c) c So, the growth rate fuctio is O(2 )

27 Sequetial Search it sequetialsearch(cost it a[], it item, it ){ for (it i = 0; i < && a[i]!= item; i++); if (i == ) retur 1; retur i; } Usuccessful Search: O() Successful Search: Best-Case: item is i the first locatio of the array O(1) Worst-Case: item is i the last locatio of the array O() Average-Case: The umber of key comparisos 1, 2,..., i i ( 2 1 ) / 2 O()

28 Biary Search it biarysearch(it a[], it size, it x) { it low =0; it high = size 1; } it mid; while (low <= high) { mid = (low + high)/2; if (a[mid] < x) low = mid + 1; else if (a[mid] > x) high = mid 1; else retur mid; } retur 1; // mid will be the idex of // target whe it s foud.

29 Biary Search Aalysis For a usuccessful search: The umber of iteratios i the loop is log O(log 2 ) For a successful search: Best-Case: The umber of iteratios is 1. O(1) Worst-Case: The umber of iteratios is log 2 +1 O(log 2 ) Average-Case: The avg. # of iteratios < log 2 O(log 2 ) a array with size # of iteratios The average # of iteratios = 21/8 < log 2 8