Data Structures I (CPCS-204) Week # 2: Algorithm Analysis tools Dr. Omar Batarfi Dr. Yahya Dahab Dr. Imtiaz Khan.

Slides:



Advertisements
Similar presentations
Razdan with contribution from others 1 Algorithm Analysis What is the Big ‘O Bout? Anshuman Razdan Div of Computing.
Advertisements

Fall 2006CENG 7071 Algorithm Analysis. Fall 2006CENG 7072 Algorithmic Performance There are two aspects of algorithmic performance: Time Instructions.
CSC401 – Analysis of Algorithms Lecture Notes 1 Introduction
© 2004 Goodrich, Tamassia 1 Lecture 01 Algorithm Analysis Topics Basic concepts Theoretical Analysis Concept of big-oh Choose lower order algorithms Relatives.
Introduction to Analysis of Algorithms
Analysis of Algorithms Algorithm Input Output. Analysis of Algorithms2 Outline and Reading Running time (§1.1) Pseudo-code (§1.1) Counting primitive operations.
Complexity Analysis (Part I)
Analysis of Algorithms (Chapter 4)
Analysis of Algorithms1 Estimate the running time Estimate the memory space required. Time and space depend on the input size.
Analysis of Algorithms
Cmpt-225 Algorithm Efficiency.
Fall 2006CSC311: Data Structures1 Chapter 4 Analysis Tools Objectives –Experiment analysis of algorithms and limitations –Theoretical Analysis of algorithms.
Analysis of Algorithms COMP171 Fall Analysis of Algorithms / Slide 2 Introduction * What is Algorithm? n a clearly specified set of simple instructions.
Algorithm Analysis (Big O)
Analysis of Performance
CS2210 Data Structures and Algorithms Lecture 2:
Analysis of Algorithms Algorithm Input Output © 2014 Goodrich, Tamassia, Goldwasser1Analysis of Algorithms Presentation for use with the textbook Data.
Analysis of Algorithms
Week 2 CS 361: Advanced Data Structures and Algorithms
Analysis Tools Jyh-Shing Roger Jang ( 張智星 ) CSIE Dept, National Taiwan University.
Algorithm Efficiency CS 110: Data Structures and Algorithms First Semester,
Analysis of Algorithms
Analysis of Algorithms1 The Goal of the Course Design “good” data structures and algorithms Data structure is a systematic way of organizing and accessing.
CSC 201 Analysis and Design of Algorithms Lecture 04: CSC 201 Analysis and Design of Algorithms Lecture 04: Time complexity analysis in form of Big-Oh.
Algorithm Input Output An algorithm is a step-by-step procedure for solving a problem in a finite amount of time. Chapter 4. Algorithm Analysis (complexity)
Data Structures Lecture 8 Fang Yu Department of Management Information Systems National Chengchi University Fall 2010.
Analysis of Algorithms
Program Efficiency & Complexity Analysis. Algorithm Review An algorithm is a definite procedure for solving a problem in finite number of steps Algorithm.
Chapter 5 Algorithms (2) Introduction to CS 1 st Semester, 2015 Sanghyun Park.
Introduction to Analysis of Algorithms CS342 S2004.
Analysis of Algorithms Algorithm Input Output © 2010 Goodrich, Tamassia1Analysis of Algorithms.
Algorithm Analysis Part of slides are borrowed from UST.
Analysis of algorithms. What are we going to learn? Need to say that some algorithms are “better” than others Criteria for evaluation Structure of programs.
CSC Devon M. Simmonds University of North Carolina, Wilmington CSC231 Data Structures.
David Luebke 1 1/6/2016 CS 332: Algorithms Asymptotic Performance.
Algorithm Analysis (Big O)
Announcement We will have a 10 minutes Quiz on Feb. 4 at the end of the lecture. The quiz is about Big O notation. The weight of this quiz is 3% (please.
GC 211:Data Structures Week 2: Algorithm Analysis Tools Slides are borrowed from Mr. Mohammad Alqahtani.
1 COMP9024: Data Structures and Algorithms Week Two: Analysis of Algorithms Hui Wu Session 2, 2014
Analysis of Algorithms Algorithm Input Output © 2014 Goodrich, Tamassia, Goldwasser1Analysis of Algorithms Presentation for use with the textbook Data.
(Complexity) Analysis of Algorithms Algorithm Input Output 1Analysis of Algorithms.
Algorithm Analysis 1.
Analysis of Algorithms
COMP9024: Data Structures and Algorithms
COMP9024: Data Structures and Algorithms
Analysis of Algorithms
GC 211:Data Structures Week 2: Algorithm Analysis Tools
Introduction to Algorithms
GC 211:Data Structures Algorithm Analysis Tools
Analysis of Algorithms
COMP9024: Data Structures and Algorithms
Analysis of Algorithms
Analysis of Algorithms
Data Structures (CS212D) Overview & Review.
Analysis of Algorithms
Algorithm Analysis (not included in any exams!)
Analysis of Algorithms
GC 211:Data Structures Algorithm Analysis Tools
CSC 413/513: Intro to Algorithms
Analysis of Algorithms
Analysis of Algorithms
Analysis of Algorithms
Analysis of Algorithms
GC 211:Data Structures Algorithm Analysis Tools
Data Structures (CS212D) Overview & Review.
Performance Evaluation
Analysis of Algorithms
CS210- Lecture 2 Jun 2, 2005 Announcements Questions
Analysis of Algorithms
Presentation transcript:

Data Structures I (CPCS-204) Week # 2: Algorithm Analysis tools Dr. Omar Batarfi Dr. Yahya Dahab Dr. Imtiaz Khan

Algorithm Analysis: Motivation  A problem can be solved in many different ways  Single problem, many algorithms  Which of the several algorithms should I choose?  We use algorithm analysis to answer this question o Writing a working program is not good enough o The program may be inefficient! o If the program runs on a large data set, then the running time becomes an issue

What is algorithm analysis?  A methodology to predict the resources that the algorithm requires  Computer memory  Computational time  We’ll focus on computational time  It does not mean memory is not important  Generally, there is a trade-off between the two factors o Space-time trade-off is a common term

How to analyse algorithms?  Experimental Approach  Implement algorithms as programs and run them on computers  Not a good approach, though! o Results only for a limited set of test inputs o Difficult comparisons due to the experiment environments (need the same computers, same operating systems, etc.) o Full implementation and execution of an algorithm  We need an approach which allows us to avoid experimental study

How to analyse algorithms?  Theoretical Approach  General methodology for analysing the running time o Considers all possible inputs o Evaluates algorithms in a way that is independent from the hardware and software environments o Analyses an algorithm without implementing it  Count only primitive operations used in an algorithm  Associate each algorithm with a function f(n) that characterises the running time of the algorithm as a function of the input size n o A good approximation of the total number of primitive operations

Primitive Operations  Basic computations performed by an algorithm  Each operation corresponding to a low-level instruction with a constant execution time  Largely independent from the programming language  Examples  Evaluating an expression ( x + y )  Assigning a value to a variable ( x ←5 )  Comparing two numbers ( x < y )  Indexing into an array ( A[i] )  Calling a method ( mycalculator.sum() )  Returning from a method ( return result )

Counting Primitive Operations  Total number of primitive operations executed  is the running time of an algorithms  is a function of the input size  Example Algorithm ArrayMax(A, n) # operations currentMax ←A[0] 2: (1 +1) for i←1;i<n; i←i+1 do 3n-1: (1 + n+2(n- 1)) if A[i]>currentMax then 2(n − 1) currentMax ←A[i] 2(n − 1) endif endfor return currentMax 1 Total: 7n − 2

Algorithm efficiency: growth rate  An algorithm’s time requirements can be expressed as a function of (problem) input size  Problem size depends on the particular problem:  For a search problem, the problem size is the number of elements in the search space  For a sorting problem, the problem size is the number of elements in the given list  How quickly the time of an algorithm grows as a function of problem size -- this is often called an algorithm’s growth rate

Algorithm growth rate Which algorithm is the most efficient? [The one with the growth rate Log N.]

Algorithmic time complexity  Rather than counting the exact number of primitive operations, we approximate the runtime of an algorithm as a function of data size – time complexity  Algorithms A, B, C and D (previous slide) belong to different complexity classes  We’ll not cover complexity classes in detail – they will be covered in Algorithm Analysis course, in a later semester  We’ll briefly discuss seven basic functions which are often used in complexity analysis

Seven basic function 1.Constant function f(n) = c 2.Linear function f(n) = n 3.Quadratic function f(n) = n 2 4.Cubic function f(n) = n 3 5.Log function f(n) = log n 6.Log linear function f(n) = n log n 7.Exponential function f(n) = b n

Constant function  For a given argument/variable n, the function always returns a constant value  It is independent of variable n  It is commonly used to approximate the total number of primitive operations in an algorithm  Most common constant function is g(n) = 1  Any constant value c can be expressed as constant function f(n) = c.g(1)

Linear function  For a given argument/variable n, the function always returns n  This function arises in algorithm analysis any time we have to do a single basic operation over each of n elements  For example, finding min/max value in a list of values  Time complexity of linear/sequential search algorithm is linear

Quadratic function  For a given argument/variable n, the function always returns square of n  This function arises in algorithm analysis any time we use nested loops  The outer loop performs primitive operations in linear time; for each iteration, the inner loop also perform primitive operations in linear time  For example, sorting an array in ascending/descending order using Bubble Sort (more later on)  Time complexity of most algorithms is quadratic

Cubic function  For a given argument/variable n, the function always returns n x n x n  This function is very rarely used in algorithm analysis  Rather, a more general class “polynomial” is often used o f(n) = a 0 + a 1 n + a 2 n 2 + a 3 n 3 + … + a d n d

Logarithmic function  For a given argument/variable n, the function always returns logarithmic value of n  Generally, it is written as f(n) = log b n, where b is base which is often 2  This function is also very common in algorithm analysis  We normally approximate the log b n to a value x. x is number of times n is divided by b until the division results in a number less than or equal to 1  log 3 27 is 3, since 27/3/3/3 = 1.  log 4 64 is 3, since 64/4/4/4 = 1  log 2 12 is 4, since 12/2/2/2/2 = 0.75 ≤ 1

Log linear function  For a given argument/variable n, the function always returns n log n  Generally, it is written as f(n) = n log b n, where b is base which is often 2  This function is also common in algorithm analysis  Growth rate of log linear function is faster as compared to linear and log functions

Exponential function  For a given argument/variable n, the function always returns b n, where b is base and n is power (exponent)  This function is also common in algorithm analysis  Growth rate of exponential function is faster than all other functions

Algorithmic runtime  Worst-case running time  measures the maximum number of primitive operations executed  The worst case can occur fairly often o e.g. in searching a database for a particular piece of information  Best-case running time  measures the minimum number of primitive operations executed o Finding a value in a list, where the value is at the first position o Sorting a list of values, where values are already in desired order  Average-case running time  the efficiency averaged on all possible inputs  maybe difficult to define what “average” means

Complexity classes  Suppose the execution time of algorithm A is a quadratic function of n (i.e. an 2 + bn + c )  Suppose the execution time of algorithm B is a linear function of n (i.e. an + b )  Suppose the execution time of algorithm C is a an exponential function of n (i.e. a2 n )  For large problems higher order terms dominate the rest  These three algorithms belong to three different “complexity classes”

Big-O and function growth rate  We use a convention O-notation (also called Big- Oh) to represent different complexity classes  The statement “f(n) is O(g(n))” means that the growth rate of f(n) is no more than the growth rate of g(n)  g(n) is an upper bound on f(n), i.e. maximum number of primitive operations  We can use the big-O notation to rank functions according to their growth rate

22 Big-O: functions ranking O(1) constant time O(log n) log time O(n) linear time O(n log n) log linear time O(n 2 ) quadratic time O(n 3 ) cubic time O(2 n ) exponential time BETTER WORSE

Simplifications  Keep just one term  the fastest growing term (dominates the runtime)  No constant coefficients are kept  Constant coefficients affected by machines, languages, etc  Asymptotic behavior (as n gets large) is determined entirely by the dominating term  Example: T(n) = 10 n 3 + n n o If n = 1,000, then T(n) = 10,001,040,800 o error is 0.01% if we drop all but the n 3 (the dominating) term

Big Oh: some examples  n 3 – 3n = O(n 3 )  1 + 4n = O(n)  7n n + 3 = O(n 2 )  2 n + 10n + 3 = O(2 n )

Big O: more examples  f(n) = 7n – 2;7n - 2 is O(n) ? Find c > 0 and n0 ≥ 1 such that 7n-2 ≤ cn for n ≥ n 0 This is true for c = 7 and n0 = 1 at n = 1, 7-2 ≤ 7; at n = 2, 14 – 2 ≤ 14, and so on  f(n) = 3 log n + 5;3 log n + 5 is O(log n) ? Find c > 0 and n 0 ≥ 1 such that 3 log n + 5 ≤ clog n for n ≥ n 0 This is true for c = 8 and n 0 = 2

Interpreting Big-O  f(n) is less than or equal to g(n) up to a constant factor and in the asymptotic sense as n approaching infinity (n→∞)  The big-O notation gives an upper bound on the growth rate of a function  The big-O notation allows us to  ignore constant factors and lower order terms  focus on the main components of a function that effect the growth  ignoring constants and lower order terms does not change the “complexity class” – it’s very important to remember

Asymptotic algorithm analysis  Determines the running time in big-O notation  Asymptotic analysis  find the worst-case number of primitives  operations executed as a function of the input size  express this function with big-O notation  Example:  algorithm arrayMax executes at most 7n − 2primitive operations  algorithm arrayMax runs in O(n) time

Practice  Express the following functions in terms of Big-O notation (a, b and c are constants) 1.f(n) = an 2 + bn + c 2.f(n) = 2 n + n log n + c 3.f(n) = n log n + b log n + c

Outlook Next week, we’ll discuss arrays and searching algorithms