Scribd
Upload
64 views

Introduction To Computation and Programming Using Python, Revised - Guttag, John v..131

This document introduces algorithmic complexity and how to analyze the running time of algorithms. It discusses using a random access machine model of computation where steps take a fixed amount of time. Running time is related to the size of the inputs to allow comparison between algorithms. The best, worst, and average cases are defined for an example linear search algorithm, with the worst case usually being the focus as it provides an upper bound on running time which is important when time constraints exist.

Uploaded by

ZhichaoWang
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
64 views

Introduction To Computation and Programming Using Python, Revised - Guttag, John v..131

This document introduces algorithmic complexity and how to analyze the running time of algorithms. It discusses using a random access machine model of computation where steps take a fixed amount of time. Running time is related to the size of the inputs to allow comparison between algorithms. The best, worst, and average cases are defined for an example linear search algorithm, with the worst case usually being the focus as it provides an upper bound on running time which is important when time constraints exist.

Uploaded by

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

114

Chapter 9. A Simplistic Introduction to Algorithmic Complexity


For simplicity, we will use a random access machine as our model of
computation. In a random access machine, steps are executed sequentially, one
at a time.43 A step is an operation that takes a fixed amount of time, such as
binding a variable to an object, making a comparison, executing an arithmetic
operation, or accessing an object in memory.
Now that we have a more abstract way to think about the meaning of time, we
turn to the question of dependence on the value of the input. We deal with that
by moving away from expressing time complexity as a single number and
instead relating it to the sizes of the inputs. This allows us to compare the
efficiency of two algorithms by talking about how the running time of each grows
with respect to the sizes of the inputs.
Of course, the actual running time of an algorithm depends not only upon the
sizes of the inputs but also upon their values. Consider, for example, the linear
search algorithm implemented by
def linearSearch(L, x):
for e in L:
if e == x:
return True
return False

Suppose that L is a million elements long and consider the call


linearSearch(L, 3). If the first element in L is 3, linearSearch will return True
almost immediately. On the other hand, if 3 is not in L, linearSearch will have
to examine all one million elements before returning False.
In general, there are three broad cases to think about:

The best-case running time is the running time of the algorithm when
the inputs are as favorable as possible. I.e., the best-case running time
is the minimum running time over all the possible inputs of a given size.
For linearSearch, the best-case running time is independent of the size
of L.

Similarly, the worst-case running time is the maximum running time


over all the possible inputs of a given size. For linearSearch, the worstcase running time is linear in the size of the list.

By analogy with the definitions of the best-case and worst-case running


time, the average-case (also called expected-case) running time is the
average running time over all possible inputs of a given size.
Alternatively, if one has some a priori information about the distribution
of input values (e.g., that 90% of the time x is in L), one can take that into
account.

People usually focus on the worst case. All engineers share a common article of
faith, Murphys Law: If something can go wrong, it will go wrong. The worst-case
provides an upper bound on the running time. This is critical in situations
where there is a time constraint on how long a computation can take. It is not

43 A more accurate model for todays computers might be a parallel random access
machine. However, that adds considerable complexity to the algorithmic analysis, and
often doesnt make an important qualitative difference in the answer.

You might also like