Analysis of Algorithms1 Running Time Pseudo-Code Analysis of Algorithms Asymptotic Notation Asymptotic Analysis Mathematical facts.

Slides:



Advertisements
Similar presentations
Analysis of Algorithms
Advertisements

CSC401 – Analysis of Algorithms Lecture Notes 1 Introduction
Analysis of Algorithms1 Running Time Pseudo-Code Analysis of Algorithms Asymptotic Notation Asymptotic Analysis Mathematical facts COMP-2001 L4&5 Portions.
© 2004 Goodrich, Tamassia 1 Lecture 01 Algorithm Analysis Topics Basic concepts Theoretical Analysis Concept of big-oh Choose lower order algorithms Relatives.
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 Algorithms1 CS5302 Data Structures and Algorithms Lecturer: Lusheng Wang Office: Y6416 Phone:
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
Analysis of Algorithms (pt 2) (Chapter 4) COMP53 Oct 3, 2007.
Fall 2006CSC311: Data Structures1 Chapter 4 Analysis Tools Objectives –Experiment analysis of algorithms and limitations –Theoretical Analysis of algorithms.
Introduction to Analysis of Algorithms Prof. Thomas Costello (reorganized by Prof. Karen Daniels)
The Seven Functions. Analysis of Algorithms. Simple Justification Techniques. 2 CPSC 3200 University of Tennessee at Chattanooga – Summer Goodrich,
Analysis of Algorithms1 CS5302 Data Structures and Algorithms Lecturer: Lusheng Wang Office: Y6416 Phone:
PSU CS 311 – Algorithm Design and Analysis Dr. Mohamed Tounsi 1 CS 311 Design and Algorithms Analysis Dr. Mohamed Tounsi
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 Lecture 2
Analysis of Algorithms
CSCE 3110 Data Structures & Algorithm Analysis Algorithm Analysis I Reading: Weiss, chap.2.
Data Structures & AlgorithmsIT 0501 Algorithm Analysis I.
CSCE 3110 Data Structures & Algorithm Analysis Rada Mihalcea Algorithm Analysis II Reading: Weiss, chap. 2.
Introduction Data Structures & Algorithm Data Structures & Algorithm.
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.
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.
1 Analysis of Algorithms CS 105 Introduction to Data Structures and Algorithms.
Grading Exams 60 % Lab 20 % Participation 5% Quizes 15%
1 Dr. J. Michael Moore Data Structures and Algorithms CSCE 221 Adapted from slides provided with the textbook, Nancy Amato, and Scott Schaefer.
CSC401 – Analysis of Algorithms Chapter 1 Algorithm Analysis Objectives: Introduce algorithm and algorithm analysis Discuss algorithm analysis methodologies.
COMP 2402/2002 Abstract Data Types and Algorithms Prof: Office: Office hours: Eduardo Mesa HP 5347 Tuesday and Thursday 4:30pm.
CSC401 – Analysis of Algorithms Lecture Notes 2 Asymptotic Analysis Objectives: Mathematics foundation for algorithm analysis Amortization analysis techniques.
Analysis of Algorithms Algorithm Input Output An algorithm is a step-by-step procedure for solving a problem in a finite amount of time.
Analysis of Algorithms Algorithm Input Output © 2010 Goodrich, Tamassia1Analysis of Algorithms.
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.
Lecture aid 1 Devon M. Simmonds University of North Carolina, Wilmington CSC231 Data Structures.
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.
Data Structures I (CPCS-204) Week # 2: Algorithm Analysis tools Dr. Omar Batarfi Dr. Yahya Dahab Dr. Imtiaz Khan.
(Complexity) Analysis of Algorithms Algorithm Input Output 1Analysis of Algorithms.
Analysis of Algorithms
Analysis of Algorithms
COMP9024: Data Structures and Algorithms
COMP9024: Data Structures and Algorithms
GC 211:Data Structures Week 2: Algorithm Analysis Tools
Data Structures and Algorithms
Analysis of Algorithms
COMP9024: Data Structures and Algorithms
Lecture 3 of Computer Science II
Analysis of Algorithms
Analysis of Algorithms
Analysis of Algorithms
Analysis of Algorithms
Analysis of Algorithms
Analysis of Algorithms
Analysis of Algorithms
Analysis of Algorithms
Analysis of Algorithms
Analysis of Algorithms
CS210- Lecture 2 Jun 2, 2005 Announcements Questions
Analysis of Algorithms
Presentation transcript:

Analysis of Algorithms1 Running Time Pseudo-Code Analysis of Algorithms Asymptotic Notation Asymptotic Analysis Mathematical facts

Analysis of Algorithms2 Average Case vs. Worst Case Running Timeof an algorithm An algorithm may run faster on certain data sets than on others. Finding the average case can be very difficult, so typically algorithms are measured by the worst-case time complexity. Also, in certain application domains (e.g., air traffic control, surgery, IP lookup) knowing the worst-case time complexity is of crucial importance.

Analysis of Algorithms3 Measuring the Running Time How should we measure the running time of an algorithm? Approach 1: Experimental Study –Write a program that implements the algorithm –Run the program with data sets of varying size and composition. –Use a method like System.currentTimeMillis() to get an accurate measure of the actual running time.

Analysis of Algorithms4 Beyond Experimental Studies Experimental studies have several limitations: –It is necessary to implement and test the algorithm in order to determine its running time. –Experiments can be done only on a limited set of inputs, and may not be indicative of the running time on other inputs not included in the experiment. –In order to compare two algorithms, the same hardware and software environments should be used.

Analysis of Algorithms5 Beyond Experimental Studies We will now develop a general methodology for analyzing the running time of algorithms. In contrast to the "experimental approach", this methodology: –Uses a high-level description of the algorithm instead of testing one of its implementations. –Takes into account all possible inputs. –Allows one to evaluate the efficiency of any algorithm in a way that is independent from the hardware and software environment.

Analysis of Algorithms6 Pseudo-Code Pseudo-code is a description of an algorithm that is more structured than usual prose but less formal than a programming language. Example: finding the maximum element of an array. Algorithm arrayMax(A, n): Input: An array A storing n integers. Output: The maximum element in A. currentMax  A[0] for i  1 to n -1 do if currentMax < A[i] then currentMax  A[i] return currentMax Pseudo-code is our preferred notation for describing algorithms. However, pseudo-code hides program design issues.

Analysis of Algorithms7 What is Pseudo-Code ? A mixture of natural language and high-level programming concepts that describes the main ideas behind a generic implementation of a data structure or algorithm. -Expressions: use standard mathematical symbols to describe numeric and boolean expressions -use  for assignment (“=” in Java) -use = for the equality relationship (“==” in Java) -Method Declarations: -Algorithm name(param1, param2) - Programming Constructs: - decision structures:if... then... [else... ] - while-loops: while... do - repeat-loops: repeat... until... - for-loop: for... do - array indexing: A[i] - Methods: - calls: object method(args) - returns:return value

8 Analysis of Algorithms Primitive Operations: Low-level computations independent from the programming language can be identified in pseudocode. Examples: –calling a method and returning from a method –arithmetic operations (e.g. addition) –comparing two numbers, etc. By inspecting the pseudo-code, we can count the number of primitive operations executed by an algorithm.

Analysis of Algorithms9 Example: Algorithm arrayMax(A, n): Input: An array A storing n integers. Output: The maximum element in A. currentMax ¨ A[0] for i ¨ 1 to n -1 do if currentMax < A[i] then currentMax  A[i] return currentMax

Analysis of Algorithms10 Asymptotic Notation Goal: to simplify analysis by getting rid of unneeded information (like “rounding” 1,000,001≈1,000,000) We want to say in a formal way 3n 2 ≈ n 2 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 n 0 such that f(n)≤ c g(n) for n ≥ n 0

Analysis of Algorithms11 Example For functions f(n) and g(n) (to the right) there are positive constants c and n 0 such that: f(n)≤c g(n) for n ≥ n 0 conclusion: 2n+6 is O(n).

Analysis of Algorithms12 Another Example On the other hand… n 2 is not O(n) because there is no c and n 0 such that: n 2 ≤ cn for n ≥ n 0 (As the graph to the right illustrates, no matter how large a c is chosen there is an n big enough that n 2 >cn ).

Analysis of Algorithms13 Asymptotic Notation (cont.) Note: Even though it is correct to say “7n - 3 is O(n 3 )”, a better statement is “7n - 3 is O(n)”, that is, one should make the approximation as tight as possible Simple Rule: Drop lower order terms and constant factors 7n-3 is O(n) 8n 2 log n + 5n 2 + n is O(n 2 log n)

Analysis of Algorithms14 Asymptotic Notation (terminology) Special classes of algorithms: logarithmic:O(log n) linear:O(n) quadratic:O(n 2 ) polynomial:O(n k ), k ≥ 1 exponential:O(a n ), n > 1 “Relatives” of the Big-Oh –  (f(n)): Big Omega--asymptotic lower bound –  (f(n)): Big Theta--asymptotic tight bound

15 Asymptotic Analysis of The Running Time Use the Big-Oh notation to express the number of primitive operations executed as a function of the input size. For example, we say that the arrayMax algorithm runs in O(n) time. Comparing the asymptotic running time -an algorithm that runs in O(n) time is better than one that runs in O(n 2 ) time -similarly, O(log n) is better than O(n) -hierarchy of functions: log n << n << n 2 << n 3 << 2n Caution! Beware of very large constant factors. An algorithm running in time 1,000,000 n is still O(n) but might be less efficient on your data set than one running in time 2n 2, which is O(n 2 )

16 Example of Asymptotic Analysis An algorithm for computing prefix averages 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 a  0 for j  0 to i do a  a + X[j] A[i]  a/(i+ 1) return array A Analysis... 1 step i iterations with i=0,1,2...n-1 n iterations

Analysis of Algorithms17 Another Example A better algorithm for computing prefix averages: 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 Analysis...

Analysis of Algorithms18 Math You Need to Review Logarithms and Exponents (Appendix A, p.617) properties of logarithms: log b (xy) = log b x + log b y log b (x/y) = log b x - log b y log b xa = alog b x log b a=log x a/log x b properties of exponentials: a (b+c) = a b a c a bc = (a b ) c a b /a c = a (b-c) b = a log a b b c = a c*log a b

Analysis of Algorithms19 More Math to Review Floor:  x  = the largest integer ≤ x Ceiling:  x  = the smallest integer ≥ x Summations: (see Appendix A, p.619) Geometric progression: (see Appendix A, p.620)