Recursion

1
Recursion

• Chapter 12

2
12.1 Nature of Recursion

• Problems that lend themselves to a recursive
  solution have the following characteristics
• One or more simple case of the problem have a
  straightforward, non-recursive solution
• Otherwise, use reduced cases of the problem that
  are closer to a stopping case
• Eventually the problem can be reduced to stopping
  cases only. Easy to solve

3
Nature of Recursion

• Splitting a problem into smaller problems

Size n Problem
Size n-1 Problem
Size n-2 Problem
Size 1 problem
Size 1 problem
Size 1 problem
4
Power by Multiplication

• Raise 6 to the power of 3
• Raise 6 to the power of 22
• Multiply the result by 6
• Raise 6 to the power of 2
• Raise 6 to the power of 1
• Multiply the result by 6
• Multiplying 6 6 6

5
Power.cpp

• // FILE Power.cpp
• // RECURSIVE POWER FUNCTION
• // Raises its first argument to the power
• // indicated by its second argument.
• // Pre m and n are defined and gt 0.
• // Post Returns m raised to power n.
• int power (int m, int n)
• if (n lt 1)
• return m
• else
• return m power (m, n - 1)

6
12.2 Tracing Recursive Functions

• Hand tracing we see how algorithm works
• Very useful in recursion
• Previous Multiply example trace
• Activation Frame corresponds to a function call
• Darker shading shows the depth of recursion

7
Trace of Power
8
Recursive Function with No Return Value

• If statement with some stopping condition
• n lt 1
• When TRUE stopping case is reached
• recursive step is finished
• falls back to previous calls (if any)
• trace of reverse
• ReverseTest.cpp

9
ReverseTest.cpp

• include ltiostreamgt
• using namespace std
• void reverse()
• int main ()
• reverse()
• cout ltlt endl
• return 0

10
ReverseTest.cpp

• void reverse()
• char next
• cout ltlt "Next character or to stop "
• cin gtgt next
• if (next ! )
• reverse()
• cout ltlt next

11
Reverse Trace
12
Argument and Local Variable Stacks

• How does C keep track of n and next ?
• Uses a data structure called a stack
• Think of a stack of trays in a cafeteria
• Each time a function is called it is pushed onto
  the stack
• Only top values are used when needed (popping)
• Example of calls to reverse

13
Recursive String

• After 1st call to reverse
• n next
• 3 ? top
• c is read into next just prior to 2nd call
• n next
• 3 c top

14
Recursive String

• After 2nd call to reverse
• n next
• 2 ? top
• 3 c
• letter a is read into next just prior to 3rd call
• n next
• 2 a top
• 3 c

15
Recursive String

• After 3rd call to reverse
• n next
• 1 ? top
• 2 a
• 3 c
• letter t is read into next printed due to stop
  case
• n next
• 1 t top
• 2 a
• 3 c

16
Recursive String

• After 1st return
• n next
• 2 a top
• 3 c
• After 2nd return
• n next
• 3 c
• After 3rd return (final)
• ? ?

17
12.3 Recursive Mathematical Functions

• Many mathematical functions are defined
  recursively
• factorial n! of a number
• 0! 1
• n! n n-1)! for n gt 0
• So 4! 4 3 2 1 or 24
• Look at a block of recursive math function
  example source code files

18
Factorial.cpp

• // FILE Factorial.cpp
• // RECURSIVE FACTORIAL FUNCTION
• // COMPUTES N!
• int factorial (int n)
• if (n lt 0)
• return 1
• else
• return n factorial (n-1)

19
Factorial Trace
20
FactorialI.cpp

• // FILE FactorialI.cpp
• // ITERATIVE FACTORIAL FUNCTION
• // COMPUTES N!
• int factorialI (int n)
• int factorial
• factorial 1
• for (int i 2 i lt n i)
• factorial i
• return factorial

21
Fibonacci.cpp

• // FILE Fibonacci.cpp
• // RECURSIVE FIBONACCI NUMBER FUNCTION
• int fibonacci (int n)
• // Pre n is defined and n gt 0.
• // Post None
• // Returns The nth Fibonacci number.
• if (n lt 2)
• return 1
• else
• return fibonacci (n - 2) fibonacci
• (n - 1)

22
GCDTest.cpp

• // FILE gcdTest.cpp
• // Program and recursive function to find
• // greatest common divisor
• include ltiostreamgt
• using namespace std
• // Function prototype
• int gcd(int, int)

23
GCDTest.cpp

• int main()
• int m, n // the two input items
• cout ltlt "Enter two positive integers "
• cin gtgt m gtgt n
• cout ltlt endl
• cout ltlt "Their greatest common divisor is " ltlt
• gcd(m, n) ltlt endl
• return 0

24
GCDTest.cpp

• // Finds the greatest common divisor of two
• // integers
• // Pre m and n are defined and both are gt 0.
• // Post None
• // Returns The greatest common divisor of m and
• // n.
• int gcd(int m, int n)
• if (m lt n)
• return gcd(n, m)

25
GCDTest.cpp

• else if (m n 0)
• return n
• else
• return gcd(n, m n) // recursive step

26
GCDTest.cpp

• Program Output
• Enter two positive integers separated by a space
  24 84
• Their greatest common divisor is 12

27
12.4 Recursive Functions with Array Arguments

• // File findSumTest.cpp
• // Program and recursive function to sum an
• // array's elements
• include ltiostreamgt
• using namespace std
• // Function prototype
• int findSum(int, int)
• int binSearch(int, int, int, int)

28
FindSumTest.cpp

• int main()
• const int SIZE 10
• int xSIZE
• int sum1
• int sum2
• // Fill array x
• for (int i 0 i lt SIZE i)
• xi i 1

29
FindSumTest.cpp

• // Calulate sum two ways
• sum1 findSum(x, SIZE)
• sum2 (SIZE (SIZE 1)) / 2
• cout ltlt "Recursive sum is " ltlt sum1 ltlt endl
• cout ltlt "Calculated sum is " ltlt sum2 ltlt endl
• cout ltlt binSearch(x, 10, 10, SIZE-1) ltlt endl
• return 0

30
FindSumTest.cpp

• // Finds the sum of integers in an n-element
• // array
• int findSum(int x, int n)
• if (n 1)
• return x0
• else
• return xn-1 findSum(x, n-1)

31
FindSumTest.cpp

• // Searches for target in elements first through
• // last of array
• // Precondition The elements of table are
• // sorted first and last are defined.
• // Postcondition If target is in the array,
• // return its position otherwise, returns -1.
• int binSearch (int table, int target,
• int first, int last)
• int middle

32
FindSumTest.cpp

• middle (first last) / 2
• if (first gt last)
• return -1
• else if (target tablemiddle)
• return middle
• else if (target lt tablemiddle)
• return binSearch(table, target, first,
• middle-1)
• else
• return binSearch(table, target, middle1,
• last)

33
12.5 Problem Solving with Recursion

• Case Study The Towers of Hanoi
• Problem Statement
• Solve the Towers of Hanoi problem for n disks,
  where n is the number of disks to be moved from
  tower A to tower c
• Problem Analysis
• Solution is a printed list of each disk move.
  Recursive function that can be used to move any
  number of disks from one tower to the other tower.

34
Towers of Hanoi

• Program Design
• If n is 1
• move disk 1 from fromTower to toTower
• else
• move n-1 disks from fromTower to aux tower using
  the toTower
• move disk n from the fromTower to the toTower
• move n-1 disks from aux tower to the toTower
  using fromTower

35
Towers of Hanoi

• Program Implementation
• Towers.cpp
• Program Verification Test
• towers (A, C, B, 3)
• Towers trace

36
Tower.cpp

• // File tower.cpp
• // Recursive tower of hanoi function
• include ltiostreamgt
• using namespace std
• void tower(char, char, char, int)
• int main()
• int numDisks // input - number of disks

37
Tower.cpp

• cout ltlt "How many disks "
• cin gtgt numDisks
• tower('A', 'C', 'B', numDisks)
• return 0
• // Recursive function to "move" n disks from
• // fromTower to toTower using auxTower
• // Pre The fromTower, toTower, auxTower, and
• // n are defined.
• // Post Displays the required moves.

38
Tower.cpp

• void tower (char fromTower, char toTower,
• char auxTower, int n)
• if (n 1)
• cout ltlt "Move disk 1 from tower " ltlt
• fromTower ltlt " to tower " ltlt toTower ltlt
• endl
• else

39
Tower.cpp

• tower(fromTower, auxTower, toTower, n-1)
• cout ltlt "Move disk " ltlt n ltlt
• " from tower "ltlt fromTower ltlt
• " to tower " ltlt toTower ltlt endl
• tower(auxTower, toTower, fromTower, n-1)
• // end tower

40
Towers Trace
41
TowerTest.cpp

• Program Output
• Move disk 1 from tower A to tower C
• Move disk 2 from tower A to tower B
• Move disk 1 from tower C to tower B
• Move disk 3 from tower A to tower C
• Move disk 1 from tower B to tower A
• Move disk 2 from tower B to tower C
• Move disk 1 from tower A to tower C

42
12.6 Common Programming Errors

• Stopping conditions
• Missing return statements
• Optimizations
• recursion of arrays use large amounts of memory
• use care when tracing your solutions