Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Scribd
Upload
46 views

Mathematical Analysis of Nonrecursive Algorithms

The document discusses analyzing the time complexity of non-recursive algorithms through three main steps: 1. Decide on a parameter like input size n to measure complexity. 2. Identify the basic operation, usually in the innermost loop. 3. Derive a formula for the number of times the basic operation is performed as a function of n using summations, then determine the complexity class. It provides examples finding the complexity of algorithms for finding the maximum element, checking element uniqueness, and matrix multiplication. All are shown to perform the basic operation a number of times proportional to n, n^2, and n^3 respectively.

Uploaded by

Sindhusaranya Prakash
Copyright
© © All Rights Reserved
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
46 views

Mathematical Analysis of Nonrecursive Algorithms

The document discusses analyzing the time complexity of non-recursive algorithms through three main steps: 1. Decide on a parameter like input size n to measure complexity. 2. Identify the basic operation, usually in the innermost loop. 3. Derive a formula for the number of times the basic operation is performed as a function of n using summations, then determine the complexity class. It provides examples finding the complexity of algorithms for finding the maximum element, checking element uniqueness, and matrix multiplication. All are shown to perform the basic operation a number of times proportional to n, n^2, and n^3 respectively.

Uploaded by

Sindhusaranya Prakash
Copyright
© © All Rights Reserved
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 13

Mathematical Analysis of Nonrecursive

Algorithms
simple example that demonstrates all the principal steps typically taken in analysing
Time complexity of an algorithms.
EXAMPLE : Consider the problem of finding the value of the largest element in a
list of n numbers. For simplicity, we assume that the list is implemented as an array
 ALGORITHM MaxElement(A[0..n − 1])
input’s size =the number of elements in the array, i.e., n.
 //Determines the value of the largest element in a given array
 //Input: An array A[0..n − 1] of real numbers The operations that are going to be executed most often are
 //Output: The value of the largest element in A in the algorithm’s for loop. (two operations)

 maxval ←A[0] the comparison : A[i]> maxval and


the assignment maxval←A[i].
 for i ←1 to n − 1 do
 if A[i]>maxval Which of these two operations should we consider
 maxval←A[i] basic?
Since the comparison is executed on each repetition of
 return maxval
the loop and the assignment is not, we should consider
the comparison to be the algorithm’s basic operation.
the number of comparisons will be the same for all
 Let us denote C(n) the number of times this comparison is executed and try to find a
formula expressing it as a function of size n. The algorithm makes one comparison
on each execution of the loop, which is repeated for each value of the loop’s variable
i within the bounds 1 and n − 1, inclusive. Therefore, we get the following sum for
C(n):

 Since the loop runs n-1 times, and there's one comparison in each iteration, the total
number of comparisons, denoted by C(n), is equal to n-1. Thus,

The function C(n) = n - 1 is in the class Θ(n), which denotes the time complexity.
This means the number of comparisons grows linearly with the size of the input, n.
 General Plan for Analyzing the Time Efficiency of Non-recursive Algorithms
 1. Decide on a parameter (or parameters) indicating an input’s size.
 2. Identify the algorithm’s basic operation.
 (As a rule, it is located in the innermost loop.)
 3. Check whether the number of times the basic operation is executed depends only on
the size of an input.
 If it also depends on some additional property, the worst-case, average-case, and, if necessary, best-
case efficiencies have to be investigated separately.
 4. Set up a sum expressing the number of times the algorithm’s basic operation is
executed.4
 5. Using standard formulas and rules of sum manipulation, either find a closed form
formula for the count or, at the very least, establish its order of growth.
Two basic rules of sum manipulation,

Two summation formulas,


EXAMPLE : Consider the element uniqueness problem: check whether all the elements in
a given array of n elements are distinct. This problem can be solved by the following
straightforward algorithm.
 ALGORITHM UniqueElements(A[0..n − 1])
 //Determines whether all the elements in a given
array are distinct
 //Input: An array A[0..n − 1]
 //Output: Returns “true” if all the elements in A are
distinct
 // and “false” otherwise
 for i ←0 to n − 2 do
 for j ←i + 1 to n − 1 do
 if A[i]= A[j ] return false
 return true
 input’s size = n, the number of elements in the array.
 Since the innermost loop contains a single operation (the comparison of two elements), we
should consider it as the algorithm’s basic operation.
 Note, however, that the number of element comparisons depends not only on n but also on whether there
are equal elements in the array and, if there are, which array positions they occupy.
We will limit our investigation to the worst case only.
 number of element comparisons Cworst(n) is the largest among all arrays of size n.
 An inspection of the innermost loop reveals that there are two kinds of worst-case inputs –
(inputs for which the algorithm does not exit the loop prematurely)
 1. arrays with no equal elements and
 2. arrays in which the last two elements are the only pair of equal elements.
 For such inputs, one comparison is made for each repetition of the innermost loop, i.e., for
each value of the loop variable j between its limits i + 1 and n − 1;
 this is repeated for each value of the outer loop, i.e., for each value of the loop variable i
between its limits 0 and n − 2. Accordingly, we get
 where the last equality is obtained by applying summation formula (S2).
 Note that this result was perfectly predictable: in the worst case, the algorithm
needs to compare all n(n − 1)/2 distinct pairs of its n elements.
EXAMPLE : Given two n × n matrices A and B, find the time efficiency of the definition-
based algorithm for computing their product C = AB. By definition, C is an n × n matrix
whose elements are computed as the scalar (dot) products of the rows of matrix A and the
columns of matrix B:

where C[i, j ]= A[i, 0]B[0, j]+ . . . + A[i, k]B[k, j]+ . . . + A[i, n − 1]B[n − 1, j] for every
pair of indices 0 ≤ i, j ≤ n − 1.
 ALGORITHM MatrixMultiplication(A[0..n − 1, 0..n − 1], B[0..n − 1, 0..n − 1])
 //Multiplies two square matrices of order n by the definition-based algorithm
 //Input: Two n × n matrices A and B  input’s size = matrix order n.

 //Output: Matrix C = AB  basic operation: —multiplication and addition—


 (Actually, we do not have to choose between
 for i ←0 to n − 1 do
them, because on each repetition of the innermost
 for j ←0 to n − 1 do loop each of the two is executed exactly once. So
by counting one we automatically count the other.
 C[i, j ]←0.0 we consider multiplication as the basic operation)
 for k←0 to n − 1 do
 C[i, j ]←C[i, j ]+ A[i, k] ∗ B[k, j]
 return C
 Let us set up a sum for the total number of multiplicationsM(n) executed by the algorithm. (count
depends only on the size of the input matrices- do not have to investigate the worst, average & best-
case efficiencies separately.)
 one multiplication executed on each repetition of the algorithm’s innermost loop, which is governed by
the variable k ranging from the lower bound 0 to the upper bound n − 1. Therefore, the number of
multiplications made for every pair of specific values of variables i and j is,
 The algorithm computes n2 elements of the product matrix. Each of the product’s elements is
computed as the scalar (dot) product of an n-element row of the first matrix and an n-element
column of the second matrix, which takes n multiplications. So the total number of
multiplications is n . n2 = n3.
 If we now want to estimate the running time of the algorithm on a particular machine, we can
do it by the product,

 where cm is the time of one multiplication on the machine in question.


 To get a more accurate estimate, consider the time spent on the additions, too:

where ca is the time of one addition.


Mathematical Analysis of Recursive
Algorithms

You might also like