Theoretical and Experimental DNA Computation (Natural ...

40 2 Theoretical Computer Science: A Primer
Root
Parents
Child leaf nodes
Fig. 2.14. An example tree
faster (on the same computer) than one used to calculate the first million
prime numbers. However, it is important be able to establish this fact with
certainty. The field of computational complexity is concerned with the resources
required by algorithms.
Complexity may be defined as “the intrinsic minimum amount of resources,
for instance, memory or time, needed to solve a problem or execute an algorithm.”
In practice, we generally consider time as the limiting factor (that is,
when discussing the relative complexity of algorithms, we consider the time
taken for them to achieve their task).
We measure the time complexity of an algorithm in terms of the number of
computational “steps” it takes. For example, consider the factoring algorithm
given in Sect. 2.4. We assume for the sake of argument than n>0. Step 1
involves reading n. Step 2 is the conditional, checking if n ≤ 0. Step 3 assigns
thevalue1tothepower variable. Then we enter a loop. This is the crucial
part of the analysis, as it involves the section of the algorithm where most
work is done. Step 4 checks the value of n. Aslongasn>0, we execute two
assignment steps (to power and n). We then execute a final step to print out
the value of power. Ascounter has the value n − 1, this algorithm takes two
steps if n ≤ 0, and 5 + (n∗3) steps if n ≥ 0. Note that the constant 5 includes
the final “while” step.
However, consider the implementation of this algorithm on a computer.
The running time of the program, given a particular value of n, still depends
on two factors:
1. The computer on which the program is run. Supercomputers execute instructions
far more rapidly than personal computers,
2. The conversion of the pseudo-code into machine language. Programs to
do this are called compilers, and some compilers generate more efficient
machine code than others. The number of machine instructions used to
implement a particular pseudo-code statement will vary from compiler to
compiler.
We cannot therefore make statements like “this program will take 0.52 seconds
to run for an input value of n = 1000”, unless we know the precise details of
the machine and the compiler. Even then, the fact that the machine may or
may not be carrying out other time-consuming tasks renders such predictions
meaningless. Nobody is interested in the time complexity of an algorithm
compiled in a particular way running on a particular machine in a particular