recursion chapter 12. 2 12.1 nature of recursion t problems that lend themselves to a recursive...

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 nProblem

Size n-1Problem

Size n-2Problem

Size 1problem

Size 1problem

Size 1problem

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 > 0.

// Post:Returns m raised to power n.

int power (int m, int n)

{

if (n <= 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 <= 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 <iostream>

using namespace std;

void reverse();

int main ()

{

reverse();

cout << endl;

return 0;

}

10

ReverseTest.cpp

void reverse()

{

char next;

cout << "Next character or * to stop: ";

cin >> next;

if (next != ‘*’)

{

reverse();

cout << 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 reversen 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 reversen 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 returnn 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 > 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 <= 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 <= 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 > 0.

// Post: None

// Returns: The nth Fibonacci number.

{

if (n <= 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 <iostream>

using namespace std;

// Function prototype

int gcd(int, int);

23

GCDTest.cpp

int main()

{

int m, n; // the two input items

cout << "Enter two positive integers: ";

cin >> m >> n;

cout << endl;

cout << "Their greatest common divisor is " <<

gcd(m, n) << endl;

return 0;

}

24

GCDTest.cpp

// Finds the greatest common divisor of two

// integers

// Pre: m and n are defined and both are > 0.

// Post: None

// Returns: The greatest common divisor of m and

// n.

int gcd(int m, int n)

{

if (m < 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 <iostream>

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 x[SIZE];

int sum1;

int sum2;

// Fill array x

for (int i = 0; i < SIZE; i++)

x[i] = i + 1;

29

FindSumTest.cpp

// Calulate sum two ways

sum1 = findSum(x, SIZE);

sum2 = (SIZE * (SIZE + 1)) / 2;

cout << "Recursive sum is " << sum1 << endl;

cout << "Calculated sum is " << sum2 << endl;

cout << binSearch(x, 10, 10, SIZE-1) << 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 x[0];

else

return x[n-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 > last)

return -1;

else if (target == table[middle])

return middle;

else if (target < table[middle])

return binSearch(table, target, first,

middle-1);

else

return binSearch(table, target, middle+1,

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 <iostream>

using namespace std;

void tower(char, char, char, int);

int main()

{

int numDisks; // input - number of disks

37

Tower.cpp

cout << "How many disks: ";

cin >> 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 << "Move disk 1 from tower " <<

fromTower << " to tower " << toTower <<

endl;

else

{

39

Tower.cpp

tower(fromTower, auxTower, toTower, n-1);

cout << "Move disk " << n <<

" from tower "<< fromTower <<

" to tower " << toTower << 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