Algorithms Lecture 2: Analysis of Algorithms I

Analysis and Design of Algorithms
Analysis of Algorithms I

Analysis of Algorithms
Time complexity
Asymptotic Notations
Big O Notation
Growth Orders
Problems

Analysis of Algorithms is the determination of the
amount of time, storage and/or other resources necessary
to execute them.
Analyzing algorithms is called Asymptotic Analysis
Asymptotic Analysis evaluate the performance of an
algorithm

Time complexity

 time complexity of an algorithm quantifies the amount of time taken
by an algorithm
 We can have three cases to analyze an algorithm:
1) Worst Case
2) Average Case
3) Best Case

 Assume the below algorithm using Python code:

 Worst Case Analysis: In the worst case analysis, we calculate upper
bound on running time of an algorithm.

 Worst Case Analysis: the case that causes maximum number of
operations to be executed.
 For Linear Search, the worst case happens when the element to be
searched is not present in the array. (example : search for number
8)
2 3 5 4 1 7 6

 Worst Case Analysis: When x is not present, the search() functions
compares it with all the elements of arr one by one.

 The worst case time complexity of linear search would be O(n).

 Average Case Analysis: we take all possible inputs and calculate
computing time for all of the inputs.

 Best Case Analysis: calculate lower bound on running time of an
algorithm.

 The best case time complexity of linear search would be O(1).

 Best Case Analysis: the case that causes minimum number of
operations to be executed.
 For Linear Search, the best case occurs when x is present at the first
location. (example : search for number 2)
 So time complexity in the best case would be Θ(1)
2 3 5 4 1 7 6

 Most of the times, we do worst case analysis to analyze algorithms.
 The average case analysis is not easy to do in most of the practical
cases and it is rarely done.
 The Best case analysis is bogus. Guaranteeing a lower bound on an
algorithm doesn’t provide any information.

1) Big O Notation: is an Asymptotic Notation for the worst case.
2) Ω Notation (omega notation): is an Asymptotic Notation for the
best case.
3) Θ Notation (theta notation) : is an Asymptotic Notation for the
worst case and the best case.

Big O Notation

1) O(1)
 Time complexity of a function (or set of statements) is considered as
O(1) if it doesn’t contain loop, recursion and call to any other non-
constant time function. For example swap() function has O(1) time
complexity.

 A loop or recursion that runs a constant number of times is also
considered as O(1). For example the following loop is O(1).

2) O(n)
 Time Complexity of a loop is considered as O(n) if the loop
variables is incremented / decremented by a constant amount. For
example the following loop statements have O(n) time complexity.

2) O(n)

2) O(n)
 Another Example:

3) O(nc)
 Time complexity of nested loops is equal to the number of times the
innermost statement is executed. For example the following loop
statements have O(n2) time complexity

3) O(n2)

 Another Example

4) O(Logn)
 Time Complexity of a loop is considered as O(Logn) if the loop
variables is divided / multiplied by a constant amount.

4) O(Logn)
 Another Example

5) O(LogLogn)
 Time Complexity of a loop is considered as O(LogLogn) if the loop
variables is reduced / increased exponentially by a constant.

5) O(LogLogn)
 Another Example

 How to combine time complexities of consecutive loops?
 Time complexity of above code is O(n) + O(m) which is O(n+m)

n O(1) O(log(n)) O(n) O(nlog(n)) O(N2) O(2n) O(n!)
1 1 0 1 1 1 2 1
8 1 3 8 24 64 256 40xx103
30 1 5 30 150 900 10x109 210x1032
500 1 9 500 4500 25x104 3x10150 1x101134
1000 1 10 1000 10x103 1x106 1x10301 4x102567
16x103 1 14 16x103 224x103 256x106 - -
1x105 1 17 1x105 17x105 10x109 - -

Length of Input (N) Worst Accepted Algorithm
≤10 O(N!),O(N6)
≤15 O(2N∗N2)
≤20 O(2N∗N)
≤100 O(N4)
≤400 O(N3)
≤2K O(N2∗logN)
≤10K O(N2)
≤1M O(N∗logN)
≤100M O(N),O(logN),O(1)

 Find the complexity
of the below
program:

 Solution: Time
Complexity O(n).
Even though the
inner loop is
bounded by n, but
due to break
statement it is
executing only once.

 Find the complexity of the below program:

 Solution:
Time
O(n2logn)

 Solution:
Time
O(n log2n)

 Find the
complexity
of the
below
program:

 Solution:
Time O(n5)

facebook.com/mloey
mohamedloey@gmail.com
twitter.com/mloey
linkedin.com/in/mloey
mloey@fci.bu.edu.eg
mloey.github.io

Algorithms Lecture 2: Analysis of Algorithms I

Recommended

More Related Content

What's hot (20)

Viewers also liked (6)

Similar to Algorithms Lecture 2: Analysis of Algorithms I (20)

More from Mohamed Loey (19)

Recently uploaded (20)

Algorithms Lecture 2: Analysis of Algorithms I