0% found this document useful (0 votes)
11 views25 pages

Computational Complexity of Algo

Discrete mathematics for it book

Uploaded by

crystaljhoyl
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
11 views25 pages

Computational Complexity of Algo

Discrete mathematics for it book

Uploaded by

crystaljhoyl
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 25

Computational

Complexity of
Algorithm
Group 5
Computational Complexity

Given some input data of size n,


how long will a function take to
run?

How does the number of


computations scale with n?

BACK NEXT
Ex:

EXAMPLE: COUNTING LETTERS

HELLO

HELLO, WELCOME TO DISCRETEMATH!

BACK NEXT
EX:

Runtimes Can Vary

Discretemath

This sentence has a D

I Like Discretemath!

-Focus on Worst Case!

BACK NEXT
BIG O

BIG 'O' NOTATION

DESCRIBES THE GROWTH BEHAVIOR OR


"ORDER" OF A FUNCTION.

EX: O(N) - N OPERATIONS (LINEAR)


ROUGH UPPER BOUND.

BACK NEXT
GRAPH

# COMPUTATIONS

Constant- 0 (1)
INPUT SIZE N

BACK NEXT
DESCRIPTION

Constant O(1)

Runtime does not depend on input size.

Example: Look up first item

[1, 2, 5]

[1, 3, 5, 6, 7, 8, 9, 11, 15, 19, 21]

BACK NEXT
GRAPH

# COMPUTATIONS

Logarithmic - 0 (log(n))

Constant- 0 (1)
INPUT SIZE N

BACK NEXT
DESCRIPTION

Logarithmic - O(log(n))
Runtime grows slower than input size.
Example: Binary Search

BACK NEXT
GRAPH

# COMPUTATIONS
Linear - 0(n)

Logarithmic - 0(log(n))

Constant- 0(1)
INPUT SIZE N

BACK NEXT
DESCRIPTION

Linear - O(n)

Runtime grows at the same rate as input.

Example: Unsorted list search

BACK NEXT
GRAPH

# COMPUTATIONS
Log-Linear - 0(n log(n))

Linear - 0(n)

Logarithmic - 0(log(n))

Constant- 0(1)
INPUT SIZE N

BACK NEXT
DESCRIPTION

Log-Linear - O(n * log(n))


An operation of log(n) complexity for
each input value.
Example: Efficient Sorting

BACK NEXT
GRAPH

Quadratic - O (n^2)

# COMPUTATIONS
Log-Linear - 0(n log(n))

Linear - 0(n)

Logarithmic - 0(log(n))

Constant- 0(1)
INPUT SIZE N

BACK NEXT
DESCRIPTION

Quadratic - O(n^2)

An operation of complexity O(n) is


carried out for each input.
Example: Check all pairs of input
values. (Double for loop)

BACK NEXT
GRAPH

Quadratic - O (n^2)

# COMPUTATIONS
Log-Linear - 0(n log(n))

..
)..
^3
Linear - 0(n)

(n
O
- l
ia
m
no
ly
Po
Logarithmic - 0(log(n))

Constant- 0(1)
INPUT SIZE N

BACK NEXT
DESCRIPTION

Polynomial - O(n^3)...

Computations with other exponents


(n^3, n^4, etc.)
Example: Check all triplets of input
values. (Triple for loop)

BACK NEXT
GRAPH

Exponential - O(2^n)

Quadratic - O pi(n^2)

# COMPUTATIONS
Log-Linear - O(n log(n))

..
)..
^3
Linear - O(n)

(n
O
- l
ia
m
no
ly
Po
Logarithmic - O(log(n))

Constant- O(1)
INPUT SIZE N

BACK NEXT
DESCRIPTION

Exponential - O(2^n)

Complexity is multiplied (doubled,


tripled, etc.) with each additional
input value.
Ex: Recursive algorithms
Traveling salesman
BACK NEXT
GRAPH

Worse:
O(n!)
Exponential - O(2^n)

Quadratic - O pi(n^2)

# COMPUTATIONS
Log-Linear - O(n log(n))

..
)..
^3
Linear - O(n)

(n
O
-l
ia
m
no
ly
Po
Logarithmic - O(log(n))

Constant- O(1)
INPUT SIZE N

BACK NEXT
DESCRIPTION

Worse: O(n!)

Runtimes can be worse than


exponential.

Ex: Permutations.
Runtimes can be infinite.
BACK NEXT
Multiple Input Dimensions

Inputs of size n and m. Complexity


may depend on both: O(m * n)
Example: 2 dimensional data (matrix)
operations

BACK NEXT
Complexity Implications

Code implementation can have a


practical impact.
Analyzing runtime and refactoring is
useful.
Some problems are hard (intractable).
BACK NEXT
Considerations

Practical vs theoretical implications


Suboptimal solutions (heuristics) may
be good enough.
Better technology helps.
Memory complexity
BACK NEXT

You might also like