# Programming Appreciation Camp - PowerPoint PPT Presentation

1 / 56

Programming Appreciation Camp. Session 2: Recursion Steven Halim NUS School of Computing. Recap. In the first session, we have learnt/done some problem solving using algorithm: Algorithms have three control structures: Sequence Selection (branching) Repetition (loop) And Recursion.

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.

Programming Appreciation Camp

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

## Programming Appreciation Camp

Session 2: Recursion

Steven Halim

NUS School of Computing

### Recap

• In the first session, we have learnt/done some problem solving using algorithm:

• Algorithms have three control structures:

• Sequence

• Selection (branching)

• Repetition (loop)

• And Recursion

[Programming Appreciation Camp November 2008]

### Recursion: Informal Definition

• A “Definition” in an English-English dictionary

• Recursion

• If you still don't get it, See: “Recursion”.

• Informally:

• Repeat same thing until some conditions are met.

• Seems like repetition/iteration/loop

• But more than that!

[Programming Appreciation Camp November 2008]

### Non Computing Examples

• Droste Effecthttp://en.wikipedia.org/wiki/Droste_effect

• Mathematical Definition

• Example: even number

• 2 is an even number

• If n is an even number, then n+2 too

• Russian Doll

http://en.wikipedia.org/wiki/Matryoshka_doll

• Recursive Acronymshttp://en.wikipedia.org/wiki/Recursive_acronym

• GNU: GNU’s Not Unix

• VISA: VISA International Service Association

[Programming Appreciation Camp November 2008]

### Non Computing Examples: Fractal

• Sierpinski Triangle

• Koch Snowflake

• Recursive Tree

• More Fractals

• http://en.wikipedia.org/wiki/Fractal

[Programming Appreciation Camp November 2008]

### Recursion in Comp Sci: Motivation (1)

• Given this 9x9 2-D map

• L is Land

• W is Water

• Q: “How many lakes in the map?”

• Adjacent ‘W’s (N, E, S, W) belong to one lake.

• LLLLLLLLL

• LLWWLLWLL

• LWWLLLLLL

• LWWWLWWLL

• LLLWWWLLL

• LLLLLLLLL

• LLLWWLLWL

• LLWLWLLLL

• LLLLLLLLL

• LLLLLLLLL

• LL11LL2LL

• L11LLLLLL

• L111L11LL

• LLL111LLL

• LLLLLLLLL

• LLL33LL4L

• LL5L3LLLL

• LLLLLLLLL

The answer for this scenario: 5 lakes!

[Programming Appreciation Camp November 2008]

### Recursion in Comp Sci: Motivation (2)

• Hard to get answer using standard iteration!

numOfW  0for each cell(i,j) in the map // (0,0) to (9,9) if (cell(i,j) is character ‘W’) numOfW  numOfW + 1printf numOfW // W = 18 in this case

• LLLLLLLLL

• LLWWLLWLL

• LWWLLLLLL

• LWWWLWWLL

• LLLWWWLLL

• LLLLLLLLL

• LLLWWLLWL

• LLWLWLLLL

• LLLLLLLLL

• LLLLLLLLL

• LL12LL3LL

• L45LLLLLL

• L678L9ALL

• LLLBCDLLL

• LLLLLLLLL

• LLLEFLLGL

• LLHLILLLL

• LLLLLLLLL

• LLLLLLLLL

• LL11LL2LL

• L11LLLLLL

• L111L11LL

• LLL111LLL

• LLLLLLLLL

• LLL33LL4L

• LL5L3LLLL

• LLLLLLLLL

A=10, B=11, …, I = 18

So, how to answer: 5 lakes?

Use recursion!

This problem will be revisitedat the latter part of this session!

[Programming Appreciation Camp November 2008]

### Recursion: Basic Ideahttp://en.wikipedia.org/wiki/Recursion_(computer_science)

• Recursion is a programming paradigm!

• Complements sequence, selection, repetition

• Divide: break up a probleminto sub-problems of the same type!

• Conquer: Solve the problem with a functionthat calls itself to solve each sub-problem

• Somewhat similar to repetition, but not 100%

• Terminating condition: one or more of these sub-problems are so simple that they can be solved directly without further calls to the function

[Programming Appreciation Camp November 2008]

### Why use Recursion?

• Many computer algorithms can be expressed naturally in recursive form

• Trying to express these algorithms iterativelycan be actually confusing…

• e.g. “finding lakes” example

• LLLLLLLLL

• LLWWLLWLL

• LWWLLLLLL

• LWWWLWWLL

• LLLWWWLLL

• LLLLLLLLL

• LLLWWLLWL

• LLWLWLLLL

• LLLLLLLLL

[Programming Appreciation Camp November 2008]

### Recursion: Implemented As Function

• Function is simply defined as follow:

• output function_name(inputs) process the inputs return output

[Programming Appreciation Camp November 2008]

### Recursion: Basic Form

• Template for most recursive function

Recursive_Function_Name(Parameter_List)

// you will always see “selection statement” (if, switch, etc)

if (base_case) // problem is trivial, there can be more than one

do_something_simple // produce the result directly

else // recursive case

// Simplify the problem and then call this same function again

Recursive_Function_Name(Modified_Parameter_List)

• Modified_Parameter_List must bring the recursive function closer to (one of) the base case!

[Programming Appreciation Camp November 2008]

7 recursion examples to get you started

### Learning by example

[Programming Appreciation Camp November 2008]

### Example 1: Countdown (1)http://www.nasa.gov/returntoflight/launch/countdown101.html

• Problem Description:

• We want to count down the space shuttle launch, e.g. 10, 9, 8, …, 3, 2, 1, BLAST OFF!!!

• Must use recursion!

• Although this can be done iteratively.

[Programming Appreciation Camp November 2008]

### Example 1: Countdown (2)http://www.nasa.gov/returntoflight/launch/countdown101.html

• Recursive version:

count_down(n) if (n <= 0) print “BLAST OFF!!!!” else print “Time = ” + ncount_down(n-1)

Base Case

occurs when n <= 0

If this happens, simply print “BLAST OFF!!!!”

Recursive Case

occurs when n > 0

If this happens, print the current time,

and then call a simpler problem:

count_down(n-1)

Note that this recursive function returns nothing

[Programming Appreciation Camp November 2008]

### Example 1: Countdown (3)http://www.nasa.gov/returntoflight/launch/countdown101.html

• Recursive version:

count_down(n) if (n <= 0) print “BLAST OFF!!!!” else print “Time = ” + ncount_down(n-1)

• Sample calls:

count_down(3) Time = 3Time = 2Time = 1BLAST OFF!!!!

• Iterative version:

count_down_itr(n) for (t=n to 0, decrement by 1) print “Time = ” + t print BLAST OFF!!!!”// actually the iterative// version is simpler// for this case

• Sample calls:

count_down_itr(3) Time = 3Time = 2Time = 1BLAST OFF!!!!

[Programming Appreciation Camp November 2008]

### Example 2: Factorial (1)http://en.wikipedia.org/wiki/Factorial

• Problem Description:

• fact(n), n!, product of 1 to n, is defined as:

• fact(n) = n * (n-1) * (n-2) * ... * 2 * 1, and

• fact(0) = 1

• fact(<0) is not defined

• This is an iterative paradigm!

• Using recursion, it can be defined as

• fact(n) = 1 if (n = 0) // simple sub-problem

• n * fact (n-1) if (n > 0) // calls itself

[Programming Appreciation Camp November 2008]

### Example 2: Factorial (2)http://en.wikipedia.org/wiki/Factorial

• Recursive version:

fact(n) if (n = 0) return 1 else return n * fact(n-1)

Base Case

occurs when n = 0

If this happens, simply return 1, 0! = 1

Recursive Case

occurs when n > 0

If this happens, return n * result of simpler problem of fact(n-1)

• Recursive definition:

• fact(n) = 1 if (n = 0)

• n * fact (n-1) if (n > 0)

Note that this recursive function returns a number, which is the result of fact(n)

[Programming Appreciation Camp November 2008]

### Example 2: Factorial (3)http://en.wikipedia.org/wiki/Factorial

• Recursive version:

fact(n) if (n = 0) return 1 else return n * fact(n-1)

• Sample calls:

fact(0) 1 (base case)fact(1)  1*fact(0) = 1*1 = 1fact(2)  2*fact(1) = 2*1 = 2fact(3)  3*fact(2) = 3*2 = 6fact(4)  4*fact(3) = 4*6 = 24fact(5)  5*fact(4) = 5*24 = 120…see visual explanation 

[Programming Appreciation Camp November 2008]

### Example 2: Factorial (3)http://en.wikipedia.org/wiki/Factorial

• Recursive version:

fact(n) if (n = 0) return 1 else return n * fact(n-1)

• Sample calls:

fact(0) 1 (base case)fact(1)  1*fact(0) = 1*1 = 1fact(2)  2*fact(1) = 2*1 = 2fact(3)  3*fact(2) = 3*2 = 6fact(4)  4*fact(3) = 4*6 = 24fact(5)  5*fact(4) = 5*24 = 120…

• Iterative version:

fact_itr(n) { result  1 for (i=1 to n, increment by 1) result  result * i return result

• Sample calls:

fact_itr(0)  1fact_itr (1)  1fact_itr (2)  1*2 = 2fact_itr (3)  1*2*3 = 6fact_itr (4)  1*2*3*4 = 24fact_itr (5)  1*2*3*4*5 = 120…

[Programming Appreciation Camp November 2008]

### Example 3: Fibonacci (1)http://en.wikipedia.org/wiki/Fibonacci_number

• Problem Description:

• Fibonacci numbers are defined recursively:

• Fn =0if n = 0

• 1if n = 1

• Fn-1 + Fn-2if n > 1

[Programming Appreciation Camp November 2008]

### Example 3: Fibonacci (2)http://en.wikipedia.org/wiki/Fibonacci_number

• Recursive version:

fib(n) if (n <= 1) // for 0 and 1 return n else return fib(n-1) + fib(n-2)

Base Case

occurs when n <= 1 (0 or 1 only)

If this happens, simply return n (the value itself)

Recursive Case

occurs when n > 1

If this happens, return fib(n-1) + fib(n-2)

we call the same function twice!

• Recursive definition:

• Fn =0if n = 0

• 1if n = 1

• Fn-1 + Fn-2if n > 1

Here, we observe that a recursive function can call itself more than once! (branching recursion)

[Programming Appreciation Camp November 2008]

### Example 3: Fibonacci (3)http://en.wikipedia.org/wiki/Fibonacci_number

• Recursive version:

fib(n) if (n <= 1) // for 0 and 1 return n else return fib(n-1) + fib(n-2)

• Sample calls:

fib(0)  0 (base case)fib(1)  1 (base case) fib(2)  fib(0)+fib(1) = 0+1 = 1fib(3)  fib(1)+fib(2) = 1+1 = 2fib(4)  fib(2)+fib(3) = 1+2 = 3fib(5)  fib(3)+fib(4) = 2+3 = 5…

• Iterative version:

fib[0]  0fib[1]  1for (i=2 to n, increment by 1) fib[i]  fib[i-1] + fib[i-2]

• Sample calls:

fib[0] = 0fib[1] = 1fib[2] = 1fib[3] = 2fib[4] = 3fib[5] = 5…

[Programming Appreciation Camp November 2008]

### Example 3: Fibonacci (4)http://en.wikipedia.org/wiki/Fibonacci_number

• Recursive version:

• Sample calls:

On my machine

fib(20) ~ 0.0 second fib(30) ~ 0.0 secondfib(35) ~ 1 secondfib(36) ~ 2 secondsfib(37) ~ 4 secondsfib(38) ~ 6 secondsfib(39) ~ 8 seconds fib(40) ~ 11 seconds

• Iterative version:

• Sample calls:

On my machine

fib(20) ~ 0.0 second fib(30) ~ 0.0 secondfib(35) ~ 0.0 second fib(36) ~ 0.0 second fib(37) ~ 0.0 second fib(38) ~ 0.0 second fib(39) ~ 0.0 second fib(40) ~ 0.0 second

[Programming Appreciation Camp November 2008]

### Example 3: Fibonacci (5)http://en.wikipedia.org/wiki/Fibonacci_number

• The Recursive Pattern of Fibonacci(5)

• Many repetitions…

• Slow!

Fib 5

Fib 3

Fib 4

Fib 1

Fib2

Fib 2

Fib 3

1

Fib 1

Fib 0

Fib 0

Fib1

Fib 1

Fib 2

1

0

0

1

1

Fib 0

Fib1

0

1

### Example 4: Exponentiation, 2n (1)http://en.wikipedia.org/wiki/Exponentiation

• Problem Description:

• Exponentiation, written as an,where a is called as “base”and n is called “the exponent”.

• When n >= 0, exponentiation is defined as:

• an = a * a * …. * a (n times)

• This is iterative definition

• What is the recursive formulation?

• an = __________________________

_____________

[Programming Appreciation Camp November 2008]

### Example 4: Exponentiation, 2n (2)http://en.wikipedia.org/wiki/Exponentiation

• Recursive version:

pow2(n) if (n = 0) return 1 else if (n = 1) return 2 else return 2 * pow2(n-1)

Base Case

occurs when n = 0 or n = 1

there can be >= 1 base case(s)

If this happens, return 1 for 20 or 2 for 21

Recursive Case

occurs when n > 1

If this happens, return 2 * pow2(n-1)

pow2(n-1) is a simplified problem

Here, we observe that a recursive function can have more than one base cases (processed differently)

[Programming Appreciation Camp November 2008]

### Example 4: Exponentiation, 2n (3)http://en.wikipedia.org/wiki/Exponentiation

• Recursive version:

pow2(n) if (n = 0) return 1 else if (n = 1) return 2 else return 2 * pow2(n-1)

• Sample calls:

pow2(1)  2 (base case)pow2(2)  2*pow2(1) = 2*2 = 4pow2(3)  2*pow2(2) = 2*4 = 8 pow2(4)  2*pow2(3) = 2*8 = 16 …

• Iterative version:

pow2_itr(n) result  1 for (i=1 to n, increment by 1) result  result * 2 return result

• Sample calls:

pow2_itr(1)  1*2=2pow2_itr (2)  1*2*2=4pow2_itr (3)  1*2*2*2=8pow2_itr (4)  1*2*2*2*2=16

[Programming Appreciation Camp November 2008]

### Example 5: Print Digits (1)http://en.wikipedia.org/wiki/Decimal

• Problem Description:

• Given a decimal number (base 10),as what we used in daily life…

• Print its digit line by line.

• e.g. 2008 is printed as:Answer (red lines):2008

[Programming Appreciation Camp November 2008]

### Example 5: Print Digits (2)http://en.wikipedia.org/wiki/Decimal

• Recursive version:

digit(n) if (n > 0) digit(n / 10) print n % 10

Base Case

occurs when n <= 0

If this happens, do nothing!

Recursive Case

occurs when n > 0

If this happens, call print_digit with simplified problem: one less ‘digit’ (n / 10)

then, print n % 10. % is called themodulus (remainder) operator.

Here, we observe that base case can be as simple as doing nothing and we can still do something after recursive calls!

[Programming Appreciation Camp November 2008]

### Example 5: Print Digits (3)http://en.wikipedia.org/wiki/Decimal

• Recursive version:

digit(n) if (n > 0) digit(n / 10) print n % 10

• Sample calls:

digit(2008)

2

0

0

8

Details in the next slide!

• Iterative version *:

digit_itr(n) while (n > 0) print n % 10 n  n / 10

• Sample calls:

digit_itr(2008)

8

0

0

2

* This is not what we want…

* We need to reverse the answer!

[Programming Appreciation Camp November 2008]

### Example 5: Print Digits (4)http://en.wikipedia.org/wiki/Decimal

• Recursive version:

digit(n) if (n > 0) digit(n / 10) print n % 10

• Sample calls:

digit(2008)

2

0

0

8

See diagram for clarity 

[Programming Appreciation Camp November 2008]

### Recall - Task 2: Pascal’s Trianglehttp://en.wikipedia.org/wiki/Pascal%27s_triangle

1

1 1

1 2 1

1 3 3 1

1 4 6 4 1

1 5 10 10 5 1

Compute nCk or C(n,k)

nCk = n! / (k! * (n – k)!)

[Programming Appreciation Camp November 2008]

32

### Example 6: Ways to choose(n, k) (1)http://en.wikipedia.org/wiki/Combinations

• How many ways to choose k out of n items?

• Enumerate the Base Cases

• When k < 0, e.g. (k=-1) out of (n=3)?

• 0, this problem is undefined for k < 0…

• When k > n, e.g. (k=4) out of (n=3)?

• 0, also undefined for k > n…

• When k == n, e.g. (k=3) out of (n=3)?

• 1, take all

• When k == 0, e.g. (k=0) out of (n=3)?

• 1, do not take anything

[Programming Appreciation Camp November 2008]

### Example 6: Ways to choose(n, k) (2)http://en.wikipedia.org/wiki/Combinations

• How many ways to choose k out of n items?

• Think about the General (recursive) Cases

• When 0 < k < n, e.g. (k=2) out of (n=3)?

• Consider the item one by one, e.g. item X!

• choose(n,k) =

• choose(n-1,k-1)The number of ways if I take X

• The problem becomes simpler:choosing k-1 (k=1) out of n-1 (n=2)

• plus choose(n-1,k)The number of ways if I do not take X

• The problem becomes simpler:choosing k (k=2) out of n-1 (n=2)

[Programming Appreciation Camp November 2008]

### Example 6: Ways to choose(n, k) (3)http://en.wikipedia.org/wiki/Combinations

• How many ways to choose k out of n items?

Recursive version only:

choose(n, k) if (k = 0 or k = n) return 1 else

return choose(n-1,k-1) + choose(n-1,k)

[Programming Appreciation Camp November 2008]

### Example 6: Ways to choose(k, n) (4)http://en.wikipedia.org/wiki/Combinations

• How many ways to choose k out of n items?

This problem is not intuitive to be solved iteratively!

However, the recursive solution has many similar sub-problems (compare with Fibonacci)

Special:

Closed form:nCk = n!/(k!*(n-k)!)

6 in this case!

[Programming Appreciation Camp November 2008]

### Example 7: Binary Search (1)http://en.wikipedia.org/wiki/Binary_search

• Searching in Sorted Array, e.g. array A =

• Standard:

• Scan item one by one from left to right

• Can we do better?

• Yes, using a technique called binary search

• Idea: Narrow the search space by half (left/right side) successively until we find the item or until we are sure that the item is not in the sorted array.

[Programming Appreciation Camp November 2008]

### Example 7: Binary Search (2)http://en.wikipedia.org/wiki/Binary_search

• Recursive version (iterative not shown):

bsearch(arr, key, low, high) {if (high < low)return -1 // not found, base case 1

mid  (low + high) / 2

if (arr[mid] > key)return bsearch(arr, key, low, mid-1) // recursive case 1: leftelse if (arr[mid] < key)return bsearch(arr, key, mid+1, high) // recursive case 2: rightelsereturn mid // found, base case 2

[Programming Appreciation Camp November 2008]

### Example 7: Binary Search (3)http://en.wikipedia.org/wiki/Binary_search

• Assume we have a sorted array A:

• Sample calls:

• bsearch(A, 7, 0, 9) // mid is 4, A[4] = 47, 7 < 47, go to left side

bsearch(A, 7, 0, 3) // mid is 1, A[1] = 7, 7 == 7, found it

return 1; // found in index 1

• bsearch(A, 47, 0, 9) // mid is 4, A[4] = 47, 47 == 47, found it

return 4; // found in index 4

• bsearch(A, 82, 0, 9) // mid is 4, A[4] = 47, 82 > 47, go to right side

bsearch(A, 82, 5, 9) // mid is 7, A[7] = 73 , 82 > 73, go to right side

bsearch(A, 82, 8, 9) // mid is 8, A[8] = 81, 82 > 81, go to right side

bsearch(A, 82, 9, 9) // mid is 9, A[9] = 99, 82 < 99, go to left side

[Programming Appreciation Camp November 2008]

### Recursion: Recap

• A function that call itself

• With simpler sub-problem

• Can have one or more recursive cases

• Has simple/trivial sub-problems: base cases

• This is the terminating condition

• Can be as simple as “doing nothing”

• Can have one or more base cases

• Can solve certain problems naturally

• Can be slower than iterative counterparts

• This can be optimized though…

[Programming Appreciation Camp November 2008]

### Lake Question (Revisited) (1)

• Given this 9x9 2-D map

• L is Land

• W is Water

• Q: “How many lakes in the map?”

• Adjacent ‘W’s (N, E, S, W) belong to one lake.

• LLLLLLLLL

• LLWWLLWLL

• LWWLLLLLL

• LWWWLWWLL

• LLLWWWLLL

• LLLLLLLLL

• LLLWWLLWL

• LLWLWLLLL

• LLLLLLLLL

• LLLLLLLLL

• LL11LL2LL

• L11LLLLLL

• L111L11LL

• LLL111LLL

• LLLLLLLLL

• LLL33LL4L

• LL5L3LLLL

• LLLLLLLLL

The answer for this scenario: 5 lakes!

[Programming Appreciation Camp November 2008]

### Lake Question (Revisited) (2)

• How to connect adjacent (N, E, S, W) ‘W’s?

• The idea: Analogy of real-life “water”!

• If we pour water to coordinate (1,2),

• The water will fill the area indicated with ‘1’s!

• But how to do this? (flooding the lakes?)

• LLLLLLLLL

• LLWWLLWLL

• LWWLLLLLL

• LWWWLWWLL

• LLLWWWLLL

• LLLLLLLLL

• LLLWWLLWL

• LLWLWLLLL

• LLLLLLLLL

• LLLLLLLLL

• LL11LLWLL

• L11LLLLLL

• L111L11LL

• LLL111LLL

• LLLLLLLLL

• LLLWWLLWL

• LLWLWLLLL

• LLLLLLLLL

[Programming Appreciation Camp November 2008]

### Lake Question (Revisited) (3)http://en.wikipedia.org/wiki/Flood_fill

• Flood Fill Recursive Algorithm

floodfill(r, c, ID) if (r < 0 or r > 9 or c < 0 or r > 9) return // base case 1: exceeding boundary if (cell(r,c) is not character ‘W’) return // base case 2: not water cell(r,c)  ID // simplify the problem W to ID: 1 ‘W’ less// recursively fill the 4 directions floodfill(r, c+1, ID) // east floodfill(r-1, c, ID) // north floodfill(r, c-1, ID) // west floodfill(r+1, c, ID) // south

• Sample calls:

floodfill(1,2,‘1’) // fill lake starting from (1,2) with ‘1’

• LLLLLLLLL

• LLWWLLWLL

• LWWLLLLLL

• LWWWLWWLL

• LLLWWWLLL

• LLLLLLLLL

• LLLWWLLWL

• LLWLWLLLL

• LLLLLLLLL

• LLLLLLLLL

• LL11LLWLL

• L11LLLLLL

• L111L11LL

• LLL111LLL

• LLLLLLLLL

• LLLWWLLWL

• LLWLWLLLL

• LLLLLLLLL

[Programming Appreciation Camp November 2008]

### Lake Question (Revisited) (4)

• Now, Use floodfillto flood each lake,then increment the lake counter!

lake  0for each cell(i,j) in the map if (cell(i,j) is character ‘W’)floodfill(i, j, ‘1’+lake) lake  lake + 1printf lake // 5 in this case

• LLLLLLLLL

• LLWWLLWLL

• LWWLLLLLL

• LWWWLWWLL

• LLLWWWLLL

• LLLLLLLLL

• LLLWWLLWL

• LLWLWLLLL

• LLLLLLLLL

• LLLLLLLLL

• LL11LLWLL

• L11LLLLLL

• L111L11LL

• LLL111LLL

• LLLLLLLLL

• LLLWWLLWL

• LLWLWLLLL

• LLLLLLLLL

• LLLLLLLLL

• LL11LL2LL

• L11LLLLLL

• L111L11LL

• LLL111LLL

• LLLLLLLLL

• LLLWWLLWL

• LLWLWLLLL

• LLLLLLLLL

• LLLLLLLLL

• LL11LL2LL

• L11LLLLLL

• L111L11LL

• LLL111LLL

• LLLLLLLLL

• LLL33LLWL

• LLWL3LLLL

• LLLLLLLLL

• LLLLLLLLL

• LL11LL2LL

• L11LLLLLL

• L111L11LL

• LLL111LLL

• LLLLLLLLL

• LLL33LL4L

• LLWL3LLLL

• LLLLLLLLL

• LLLLLLLLL

• LL11LL2LL

• L11LLLLLL

• L111L11LL

• LLL111LLL

• LLLLLLLLL

• LLL33LL4L

• LL5L3LLLL

• LLLLLLLLL

[Programming Appreciation Camp November 2008]

### Final Say: Recursion is Powerful

• It is a programming paradigm:

• Divide and Conquer

• Many data structures are recursively defined

• Linked List, Tree or Heap: these data structures and their operations are naturally recursive, etc

• Many algorithms are naturally recursive

• Sorting: Merge sort and Quick sort are recursive

• Top-Down Dynamic Programming, etc

• We do not discuss them now,but you may explore on your own

[Programming Appreciation Camp November 2008]

7 more recursion examples that we will discuss together

### Learning by DOING

[Programming Appreciation Camp November 2008]

• Modify recursive function floodfill(r,c,ID)so that it is able to go to 8 directions(N, NE, E, SE, S, SW, W, NW)!

• Given the same map,there will be just 4 lakes this time:look at lake number 3!

• LLLLLLLLL

• LLWWLLWLL

• LWWLLLLLL

• LWWWLWWLL

• LLLWWWLLL

• LLLLLLLLL

• LLLWWLLWL

• LLWLWLLLL

• LLLLLLLLL

• LLLLLLLLL

• LL11LLWLL

• L11LLLLLL

• L111L11LL

• LLL111LLL

• LLLLLLLLL

• LLLWWLLWL

• LLWLWLLLL

• LLLLLLLLL

• LLLLLLLLL

• LL11LL2LL

• L11LLLLLL

• L111L11LL

• LLL111LLL

• LLLLLLLLL

• LLLWWLLWL

• LLWLWLLLL

• LLLLLLLLL

• LLLLLLLLL

• LL11LL2LL

• L11LLLLLL

• L111L11LL

• LLL111LLL

• LLLLLLLLL

• LLL33LLWL

• LL3L3LLLL

• LLLLLLLLL

• LLLLLLLLL

• LL11LL2LL

• L11LLLLLL

• L111L11LL

• LLL111LLL

• LLLLLLLLL

• LLL33LL4L

• LL3L3LLLL

• LLLLLLLLL

[Programming Appreciation Camp November 2008]

• Create pow(a,n) to compute an!

• Hint: modify pow2(n) a bit

• Sample calls:

• pow(3,3) = 27

• pow(4,2) = 16

• pow(5,3) = 125

• pow(7,3) = 343

[Programming Appreciation Camp November 2008]

• Create fast_pow(a,n) to compute anwith a better recursive formulation:

• Insight: a8 a8 = a4*a4; a4 = a2*a2; and a2 = a*a

• Only 3 multiplications to compute a8!

• Logarithmic growth: log2 8 = 3

• Special case: Odd exponent: a7=a*a6

• Sample calls:

• fast_pow(3,3) = 27

• fast_pow(4,2) = 16

• fast_pow(5,3) = 125

• fast_pow(7,3) = 343

[Programming Appreciation Camp November 2008]

### Recap - Euclidean Algorithm

• First documented algorithm by Greek mathematician Euclid in 300 B.C.

• To compute the GCD (greatest common divisor) of 2 integers.

• Let A and B be integers with A > B ≥ 0.

• If B = 0, then the GCD is A and algorithm ends.

• Otherwise, find q and r such that

• A = q.B + r where 0 ≤ r < B

• Note that we have 0 ≤ r < B < A and GCD(A,B) = GCD(B,r).

• Replace A by B, and B by r. Go to step 2.

[Programming Appreciation Camp November 2008]

• Create greatest common divisor function:gcd(a,b) according to:

• gcd(a,b) = aif (b == 0)gcd(b,a%b)otherwise

• Sample calls:

• gcd(5,2) = 1, i.e., common divisor of 5 and 2 is 1

• gcd(6,2) = 2

• gcd(3,12) = 3

• gcd(15,25) = 5

[Programming Appreciation Camp November 2008]

A word is a palindrome if it reads the same forward and backward

How do you determine if a word is a palindrome?

Recursively!

Sample calls:

Palindrome(“”) = false

Palindrome(“O”) = true

Palindrome(“OO”) = true

Palindrome(“NOON”) = true

Palindrome(“D”) = true

[Programming Appreciation Camp November 2008]

52

North-east (NE) path: you may only move northward or eastward

Find the number of north-east pathsbetween A and C.

Recursively!

C

A

[Programming Appreciation Camp November 2008]

53

Given this list of coin denominations: \$1, 50 cents, 20 cents, 10 cents, 5 cents, 1 cent, find the smallest number of coins needed for a given amount. You do not need to list out what coins are used.

Example 1: For \$3.75, 6 coins are needed.

Example 2: For \$5.43, 10 coins are needed.

Recursively!

[Programming Appreciation Camp November 2008]

54

### Q & A Session

• That’s all for today

• Any questions?

• Contact:

• Steven Halim

• stevenhalim@gmail.com

• http://www.comp.nus.edu.sg/~stevenha/myteaching

[Programming Appreciation Camp November 2008]

### THE END

[Programming Appreciation Camp November 2008]