lecture 12.2 loop invariants for designing array algorithms

Lecture 12.2

Loop Invariants for Designing Array Algorithms

© 2006 Pearson Addison-Wesley. All rights reserved 12.2.2

Algorithms

An important aspect of problem solving is the creation of algorithms.

How does a programmer create an algorithm?

Often this occurs by recognizing that the problem fits some pattern.

What coding/design patterns do you know?

Often programming requires knowledge of how to approach problems object-oriented strategies design by prototype top-down design

Programming == Problem Solving


Loop Design

loopInitialization; while (loopCondition) { workOfTheLoop; makeProgress ;}

loopInitialization; while (loopCondition) { workOfTheLoop; makeProgress ;}

The basic loop pattern

Examples

list.reset();while ( list.hasNext() ) { System.out.println( (String)list.next() );}

int k = 1;min = intArray[0];while ( k != intArray.length ) { if (intArray[k] < min) {

min = intArray[k]; } k++;}


diagram - diagram - diagramPictures are a helpful way to visualize algorithms (especially when using containers).



[0] [1] [2] . . . [k] [length-1]

processed

This picture captures an important property of the loop -- the loop invariant.


Loop InvariantA loop invariant is an assertion that is true immediately before the loop condition.



[0] [1] [2] . . . [k] [length-1]

processed

INV: All values within intArray[0] ... intArray[k-1] are ≥ min & some value of intArray[0] ... intArray[k-1] == min


Trace

[0] [1] [length-1]

processed




Just before the loop

k

1

INV: All values within intArray[0] ... intArray[0] are ≥ min & some value of intArray[0] ... intArray[0] == min


[0] [1] [2] [length-1]

processed


k

1

After one loopbody execution 2






[0] [1] [2] [length-1]

processed





k

1



After executingloop body twice

3


[0] [1] [2] [length-1]

processed


k

1

INV: All values within intArray[0] ... intArray[length-1] are ≥ min & some value of intArray[0] ... intArray[length-1] == min


After executingloop body twice

3

After the lastrepetition.

length





Reversing an ArrayWhat is wrong with this initial attempt at reversing the content of an array?

char tmpChar;int k = 0;while ( k != charArr.length ) { tmpChar = charArr[k]; charArr[k] = charArr[charArr.length-k-1]; charArr[charArr.length-k-1] = tmpChar;k++;}

Consider how the loop invariant captures this problem...

INV: for all j, (0 ≤ j < k) charArr[j] == charArr[charArr.length-j-1]@pre

[0] [1] [2] . . . [j] [length-j-1] [length-1]


Coding from the Invariant

1) Select the loop invariant.2) Determine initialization code.3) Determine the loop condition.4) Complete the loop body.

loopInitialization; while /* loopInvariant */(loopCondition) { loopBody;}

Four Steps


Example: Coding from the Invariant

1) Select the loop invariant.2) Determine the loop condition.3) Determine the initialization.4) Complete the loop body.

// Assert: n is an int and n ≥ 0 loopInitialization; while /* loopInvariant */(loopCondition) { loopBody;}// Assert: factorial == n!

Four Steps

Design a loop to calculate n factorial, written n!

n! == 1 * 2 * 3 * 4 * ... * n3! == 1 * 2 * 3 == 65! == ??

Note, also, the following ... 1! == 1 0! == 1



Below is a suitable invariant

factorial == counter!

for some int variable, called counter.


// Assert: n ≥ 0 loopInitialization; while /* loopInvariant */(loopCondition) { loopBody;}// Assert: factorial == n!

Four Steps




What loop condition combines with the invariantto ensure the assertion after the loop? (i.e., whatvalue for counter must terminate the loop?)

counter != n


// Assert: n ≥ 0 loopInitialization; while /* factorial == counter! */(loopCondition) { loopBody;}// Assert: factorial == n!

Four Steps




What loop initial values need to be assigned to counter and factorial for the loop invariant tobe true when the loop begins?

counter = 0;factorial = 1;


// Assert: n ≥ 0 loopInitialization; while /* factorial == counter! */(counter != n) { loopBody;}// Assert: factorial == n!

Four Steps




What loop body both preserves the loop invariantand makes progress?

counter++;factorial = factorial * counter;


// Assert: n ≥ 0 counter = 0;factorial = 1; while /* factorial == counter! */(counter != n) { loopBody;}// Assert: factorial == n!

Four Steps



The Complete Loop


// Assert: n ≥ 0 counter = 0;factorial = 1; while /* factorial == counter! */(counter != n) { counter++; factorial = factorial * counter;}// Assert: factorial == n!

Four Steps


lecture 12.2 loop invariants for designing array algorithms

Documents