Asymptotic Analysis of Algorithms
Asymptotic Analysis
Growth Rate Analysis
We need to measure the computational time in a more high-level fashion,
prior to implementing the algorithm and performing experimental studies.
We should employ mathematical techniques that analyze algorithms
independently of specific implementations, computers, or data.
The growth rate analysis from the previous lecture allows us to characterize
the running times of algorithms by using functions that map the size of the
input, n, to values that correspond to the main factor that determines the
growth rate in terms of n.
Asymptotic Analysis: The "Big-Oh" Notation
Asymptotic analysis is a method of describing the limiting behavior of a
function as the input size becomes very large. It is based on mathematical
concepts such as limits, differentiation, integration, and analytic functions.
The "big-Oh" notation is a way of providing an asymptotic upper bound on
the growth rate of a function f(n). Specifically, we say that f(n) is O(g(n)) if
there exists a real constant c > 0 and an integer constant n₀ ≥ 1 such that
for all n ≥ n₀, f(n) ≤ c * g(n).
The choice of c and n₀ is not unique, as there can be many different
combinations that would make the proof work, depending on the inequalities
used while doing the upper-bounding.
The big-Oh notation provides an asymptotic way of saying that a function is
"less than or equal to" another function. It represents the upper bound of an
algorithm's runtime, i.e., the worst-case scenario. This means that the
runtime grows at most as fast as the function g(n) as the input size
increases.
Worst-Case Analysis
Analyzing the worst-case scenario is much easier than average-case
analysis, as the worst-case input is often simple to identify. Focusing on the
worst-case input typically leads to better algorithms, as an algorithm
performing well in the worst case will also do well on every input.
Experimental Studies and Growth Rate Analysis
The growth rate analysis from the previous lecture can be used to predict
the relative performance of different algorithms as the input size increases.
This can be visualized using graphs that show the running time as a function
