Functions : Recursion

1
Functions Recursion

• Lecture 11
• 4.2.2002

2
Announcements

• Class Test I on 7th February, 6pm
• Section 1 2 at S-301
• Section 5 6 at S-302

3
Call by value
Note The parameter of a function can be a
constant, variable, expression anything
that has a value. Only the value is passed to
the function.

• void printDouble (int x)
• printf (Double of d , x)
• x 2
• printf (is d\n, x)
• void main ()
• int num15
• printDouble (num)
• printf ( num d\n, num)

4
Recursion

• Def A function is recursive if it calls itself.
  
• int rfun (int x)
• . . .
• rfun (2a)
• . . .
• Questions
• How does recursion work ?
• Why do I write a recursive function ?

5
Thinking Recursively

• Learning Objectives
• To learn to think recursively
• To learn how strategies for recursion involve
  both base cases and recursion cases
• To learn how to search for different ways of
  decomposing a problem into subproblems.
• To understand how to use call trees and traces to
  reason about how recursive programs work

6
Program vs Process

• Program a set of instructions
• akin to the blueprint of an information factory
• Process activity performed by computer when
  obeying the instructions
• akin to operation of a working factory
• can create multiple factories as needed from the
  same blueprint
• need to allocate different local variables

7
Factorial via Recursion

• / 0! 1! 1, for ngt1, n! n (n-1)! /
• int factorial (int n)
• int t
• if (n lt1) t1
• else t n factorial (n-1)
• return t

8
Review Function Basics

• Tracing recursive functions is apparent if you
  remember the basics about functions
• Formal parameters and variables declared in a
  function is local to it.
• Allocated (created) on function entry
• De-allocated (destroyed) on function return
• Formal parameters initialized by copying value of
  actual parameter.

9
Factorial

• factorial (4)
• 4 factorial (3)
• 4 3 factorial (2)
• 4 3 2 factorial (1)
• 4 3 2 1 24

10
Factorial Trace
n
t
n
n
t
t
n
t
n
t
11

• int findmax (int n)
• int i, num, max
• scanf ("d", num)
• max num
• for (i1 iltn i)
• scanf ("d", num)
• if (num gt max)
• max num
• return max

int findmax (int n, int max) int num if (n0)
return max scanf ("d", num) if (num gt max)
max num max findmax (n-1, max) return
max
12
Iteration vs. Recursion

• Any iterative algorithm can be re-worked to use
  recursion, and vice-versa.
• Some algorithms are more naturally written with
  recursion.
• But naive applications of recursion can be
  inefficient.

13
When to use Recursion ?

• Problem has 1 or more simple cases.
• These have a straightforward non-recursive
  solution.
• Other cases can be re-defined in terms of
  problems that are closer to simple cases
• By applying this redefn process repeatedly one
  gets to one of the simple cases.

14
Example

• int sumSquares (int m, int n)
• int i, sum
• sum 0
• for (im iltn i)
• sum ii
• return sum

15
Example

• int sumSquares (int m, int n)
• if (mltn)
• / Recursion /
• return sumSquares(m, n-1) nn
• else
• / Base Case /
• return nn

int sumSquares (int m, int n) if (mltn) /
Recursion / return mm sumSquares(m1,
n) else / Base Case / return mm
16
Example

• int sumSquares (int m, int n)
• int middle
• if (mn)
• return mm
• else
• middle (mn)/2
• return sumSquares(m,middle)
• sumSquares(middle1,n)

5
. . .
10
8
7
. . .
n
m
mid
mid1
17
Call Tree
sumSquares(5,10)
sumSquares(5,10)
sumSquares(5,10)
sumSquares(8,10)
sumSquares(5,7)
sumSquares(10,10)
sumSquares(8,9)
sumSquares(7,7)
sumSquares(5,6)
sumSquares(9,9)
sumSquares(6,6)
sumSquares(8,8)
sumSquares(5,5)
18
Annotated Call Tree
355
sumSquares(5,10)
sumSquares(5,10)
245
110
sumSquares(5,10)
sumSquares(8,10)
sumSquares(5,7)
100
49
145
61
sumSquares(10,10)
sumSquares(8,9)
sumSquares(7,7)
sumSquares(5,6)
36
81
25
64
sumSquares(9,9)
sumSquares(6,6)
sumSquares(8,8)
sumSquares(5,5)
49
100
36
81
25
64
19
Trace
sumSq(5,10) (sumSq(5,7) sumSq(8,10))
(sumSq(5,6) (sumSq(7,7)) (sumSq(8,9)
sumSq(10,10)) ((sumSq(5,5) sumSq(6,6))
sumSq(7,7)) ((sumSq(8,8) sumSq(9,9))
sumSq(10,10)) ((25 36) 49) ((64 81)
100) (61 49) (145 100) (110
245) 355
20
Recursion The general idea

• Recursive programs are programs that call
  themselves
• to compute the solution to a subproblem having
  these properties
• 1. the subproblem is smaller than the overall
  problem or, simpler in the sense that it is
  closer to the final solution
• 2. the subproblem can be solved directly (as a
  base case) or recursively by making a recursive
  call.
• 3. the subproblems solution can be combined with
  solutions to other subproblems to obtain the
  solution to the overall problem.

21
Think recursively

• Break a big problem into smaller subproblems of
  the same kind, that can be combined back into the
  overall solution
• Divide and Conquer

22
Exercise

• 1. Write a recursive function that computes xn ,
  called power (x, n), where x is a floating point
  number and n is a non-negative integer.
• 2. Write an improved recursive version of
  power(x,n) that works by breaking n down into
  halves, squaring power(x, n/2), and multiplying
  by x again if n is odd.
• 3. To calculate the square root of x (a ve real)
  by Newtons method, we start with an initial
  approximation ax/2. If x-a?a ? epsilon, we
  stop with the result a. Otherwise a is replaced
  with the next approximation, (ax/a)/2. Write a
  recursive method, sqrt(x) to compute square root
  of x by Newtons method.

23
Common Pitfalls

• Infinite Regress a base case is never
  encountered
• a base case that never gets called fact (0)
• running out of resources each time a function
  is called, some space is allocated to store the
  activation record. With too many nested calls,
  there may be a problem of space.

int fact (int n) if (n1) return 1
return nfact(n-1)
24
Tower of Hanoi
A
B
C
25
Tower of Hanoi
A
B
C
26
Tower of Hanoi
A
B
C
27
Tower of Hanoi
A
B
C
28
void towers (int n, char from, char to, char aux)
if (n1) printf (Disk 1 c
-gt c \n, from, to) return
towers (n-1, from, aux, to) printf (Disk
d c ? c\n, n, from, to) towers
(n-1, aux, to, from)
29

• Disk 1 A -gt C
• Disk 2 A -gt B
• Disk 1 C -gt B
• Disk 3 A -gt C
• Disk 1 B -gt A
• Disk 2 B -gt C
• Disk 1 A -gt C
• Disk 4 A -gt B
• Disk 1 C -gt B
• Disk 2 C -gt A
• Disk 1 B -gt A
• Disk 3 C -gt B
• Disk 1 A -gt C
• Disk 2 A -gt B
• Disk 1 C -gt B

towers (4, A, B, C)
30
Recursion may be expensive !

• Fibonacci Sequence
• fib (n) n if n is 0 or 1
• fib (n) fib (n-2) fib(n-1) if ngt 2.

int fib (int n) if (n0 or n1) return
1 return fib(n-2) fib(n-1)
31
Call Tree
5
fib (5)
2
3
fib (3)
fib (4)
1
2
1
1
fib (2)
fib (1)
fib (2)
fib (3)
1
1
1
1
0
1
0
fib (1)
fib (2)
fib (0)
fib (1)
fib (1)
fib (0)
1
1
1
1
0
0
0
fib (1)
fib (0)
1
0
32
Iterative fibonacci computation
int fib (int n) if (n lt 1) return n
lofib 0 hifib 1 for (i2 iltn
i) x lofib lofib hifib hifib x
lofib return hifib
i 2 3 4 5 6 7 x 0 1 1 2
3 5 lofib 0 1 1 2 3 5 8 hifib 1 1 2 3
5 8 13
33
Merge Sort

• To sort an array of N elements,
• 1. Divide the array into two halves. Sort each
  half.
• 2. Combine the two sorted subarrays into a single
  sorted array
• Base Case ?

34
Binary Search revisited

• To search if key occurs in an array A (size N)
  sorted in ascending order
• mid N/2
• if (key N/2) item has been found
• if (key lt N/2) search for the key in A0..mid-1
• if (key gt N/2) search for key in Amid1..N
• Base Case ?