the efficiency of algorithms chapter 9 slides by steve armstrong letourneau university longview, tx ...

The Efficiency of Algorithms

Chapter 9

Slides by Steve ArmstrongLeTourneau University

Longview, TX2007,Prentice Hall

Carrano, Data Structures and Abstractions with Java, Second Edition, (c) 2007 Pearson Education, Inc. All rights reserved. 0-13-237045-X

Chapter Contents

• Motivation• Measuring an Algorithm's Efficiency

Big Oh Notation

• Formalities• Picturing Efficiency• The Efficiency of Implementations of the ADT

List An Array-Based Implementation A Linked Implementation Comparing Implementations


Motivation 1

• Even a simple program can be noticeably inefficient

• When the 423 is changed to 100,000,000 there is a significant delay in seeing the result


Motivation

• We seek the design of a Java class Huge to represent extremely large integers.

• Consider an inefficient approach to add numbers that result in a large sum View source code

• Even a simple program can be noticeably inefficient


Measuring Algorithm Efficiency 6

• Types of complexity Space complexity Time complexity

• Analysis of algorithms The measuring of the complexity of an

algorithm

• Cannot compute actual time for an algorithm We usually measure worst-case time



Fig. 9-1 Three algorithms for computing 1 + 2 + … n for an integer n > 0


Measuring Algorithm Efficiency

Fig. 9-2 The number of operations required by the algorithms for Fig 9-1



Fig. 9-3 The number of operations required by the algorithms in Fig. 9-1 as a function of n


Big Oh Notation 12

• To say "Algorithm A has a worst-case time requirement proportional to n" We say A is O(n) Read "Big Oh of n"

• For the other two algorithms Algorithm B is O(n2) Algorithm C is O(1)


Big Oh Notation 15

Fig. 9-4 Typical growth-rate functions evaluated at increasing values of n


Big Oh Notation 16

Fig. 9-5 The number of digits in an integer n compared with the integer portion of log10n


Big Oh Notation

Fig. 9-6 The values of two logarithmic growth-rate functions for various ranges of n.


Formalities 17

• Formal definition of Big OhAn algorithm's time requirement f(n) is of order at most g(n) f(n) = O(g(n)) For a positive real number c and positive

integer N exist such that

f(n) ≤ c•g(n) for all n ≥ N


Formalities

Fig. 9-7 An illustration of the definition of Big Oh


Formalities 21

• The following identities hold for Big Oh notation:

O(k f(n)) = O(f(n)) O(f(n)) + O(g(n)) = O(f(n) + g(n)) O(f(n)) O(g(n)) = O(f(n) g(n))


Picturing Efficiency 24

Fig. 9-8 an O(n) algorithm.



Fig. 9-9 An O(n2) algorithm.



Fig. 9-10 Another O(n2) algorithm.


Picturing Efficiency

Fig. 9-11 The effect of doubling the problem size on an algorithm's time requirement.



Fig. 9-12 The time to process one million items by algorithms of various orders at the rate of one

million operations per second.


Comments on Efficiency

• A programmer can use O(n2), O(n3) or O(2n) as long as the problem size is small

• At one million operations per second it would take 1 second … For a problem size of 1000 with O(n2) For a problem size of 1000 with O(n3) For a problem size of 20 with O(2n)


Efficiency of Implementations of ADT List 29

• Reference AList from Chapter 5• For array-based implementation

Add to end of list O(1) Add to list at given position O(n)

• Reference LList from Chapter 6• For linked implementation

Add to end of list O(n) Add to list at given position O(n) Retrieving an entry O(n)


Comparing Implementations 34

Fig. 9-13 The time efficiencies of the ADT list operations for two implementations, expressed in Big Oh notation

the efficiency of algorithms chapter 9 slides by steve armstrong letourneau university longview, tx ...

Documents

data structures

algorithm c

pearson education

algorithm efficiency

time slide

inefficient slide

function of n slide

result slide