Scribd
Upload
37 views

Analysis and Design of Algorithm-2

The document discusses algorithm analysis and asymptotic notation. It introduces Big-O notation to characterize algorithms based on problem size. Common time complexities like constant, linear, quadratic, and exponential functions are described. Examples are provided to illustrate Big-O, Big-Omega, and Big-Theta notation. The properties and relationships between different asymptotic notations are outlined. Key concepts in analyzing recursive algorithms like repeated substitution and telescoping are explained.

Uploaded by

renuka05sharma
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
37 views

Analysis and Design of Algorithm-2

The document discusses algorithm analysis and asymptotic notation. It introduces Big-O notation to characterize algorithms based on problem size. Common time complexities like constant, linear, quadratic, and exponential functions are described. Examples are provided to illustrate Big-O, Big-Omega, and Big-Theta notation. The properties and relationships between different asymptotic notations are outlined. Key concepts in analyzing recursive algorithms like repeated substitution and telescoping are explained.

Uploaded by

renuka05sharma
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 29

Analysis and Design of Algorithm-2

Last Time
Steps in problem solving Algorithm analysis
Space complexity Time complexity Pseudo-code

Algorithm Analysis
Last time:
Experimental approach problems Low level analysis count operations

Abstract even further Characterize an algorithm as a function of the problem size E.g.
Input data = array problem size is N (length of array) Input data = matrix problem size is N x M

Asymptotic Notation
Goal: to simplify analysis by getting rid of unneeded information (like rounding 1,000,0011,000,000) We want to say in a formal way 3n2 n2 The Big-Oh Notation:
given functions f(n) and g(n), we say that f(n) is O(g(n)) if and only if there are positive constants c and n0 such that f(n) c g(n) for n n0

Graphic Illustration
f(n) = 2n + 6

f(n) = 2n+6 Conf. def:


Need to find a function g(n) and a const. c such as f(n) < cg(n) c g(n) = 4n

g(n) = n and c = 4 f(n) is O(n) The order of f(n) is n

g(n) = n n

More examples
What about f(n) = 4n2 ? Is it O(n)?
Find a c such that 4n2 < cn for any n > n0

50n3 + 20n + 4 is O(n3)


Would be correct to say is O(n3+n)
Not useful, as n3 exceeds by far n, for large values

Would be correct to say is O(n5)


OK, but g(n) should be as closed as possible to f(n)

3log(n) + log (log (n)) = O( ? ) Simple Rule: Drop lower order terms and constant factors

Properties of Big-Oh
If f(n) is O(g(n)) then af(n) is O(g(n)) for any a. If f(n) is O(g(n)) and h(n) is O(g(n)) then f(n)+h(n) is O(g(n)+g(n)) If f(n) is O(g(n)) and h(n) is O(g(n)) then f(n)h(n) is O(g(n)g(n)) If f(n) is O(g(n)) and g(n) is O(h(n)) then f(n) is O(h(n)) If f(n) is a polynomial of degree d , then f(n) is O(nd) nx = O(an), for any fixed x > 0 and a > 1
An algorithm of order n to a certain power is better than an algorithm of order a ( > 1) to the power of n

log nx is O(log n), fox x > 0 how? log x n is O(ny) for x > 0 and y > 0
An algorithm of order log n (to a certain power) is better than an algorithm of n raised to a power y.

Asymptotic analysis terminology


Special classes of algorithms:
logarithmic: linear: quadratic: polynomial: exponential: O(log n) O(n) O(n2) O(nk), k 1 O(an), n > 1

Polynomial vs. exponential ? Logarithmic vs. polynomial ?

Some Numbers

log n 0 1 2 3 4 5

n 1 2 4 8 16 32

n log n 0 2 8 24 64 160

n2 1 4 16 64 256 1024

n3

2n

1 2 8 4 64 16 512 256 4096 65536 32768 4294967296

Relatives of Big-Oh
Relatives of the Big-Oh
(f(n)): Big Omega asymptotic lower bound (f(n)): Big Theta asymptotic tight bound Big-Omega think of it as the inverse of O(n) g(n) is (f(n)) if f(n) is O(g(n)) Big-Theta combine both Big-Oh and Big-Omega f(n) is (g(n)) if f(n) is O(g(n)) and g(n) is (f(n)) Make the difference: 3n+3 is O(n) and is (n) 3n+3 is O(n2) but is not (n2)

More relatives
Little-oh f(n) is o(g(n)) if for any c>0 there is n0 such that f(n) < c(g(n)) for n > n0. Little-omega Little-theta 2n+3 is o(n2) 2n + 3 is o(n) ?

Example
Remember the algorithm for computing prefix averages - compute an array A starting with an array X - every element A[i] is the average of all elements X[j] with j < i

Remember some pseudo-code Solution 1


Algorithm prefixAverages1(X): Input: An n-element array X of numbers. Output: An n -element array A of numbers such that A[i] is the average of elements X[0], ... , X[i].
Let A be an array of n numbers. for i 0 to n - 1 do a0 for j 0 to i do Analyze a a + X[j] A[i] a/(i+ 1) return array A

this

Example (contd)
Algorithm prefixAverages2(X): Input: An n-element array X of numbers. Output: An n -element array A of numbers such that A[i] is the average of elements X[0], ... , X[i].
Let A be an array of n numbers. s 0 for i 0 to n do s s + X[i] A[i] s/(i+ 1) return array A

Back to the original question


Which solution would you choose?
O(n2) vs. O(n)

Some math properties of logarithms:


logb(xy) = logbx + logby logb (x/y) = logbx - logby logbxa = alogbx logba= logxa/logxb

properties of exponentials:
a(b+c) = aba c abc = (ab)c ab /ac = a(b-c) b = a logab bc = a c*logab

Important Series
S ( N ) = 1 2 N = i = N (1 N ) / 2
i =1
2

Sum of squares: Sum of exponents: Geometric series:

N ( N 1)( 2 N 1) N 3 for large N i = 6 3 i =1


N

N k 1 i | k 1 | for large N and k -1 i =1


N k

Special case when A = 2

A N 1 1 A = A 1 i =0
N i

20 + 21 + 22 + + 2N = 2N+1 - 1

Analyzing recursive algorithms


function foo (param A, param B) {
statement 1; statement 2; if (termination condition) {
return;

foo(A, B);

Solving recursive equations by repeated substitution


T(n) = = = = = = T(n/2) + c T(n/4) + c + c T(n/8) + c + c + c T(n/23) + 3c T(n/2k) + kc substitute for T(n/2) substitute for T(n/4)
in more compact form inductive leap

T(n)

= T(n/2logn) + clogn choose k = logn = T(n/n) + clogn = T(1) + clogn = b + clogn = (logn)

Solving recursive equations by telescoping


T(n) = T(n/2) + c T(n/4) + c T(n/8) + c T(n/16) + c T(2) + c T(1) + c T(1) + clogn initial equation so this holds and this and this eventually and this sum equations, canceling the terms appearing on both sides

T(n/2) = T(n/4) = T(n/8) = T(4) = T(2) = T(n) = T(n)

= (logn)

Problem
Running time for finding a number in a sorted array [binary search]
Pseudo-code Running time analysis

ADT
ADT = Abstract Data Types A logical view of the data objects together with specifications of the operations required to create and manipulate them. Describe an algorithm pseudo-code Describe a data structure ADT

What is a data type?


A set of objects, each called an instance of the data type. Some objects are sufficiently important to be provided with a special name. A set of operations. Operations can be realized via operators, functions, procedures, methods, and special syntax (depending on the implementing language) Each object must have some representation (not necessarily known to the user of the data type) Each operation must have some implementation (also not necessarily known to the user of the data type)

What is a representation?
A specific encoding of an instance This encoding MUST be known to implementors of the data type but NEED NOT be known to users of the data type Terminology: "we implement data types using data structures

Two varieties of data types


Opaque data types in which the representation is not known to the user. Transparent data types in which the representation is profitably known to the user:- i.e. the encoding is directly accessible and/or modifiable by the user. Which one you think is better? What are the means provided by C++ for creating opaque data types?

Why are opaque data types better?


Representation can be changed without affecting user Forces the program designer to consider the operations more carefully Encapsulates the operations Allows less restrictive designs which are easier to extend and modify Design always done with the expectation that the data type will be placed in a library of types available to all.

How to design a data type Step 1: Specification


Make a list of the operations (just their names) you think you will need. Review and refine the list. Decide on any constants which may be required. Describe the parameters of the operations in detail. Describe the semantics of the operations (what they do) as precisely as possible.

How to design a data type Step 2: Application


Develop a real or imaginary application to test the specification. Missing or incomplete operations are found as a side-effect of trying to use the specification.

How to design a data type Step 3: Implementation


Decide on a suitable representation. Implement the operations. Test, debug, and revise.

Example - ADT Integer


Name of ADT Operation Create Integer Description Defines an identifier with an undefined value Assigns the value of one integer identifier or value to another integer identifier Returns true if the values associated with two integer identifiers are the same C/C++ int id1; id1 = id2;

Assign

isEqual

id1 == id2;

Example ADT Integer


LessThan Returns true if an identifier integer is less than the value of the second integer identifier Returns the negative of the integer value Returns the sum of two integer values

id1<id2
-id1 id1+id2

Negative Sum

Operation Signatures Create: identifier Integer Assign: Integer Identifier IsEqual: (Integer,Integer) Boolean LessThan: (Integer,Integer) Boolean Negative: Integer Integer Sum: (Integer,Integer) Integer

You might also like