1 / 18

Chapter 2 Algorithm Analysis

Chapter 2 Algorithm Analysis. 2.1. Mathematical Background. Figure 2.1 Typical growth rates. 2.3 What to Analyze. Figure 2.2 Running times of several algorithms for maximum subsequence sum (in seconds). 2.3 What to Analyze.

lee-sears
Download Presentation

Chapter 2 Algorithm Analysis

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Chapter 2Algorithm Analysis

  2. 2.1. Mathematical Background Figure 2.1 Typical growth rates

  3. 2.3 What to Analyze Figure 2.2 Running times of several algorithms for maximum subsequence sum (in seconds)

  4. 2.3 What to Analyze Figure 2.3 Plot (N vs. milliseconds) of various maximum subsequence sum algorithms

  5. 2.3 What to Analyze Figure 2.4 Plot (N vs. seconds) of various maximum subsequence sum algorithms

  6. 2.4. Running Time Calculations • 2.4.1 A Simple Example Int Sum( int N ) { int i, PartialSum; /* 1*/ PartialSum = 0; /* 2*/ for( i = 1; i <= N; i ++ ) /* 3*/ PartialSum += i * i * i /* 4*/ return PartialSum; }

  7. 2.4.2 General Rules • RULE 1-FOR LOOPS • RULE 2-NESTED FOR LOOPS for( i = 0; i < N; i++ ) for( j = 0; j < N; j++ ) k++; • RULE 3-CONSECUTIVE STATEMENTS for( i = 0; i < N; i++ ) A[ i ] = 0; for( i = 0; i < N; i++ ) for( j = 0; j < N; j++ ) A[ i ] += A[ j ] + i + j; • RULE 4-IF/ELSE if( Condition ) S1 else S2

  8. 2.4.3. Algorithm 1 int MaxSubsequenceSum( const int A[ ], int N ) { int ThisSum, MaxSum, i, j, k; /* 1*/ MaxSum = 0; /* 2*/ for( i = 0; i < N; i++ ) /* 3*/ for( j = i; j < N; j++ ) { /* 4*/ ThisSum = 0; /* 5*/ for( k = i; k <= j; k++ ) /* 6*/ ThisSum += A[ k ]; /* 7*/ if( ThisSum > MaxSum ) /* 8*/ MaxSum = ThisSum; } /* 9*/ return MaxSum; }

  9. 2.4.3. Algorithm 2 int MaxSubsequenceSum( const int A[ ], int N ) { int ThisSum, MaxSum, i, j; /* 1*/ MaxSum = 0; /* 2*/ for( i = 0; i < N; i++ ) { /* 3*/ ThisSum = 0; /* 4*/ for( j = i; j < N; j++ ) { /* 5*/ ThisSum += A[ j ]; /* 6*/ if( ThisSum > MaxSum ) /* 7*/ MaxSum = ThisSum; } } /* 8*/ return MaxSum; }

  10. 2.4.3. Algorithm 3 static int MaxSubSum( const int A[ ], int Left, int Right ) { int MaxLeftSum, MaxRightSum; int MaxLeftBorderSum, MaxRightBorderSum; int LeftBorderSum, RightBorderSum; int Center, i; /* 1*/ if( Left == Right ) /* Base case */ /* 2*/ if( A[ Left ] > 0 ) /* 3*/ return A[ Left ]; else /* 4*/ return 0; /* 5*/ Center = ( Left + Right ) / 2; /* 6*/ MaxLeftSum = MaxSubSum( A, Left, Center ); /* 7*/ MaxRightSum = MaxSubSum( A, Center + 1, Right );

  11. 2.4.3. Algorithm 3 cont. /* 8*/ MaxLeftBorderSum = 0; LeftBorderSum = 0; /* 9*/ for( i = Center; i >= Left; i-- ) { /*10*/ LeftBorderSum += A[ i ]; /*11*/ if( LeftBorderSum > MaxLeftBorderSum ) /*12*/ MaxLeftBorderSum = LeftBorderSum; } /*13*/ MaxRightBorderSum = 0; RightBorderSum = 0; /*14*/ for( i = Center + 1; i <= Right; i++ ) { /*15*/ RightBorderSum += A[ i ]; /*16*/ if( RightBorderSum > MaxRightBorderSum ) /*17*/ MaxRightBorderSum = RightBorderSum; } /*18*/ return Max3( MaxLeftSum, MaxRightSum, /*19*/ MaxLeftBorderSum + MaxRightBorderSum ); } /*MaxSubSum*/

  12. 2.4.3. Algorithm 3 cont. int MaxSubsequenceSum( const int A[ ], int N ) { return MaxSubSum( A, 0, N - 1 ); }

  13. 2.4.4. Algorithm 4 int MaxSubsequenceSum( const int A[ ], int N) { int ThisSum, MaxSum, j; /* 1*/ ThisSum = MaxSum = 0; /* 2*/ for( j = 0; j < N; j++ ) { /* 3*/ ThisSum += A[ j ]; /* 4*/ if( ThisSum > MaxSum ) /* 5*/ MaxSum = ThisSum; /* 6*/ else if( ThisSum < 0 ) /* 7*/ ThisSum = 0; } /* 8*/ return MaxSum; }

  14. 2.4.4. Binary search int BinarySearch( const ElementType A[ ], ElementType X, int N ) { int Low, Mid, High; /* 1*/ Low = 0; High = N - 1; /* 2*/ while( Low <= High ) { /* 3*/ Mid = ( Low + High ) / 2; /* 4*/ if( A[ Mid ] < X ) /* 5*/ Low = Mid + 1; else /* 6*/ if( A[ Mid ] > X ) /* 7*/ High = Mid - 1; else /* 8*/ return Mid; /* Found */ } /* 9*/ return NotFound; /* NotFound is defined as -1 */ }

  15. 2.4.4. Euclid’s algorithm unsigned int Gcd( unsigned int M, unsigned int N ) { unsigned int Rem; /* 1*/ while( N > 0 ) { /* 2*/ Rem = M % N; /* 3*/ M = N; /* 4*/ N = Rem; } /* 5*/ return M; }

  16. 2.4.4. Efficient exponentiation long int Pow( long int X, unsigned int N ) { /* 1*/ if( N == 0 ) /* 2*/ return 1; /* 3*/ if( N == 1 ) /* 4*/ return X; /* 5*/ if( IsEven( N ) ) /* 6*/ return Pow( X * X, N / 2 ); else /* 7*/ return Pow( X * X, N / 2 ) * X; }

  17. 2.4.6. Estimate the probability that two random numbers are relatively prime Rel = 0; Tot = 0; for( i = 1; i <= N; i++ ) for( j = i + 1; j <= N; j++) { Tot++; if( Gcd( i, j) == 1 ) Rel++; } printf( “Percentage of relatively prime pairs is %f\n”, ( double ) Rel / Tot );

  18. 2.4.6 Empirical running times for the previous routine

More Related