Algorithem complexity in data sructure

Algorithms
and Data
Structures
Marcin
Sydow
Algorithms and Data Structures
Complexity of Algorithms
Marcin Sydow

Algorithms
and Data
Structures
Marcin
Sydow
Desired Properties of a Good Algorithm
Any good algorithm should satisfy 2 obvious conditions:
1 compute correct (desired) output (for the given problem)
2 be eective (fast)
ad. 1) correctness of algorithm
ad. 2) complexity of algorithm
Complexity of algorithm measures how fast is the algorithm
(time complexity) and what amount of memory it uses
(space complexity) - time and memory - 2 basic resources in
computations

Algorithms
and Data
Structures
Marcin
Sydow
Example - the Search Problem
Problem of searching a key in an array
What does the amount of work of this algorithm depend on?
find(arr, len, key)
Specication:
input: arr - array of integers, len - it's length, key - integer to be found
output: integer 0 ≤ i len being the index in arr, under which the key is
stored

Algorithms
and Data
Structures
Marcin
Sydow
find(arr, len, key)
Specication:
stored (is it a complete/clear specication?)

Algorithms
and Data
Structures
Marcin
Sydow
find(arr, len, key)
Specication:
stored (is it a complete/clear specication?) or the value of -1 when there
is no specied key in (rst len positions of) the array

Algorithms
and Data
Structures
Marcin
Sydow
find(arr, len, key)
Specication:
stored (is it a complete/clear specication?) or the value of -1 when there
is no specied key in (rst len positions of) the array
code:
find(arr, len, key){
i = 0
while(i len){
if(arr[i] == key)
return i
i++
}
return -1
}

Algorithms
and Data
Structures
Marcin
Sydow
The speed of algorithm
How to measure how fast (or slow) an algorithm is?
There are 2 issues to be considered when designing such a
measure:
1 independence on any programming language (and
hardware/software platform)
2 maximum independence on particular input data
It should be an internal property of the algorithm itself
Any idea?

Algorithms
and Data
Structures
Marcin
Sydow
The speed of algorithm
How to measure how fast (or slow) an algorithm is?
There are 2 issues to be considered when designing such a
measure:
1 independence on any programming language (and
hardware/software platform)
2 maximum independence on particular input data
It should be an internal property of the algorithm itself
Any idea? Count basic operations of the algorithm

Algorithms
and Data
Structures
Marcin
Sydow
Dominating Operations
Simplication: it is not necessary to count all the operations - it
is enough to count the representative ones
Before doing a complexity analysis 2 steps must be done:
1 determine the dominating operation set
2 observe what (in input) inuences the number of
dominating operations (data size)
Dominating operations are those which cover the amount of
work which is proportional to the whole amount of work of the
algorithm (they well represent the whole)

Algorithms
and Data
Structures
Marcin
Sydow
Example - determining operating operations
What can be the dominating operation set in the following
algorithm?
i = 0
while(i len){
if(arr[i] == key)
return i
i++
}
return -1
}
assignment i = 0 ?

Algorithms
and Data
Structures
Marcin
Sydow
algorithm?
i = 0
while(i len){
if(arr[i] == key)
return i
i++
}
return -1
}
assignment i = 0 ? no
comparison i len ?

Algorithms
and Data
Structures
Marcin
Sydow
algorithm?
i = 0
while(i len){
if(arr[i] == key)
return i
i++
}
return -1
}
comparison i len ? yes
comparison arr[i] == key ?

Algorithms
and Data
Structures
Marcin
Sydow
algorithm?
i = 0
while(i len){
if(arr[i] == key)
return i
i++
}
return -1
}
comparison arr[i] == key ? yes
both the above?

Algorithms
and Data
Structures
Marcin
Sydow
algorithm?
i = 0
while(i len){
if(arr[i] == key)
return i
i++
}
return -1
}
both the above? yes
return statement return i ?

Algorithms
and Data
Structures
Marcin
Sydow
algorithm?
i = 0
while(i len){
if(arr[i] == key)
return i
i++
}
return -1
}
both the above? yes
return statement return i ? no
index increment i++ ?

Algorithms
and Data
Structures
Marcin
Sydow
algorithm?
i = 0
while(i len){
if(arr[i] == key)
return i
i++
}
return -1
}
both the above? yes
return statement return i ? no
index increment i++ ? yes

Algorithms
and Data
Structures
Marcin
Sydow
Example, cont. - determining the data size
What is the data size in the following algorithm?
i = 0
while(i len){
if(arr[i] == key)
return i
i++
}
return -1
}

Algorithms
and Data
Structures
Marcin
Sydow
i = 0
while(i len){
if(arr[i] == key)
return i
i++
}
return -1
}
Data size: length of array arr

Algorithms
and Data
Structures
Marcin
Sydow
i = 0
while(i len){
if(arr[i] == key)
return i
i++
}
return -1
}
Data size: length of array arr
Having determined the dominating operation and data size
we can determine time complexity of the algorithm

Algorithms
and Data
Structures
Marcin
Sydow
Time Complexity of Algorithm
Denition
Time Complexity of Algorithm is the number of dominating
operations executed by the algorithm as the function of data
size.
Time complexity measures the amount of work done by the
algorithm during solving the problem in the way which is
independent on the implementation and particular input data.
The lower time complexity the faster algorithm

Algorithms
and Data
Structures
Marcin
Sydow
Example - time complexity of algorithm
i = 0
while(i len){
if(arr[i] == key)
return i
i++
}
return -1
}
Assume:
dominating operation: comparison arr[i] == key
data size: the length of array (denote by n)
Thus, the number of dominating operations executed by this
algorithm ranges:
from 1 (the key was found under the rst index)
to n (the key is absent or under the last index)
There is no single function which could express the dependence of the number of
executed dominating operations on the data size for this algorithm.

Algorithms
and Data
Structures
Marcin
Sydow
Pessimistic Time Complexity
let's assume the following denotations:
n - data size
Dn - the set of all possible input datasets of size n
t(d) - the number of dominating operations for dataset d (of size n)
(d ∈ Dn)
Denition
Pessimistic Time Complexity of algorithm:
W(n) = sup{t(d) : d ∈ Dn}
(W(n) - Worst)
Pessimistic Time Complexity expresses the number of
dominating operations in the worst case of input data of size n
E.g. for our example the pessimistic time complexity is given by
the formula:

Algorithms
and Data
Structures
Marcin
Sydow
Pessimistic Time Complexity
n - data size
t(d) - the number of dominating operations for dataset d (of size n)
(d ∈ Dn)
Denition
Pessimistic Time Complexity of algorithm:
W(n) = sup{t(d) : d ∈ Dn}
(W(n) - Worst)
Pessimistic Time Complexity expresses the number of
dominating operations in the worst case of input data of size n
E.g. for our example the pessimistic time complexity is given by
the formula:
W(n) = n

Algorithms
and Data
Structures
Marcin
Sydow
Average Time Complexity of Algorithm
n - data size
t(d) - the number of dominating operations for dataset d (of size n) (d ∈ Dn)
Xn - random variable, its value is t(d) for d ∈ Dn
pnk - probability distribution of the random variable Xn (i.e. the probability that
for input data of size n the algorithm will execute k dominating operations
(k ≥ 0))
Denition
Average Time Complexity of Algorithm:
A(n) = k≥0
pnk · k = P(Xn = k) · k
(expected value of the random variable representing the number
of dominating operations)
(A(n) Average)

Algorithms
and Data
Structures
Marcin
Sydow
Example - Determining the Average Time
Complexity
Let's determine the average time complexity for our exemplary
algorithm (nd)
First, we have to assume some probabilistic model of input
data (i.e. the probabilistic distribution of possible input
datasets)
Let's make a simplistic assumption: the key to be found occurs
exactly once in array and with the same probability on each
index (uniform distribution) (∀0≤knP(Xn = k) = 1/n)
Thus:
A(n) = k≥0
P(Xn = k) · k = 0≤kn 1/n · k = n+1
2

Algorithms
and Data
Structures
Marcin
Sydow
Space Complexity of Algorithm
Denition
Space Complexity of Algorithm: S(n) is the number of units
of memory used by algorithm as a function of data size
This characteristic is more dependent on particular platform than time complexity.
As a memory unit one can consider the machine word.
Note:
We will assume, that the memory used for keeping the input
data is not considered because usually arrays (and other
compound types) are passed as arguments to functions by
reference, which does not involve much memory
In our example space complexity is constant - because it consumes memory only
for a single variable (plus some xed number of additional temporal variables),
independently on the input data size: S(n) = const

Algorithms
and Data
Structures
Marcin
Sydow
Omitting Unimportant Details
The real time spent by an implementation of the algorithm
may dier between particular platforms by a constant
multiplicative factor. (e.g. CPU speed)
Thus, it would be very useful to have a notation allowing for
expressing the complexity functions with neglecting
unimportant details (as multiplicative or additive constant, for
example)
E.g. for the following function:
A(n) = 2.1 · n − 1
The most important information is that it is a linear function -
it's rank of complexity is linear
Does such a notation exist?

Algorithms
and Data
Structures
Marcin
Sydow
Asymptotic Notation - Big O
The notation is called asymptotic notation.
There are a couple of avours. The most common is big O:
Denition
The function g(n) is the upper bound of rank of order of the
function f(n):
f (n) = O(g(n)) ⇔ ∃c0∃n0∀n≥n0f (n) ≤ c · g(n)
The O() notation intuitively corresponds to the ≤ symbol (in
terms of ranks of orders of functions).
E.g. the fact that W(n) of our exemplary algorithm has an
upper bound of the linear rank can be noted as:
W(n) = n+1
2
= O(n)
The constant space complexity S(n) of that algorithm can be
expressed with the following special notation:
S(n) = O(1)

Algorithms
and Data
Structures
Marcin
Sydow
Asymptotic Notation - Big Theta
Another important avour of asymptotic notation is big Theta:
Denition
The function f(n) has the same rank of order as the function
g(n): f (n) = Θ(g(n)) ⇔ f (n) = O(g(n)) ∧ g(n) = O(f (n))
The Θ() notation intuitively corresponds to the = symbol (in
terms of ranks of orders of functions).
Notice, that Θ() is dened with the use of O(), similarly as = symbol can be
dened with the use of ≤ symbol.
E.g. the expression: f (n) = n2
+ n − 3 = Θ(n2
)
reads as the n2
+ n − 3 function is of square rank of order.

Algorithms
and Data
Structures
Marcin
Sydow
Other Flavours of Asymptotic Notation
We have 5 relation symbols for comparing numbers: = ≤ ≥
In total, we also have 5 analogous symbols for comparing ranks
of functions:
1 Θ - =
2 O - ≤
3 Ω - ≥
4 o -
5 ω -
(in general, a capital letter denotes non-sharp inequality and lowercase denotes
a sharp one)
E.g.:
W(n)=o(n) (lowercase o)
means: the rank of function W(n) is lower than linear

Algorithms
and Data
Structures
Marcin
Sydow
Some Remarks on Using the Asymptotic Notation
Notice: in expressions like f(n)=O(g(n)) the = has a special
meaning - it does not represent the normal equality. The
expression has it's meaning only as a whole.
E.g. it does not make sense to use asymptotic notation as the
rst expression on the left-hand side of the = symbol.
E.g. expressions like O(f(n)) = n or O(f(n)) = O(g(n)) do
not make any sense
Besides the standard usage of the asymptotic notation on the
right-hand side of the = symbol, it can be also used in the
following way:
f(n) = g(n) + O(h(n))
Which means: f(n) - g(n) = O(h(n))
(the ranks of functions f and g dier at most by a rank of
function h)

Algorithms
and Data
Structures
Marcin
Sydow
Remarks: Comparing Ranks of Functions
Sometimes the following technique is useful.
Ranks of some 2 functions f(n) and g(n) can be compared by
computing the following limit:
limn→∞
f(n)
g(n)
there are 3 possible cases for the limit:
1 ∞ - in that case f(n)=ω(g(n)) (f has higher rank)
2 a positive constant - in that case f(n)=Θ(g(n)) (the same
ranks)
3 zero - in that case f(n)=o(g(n)) (lowercase o) (g has
higher rank)

Algorithms
and Data
Structures
Marcin
Sydow
The Most Common Ranks of Functions
constant (e.g. S(n) = 3 = Θ(1))
logarithmic (e.g. W(n) = 2 + lg2n = Θ(log(n)))
linear (e.g. A(n) = 2n + 1 = Θ(n))
linear-logarithmic (e.g.
A(n) = 1.44 · nlog(n) = Θ(nlog(n)))
square (e.g. W(n) = n2
+ 4 = Θ(n2
))
cubic (e.g. A(n) = Θ(n3
))
sub-exponential (e.g. A(n) = Θ(nlog(n)))
exponential (e.g. A(n) = Θ(2
n))
factorial (e.g. W(n) = Θ(n!))
In simplication: in practise, an over-polynomial rank of time complexity is
considered as unacceptably high
In case of space complexity, even linear rank is considered as very high

Algorithms
and Data
Structures
Marcin
Sydow
Questions/Problems:
How to measure the speed of algorithm
What 2 things should be determined before starting
assessing the time complexity of an algorithm
What is a dominating operation
Denition of Time Complexity of Algorithm
Denition of Space Complexity of Algorithm
Denition of Pessimistic Time Complexity
Denition of Average Time Complexity
Be able to determine time complexity for simple algorithms
What is the purpose of the asymptotic notation
Denition and interpretation of the O() notation
Denitions (and interpretations) of the other types of
asymptotic notations
Ability to express rank of a given function with the
asymptotic notation

Algorithms
and Data
Structures
Marcin
Sydow
Thank you for your attention

Algorithem complexity in data sructure

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Algorithem complexity in data sructure (20)

More from Kumar (20)

Algorithem complexity in data sructure