Copyright © Curt Hill 2006-2007 Recursion A Different Way to Think and Solve Problems

Recursion

A Different Way to Think and Solve Problems

Definition

• A recursively defined term is somehow defined in terms of itself

• A recursive function generally calls itself– It may also call a sequence of functions that

eventually call it back

• The term recursion comes from the mathematical term of a recurrence relation

Recurrence Relation

• Usually used to define the terms of series or sequence

• The recurrence relation for the Fibonacci sequence is:an = an-1 + an-2

• Typically a Fibonacci sequence starts with:a0 = a1 = 1 giving:1 1 2 3 5 8 13 21 34 55 …

Recursive Definition

• A recursive definition almost always has two or more parts

• One deals with startup or boundary conditions– This one makes no self reference

• The other is self-referencing– Always adds something before or after

the self-reference

Definition

• An item that is somehow defined in terms of itself

• Circular ≠ recursive– Circular definition adds no information

to definition– Recursive definition usually is multipart

• One part is non recursive• Even recursive parts add information

• Recursion is a generalization of looping

Circular vs. Recursive

• A circular definition adds nothing to the knowledge of the reader– A rose is a rose is a rose is a rose

• A recursive definition is partially based on itself– Yet it is able to completely specify the

result

• Both data and functions or methods may be recursively defined

Consider this Shape

Where Do We See These?• Recursive functions

– Function calls itself– Mutual recursion – a set of functions call

each other so that a call to another function generates a call to itself• A calls B and B calls A• A calls B, B calls C, C calls A

• Recursive data structures– Lists– Trees– Graphs

Consider a recursive definition

• Recursive definition of a linked list• A list may be:

– Empty– Item followed by a list

• Now consider how this becomes code

A Linked List• Two classes:class ListItem { Data d; // carried data ListItem * next; friend class List; ListItem(); // private default }; // everything is privateclass List{ ListItem * root; public: void add(Data d); bool isPresent(Data d); …};

Discussion

• The pointer represents the list– Either the next in the ListItem or – The root in List

• May be NULL– Which is the empty list

• May refer to a ListItem– Which is an item followed by a list

• Trees are more recursive but await the data structures course

Why Recursion?• Recursion is the generalization of

looping• This is loosely translated into this:• Any loop may be made into a

recursive function• Some recursive functions cannot

be made into loops• However, every recursive function

may be converted to a loop with an auxiliary data structure

Recursive Functions

• A recursive function must follow the same rules as a recursive definition– Except as translated to execution

• They are:• One or more non-recursive paths• Each recursive path moves the

function closer to a non-recursive path

• Failure to follow this cause problems

Recursive Functions

• A routine that calls itself or• A routine that initiates a call that

calls itself– A calls B– B calls C– C calls A– Syntax

• In C++ everything must be declared before it is used

• We then merely declare the prototype before it is used

Forms of Recursion

• Most recursive functions call themselves

• Two functions that call each other are called mutually recursive:int a(…);int b(…){ … x = a(…); … }int a(…){ … y = b(…); … }

• Notice the need for a prototype• The chain could be longer than two

Factorial

• Definition of factorial: N! =– IF n > 1 THEN N * (n-1)!– IF n <= 1 THEN 1

• This suggests a recursive definition– Code:int factorial(int n) { if (n > 1) return(factorial(n-1)*n); return(1);}

• Notice conciseness

Trace through it5 int factorial(int n) { 6 if (n > 1) 7 return(factorial(n-1)*n);8 return(1);9 }...20 int f = factorial(4);

Return address

Function result

parameter

First Call

Return address

Function result

First Call

Return address

Function result

First Call

Return address

Function result

First Call

Return address

Function result

parameter

3Second Call

Return address

Function result

First Call

Return address

Function result

parameter

3Second Call

Return address

Function result

First Call

Return address

Function result

3Second Call

Trace through it5 int factorial(int n) { 6 if (n > 1) 7 return(factorial(n-1)*n); 8 return(1);9 }...20 int f = factorial(4);

Return address

Function result

First Call

Return address

Function result

3Second Call

Return address

Function result

First Call

Return address

Function result

3Second Call

Return address

Function result

parameter

2Third Call

Return address

Function result

First Call

Return address

Function result

3Second Call

Return address

Function result

2Third Call

Return address

Function result

First Call

Return address

Function result

3Second Call

Return address

Function result

2Third Call

Return address

Function result

First Call

Return address

Function result

3Second Call

Return address

Function result

2Third Call

Function result

parameter1Fourth Call

7 Return address

Return address

Function result

First Call

Return address

Function result

3Second Call

Return address

Function result

2Third Call

Function result

n1Fourth Call

7 Return address

Return address

Function result

First Call

Return address

Function result

3Second Call

Return address

Function result

2Third Call

Function result

n1Fourth Call

7 Return address

Return address

Function result

First Call

Return address

Function result

3Second Call

Return address

Function result

2Third Call

Function result

n1Fourth Call

Return address

Function result

First Call

Return address

Function result

3Second Call

Return address

Function result

2Third Call

Return address

Function result

First Call

Return address

Function result

3Second Call

Return address

Function result

First Call

Function resultgiven to f

Which is better?

• Some would argue that the iterative version is more understandable

• Others would argue the opposite• The call overhead is more expensive

than the loop overhead• The recursive version will require

more memory and more time in most cases

• Rules for recursive functions• There must be at least one non-

recursive path through the routine– There may be many recursive or non-

recursive paths

• Each recursive path must move us toward a non-recursive path

Properties• Any recursive routine can be recoded non-

recursively• Any loop can be replaced by a recursive

routine• The loop is faster and takes less space• If that is the case why use recursion?

– Elegance– Easy to write

• Use recursion only for things inherently recursive– That is, if recursion simplifies the solution

Should We or Should We Not?

• There are many examples of routines that– Should be recursive– Could be recursive– Should not be recursive

• Factorial could be either but loop is preferred– Generally easier to code– Somewhat more efficient, but not

dramatically

Fibonacci• The Fibonacci sequence

– 1 1 2 3 5 8 13 21 34 55 89 ...– Number these from zero ==> F(6) = 13

• The definition is defined as follows:a0 = 1a1 = 1 an = an-1 + an-2

• As a function this becomes:int fib (int n){ if(n<2) return 1; return fib(n-1) + fib(n-2);}

• Is this better than the iterative one?

The Code

• Code:int fibo(int n){ if(n < 2) return 1; return fibo(n-1)+fibo(n-2);}

• What is wrong with this code?

Iterative Fibonacci• The iterative function:int fib2 (int n){ int first=1, second=1; int third = 1; while(--n>0){ third = first + second; first = second; second = third; } return third;}

So which of these is better

• The recursive is somewhat easier to read

• The iterative is much, much better from an execution point of view

• The recursive version re-computes what it has already computed– Several times

• Consider the following call graph

Fibonacci Call Graph

fib(6)

fib(4)

fib(2) fib(3)

fib(0) fib(1) fib(1) fib(2)

fib(5)

fib(3) fib(4)

fib(1) fib(2)fib(0)fib(1)

Fibonacci Discussion

• No re-using of calculated values• Fibo(2) is calculated twice • Fibonacci sequence should be

calculated from zero up• Using a loop

Tower of Hanoi• The legend:

– Buddhist monastery near Hanoi– 64 gold discs of descending size– Three pegs– Move the discs from one peg to another

• Rules– Only one disc can be moved at a time– A larger disk can not be put on a smaller– When they are all moved, world will end

• The solution is so inherently recursive that the loop solution is hard to see

Moving Process

• The moving process is inherently recursive

• There are two recursive calls– One before and one after the single

plate move

• The number of single plate moves is based on the plate number: 2N-1

• How many single plate moves to move a 64 plate stack?

Tower of Hanoi

Move the stack from A to B, using C as a temporary holder

Tower of Hanoi

Move 1 to C

Tower of Hanoi

Move 2 to B

Tower of Hanoi

Move 1 to B

Tower of Hanoi

Move 3 to C

Tower of Hanoi

Move 1 to A

Tower of Hanoi

Move 2 to C

Tower of Hanoi

Move 1 to C

Tower of Hanoi

Move 4 to BThis is the halfway move.

Tower of Hanoi

Move 1 to B

Tower of Hanoi

Move 2 to A

Tower of Hanoi

Move 1 to A

Tower of Hanoi

Move 3 to B

Tower of Hanoi

Move 1 to C

Tower of Hanoi

Move 2 to B

Tower of Hanoi

Move 1 to BDone

Solution• To move Disk N from A to B using C:

– Move 1 to N-1 to C– Move N to B– Move 1 to N-1 to B

• Each move of multiple disks is recursive

• Two recursive calls per loop makes this more exciting

The codevoid move(int disk, char from, char to, char temp) {/* move disk from peg from to peg to using temp as temporary peg */if (1 < disk)

move(disk-1,from,temp,to);cout << "Move disk "<<disk <<" from "<<from << " to " << toif (1 < disk)

move(disk-1,temp,to,from);}

Recursive Loops

• Recursion is the generalization of looping

• Normal loops– The body of the loop is executed in a

straight line fashion– No opportunity to re-execute until end

• Recursive loops– Always start at the beginning and end at

end– A new loop can be inserted anywhere in

the loop

Discussion• Consider the following function:int recfun(int p1){ A; B; C; return …; }– Where A, B, C are arbitrary

sequences of statements• Where could recursive calls to

recfun be put and what would happen?

Before or After•Inserting the call before or

after the sequence gives the following sequence:–ABCABCABCABC

•Similar to a loop around the seqence

•This is what was used in factorial

•Called head or tail recursion

Head and Tail Recursion

• The factorial function is an example of tail recursion

• Tail recursion is when the routine does everything and then the recursive call last

• Head recursion is doing the call first• Usually head and tail recursion may

be easily converted to loops

One Call Elsewhere•Suppose the call is between A

and B•Then we get:

–AAABCBCBC•Still one recursive call•Now it will take two different

loops•However any one call can be

replaced by one or more loops

Two Calls • Suppose there is a call between A

and B and another between B and C• Twice through we would get

something like:– AABCBABCC

• Two recursive calls• How would you loop this?• Three times through:

– AAABCBABCCBAABCBABCCC– Although other orders are possible

• These two calls are similar to Hanoi

Maze Searching

• In maze searching the problem is that we often come to a fork in the road

• The looping solution must pursue one of these and save the other for future exploration

• The recursive solution goes both ways at once

• Like pouring water into the maze

Maze Searching

• Suppose we have a maze• How does one search a maze?• There are always multiple ways to go• Multiple paths may work

How do you do it?

• The solution is like pouring water into the maze

• If you will pour water into a 3D version of this it will move it all directions at once

• Make a recursive calls that advances one square– One recursive call for each possible

direction

Maze Representation• Assume a 25 by 25 array of

character– Maze may be smaller with a count– Positions 0 through count actually

constitute array• Getting to row or column 0 or row or

column count indicates success• Blanks are paths• Asterisks or other non-blanks are

obstacles• May only move up, down, left or right

Overview Algorithm• The search function will be a boolean

function– True indicate a path found

• Parameters are the position• If the position is not blank return

immediately• Replace position with ‘0’• If on edge return true• If any of the four ways from here

works replace with ‘= ’

Quick Sort

• Uses both looping and recursion– Just like we should use all types of loops

• The sort function has two distinct phases:

• Partition the array into three pieces– The upper part of array– An item– The lower part of array

• Recursively sort upper and lower part

Partitioning• Initialize

– Choose a pivot, typically the first array element

– Set an index to top and bottom values of remaining array

• Loop until indices collide– Find an element that is larger than

pivot in top– Find an element that is smaller than

pivot in bottom– Swap the two

• Move pivot to correct location

At the end of partition phase

• The array has three pieces:• All the elements smaller than the

pivot are together at the top• All the elements larger than the pivot

are together at the bottom• The pivot is between them and in its

sorted position– It will never be moved or looked at again

• Then recursively sort the two pieces

Quick Sort

Start, pivot is 8start looking

1st exch2nd exch

Pivot exch

Donefound

Three partitions

Efficiency

• Quick sort does well because of this partitioning

• 2 * (½ N)2 < N2

• Since the partitioning is repeatedly applied, it collapses to N log2N

• The partitioning fails if the pivot is the smallest or largest

• Degenerates to N2 for sorted or inversely sorted arrays

Determinants

• A determinant is a single number computed from a square matrix

• It is used in Cramer’s rule to find solutions to systems of equations

• It is a measure of goodness of the matrix of numbers

• It is also computed recursively

Computation

• Use the method of sums of values times the products of smaller determinants– Expanded minors

• Definition: A minor– A smaller matrix where one row and

column are eliminated

The minor of a 4 by 4• Suppose that we have the following:

4 2 1 -36 -2 7 -49 -7 8 -55 0 3 10

• The minor eliminating position 1,1 is:

4 1 -39 8 -55 3 10

Computing the Determinant

• The determinant of a 1 by 1 is just the value of that cell– This is the non-recursive version

• For a larger determinant:– Take each member of a row – Multiply that member times the

determinant of the minor with this row and column eliminated

– If the sum of subscripts of the member are even then add otherwise subtract

A Determinant of a two by two

326462

A Determinant of a three by three

• A tree is a dynamic data structure• A tree is:

– Empty– Node with one or more sub-trees

• The sub-trees could be empty

Tree Processing• Trees are always ordered• There are several linear routines in

processing a tree– Adding a node to a tree– Searching a tree

• The iterator is a different story • While finding all of the items it must

go both ways – a classic reason for a recursive routine

• This is a better topic for the next class

Common trees

• Binary search trees – used in memory

• BTrees – disk based search trees• Trie – A combination of tree and

array• Parse trees

Recursive Descent Parsing

• Consider this portion of a grammar

function: header compound stmt

compound stmt: { }stmt

expression

if stmt

compound stmt

for stmt

The Parser• A recursive descent parser typically

has a function for each of the major constructs

• Thus for this language it would have:– Statement– Expression– CompoundStatement– IfStatement– ForStatement

• These would involve chains of recursive calls

Common Features

• The examples have this in common:• The recursive function often

generates more than one recursive call

• This makes it hard to generate an iterative solution

• However, there are one call functions that are hard to do iteratively as well

Languages

• Certain languages disallow recursion– FORTRAN– Older BASICs– COBOL

• Certain languages allow– The Pascal family– The C family

• Certain languages encourage– The LISP family

Automatic Variables

• Recursion is enabled by automatic variables

• Older versions of FORTRAN disallow recursion because it only had static variables

• Newer languages have automatic variables

• Each call of a function creates a separate copy of the parameters and local variables

• Recall the trace from before

Recall this trace5 int factorial(int n) { 6 if (n > 1) 7 return(factorial(n-1)*n);8 return(1);9 }...20 int f = factorial(4);

Return address

Function result

First Call

Return address

Function result

3Second Call

Return address

Function result

2Third Call

Function result

n1Fourth Call

7 Return address

Discussion

• In the previous trace there were four copies of n

• The ability to store local values is why recursion cannot be replaced by just looping

• Instead an auxiliary data structure• Recursion has that extra data

structure – the run-time stack

Converting Recursion to Looping

• The advantage that recursion has over looping is the storage of local variables and parameters on the stack

• In order to convert recursion to looping a secondary data structure is needed to hold the multiple processing opportunities

• Thus when the maze searcher wants to go four ways, it must save all four and then pick out one to pursue

• It is done when there is nothing left to check

Infinite Recursion

• Infinite recursion is similar to an infinite loop

• Just faster• What happens is that the stack space

is exhausted and rather quickly• What happens is that the recursive

paths to not move us closer to the non-recursive path

When to use Recursion

• When recursion is natural– The problem is inherently recursive– It should be easy to understand in this

situation

• No duplicate computation occurs• Iteration ends up being much more

complex– Needs an auxiliary data structure

• You are coding in LISP

Summary

• When it is easy always use looping• Looping can always be made faster• Recursion should be used when the

problem is inherently recursive• Properly used recursion will generally

be much more elegant than looping

Copyright © Curt Hill 2006-2007 Recursion A Different Way to Think and Solve Problems

Documents

Limitless and recursion-free recursion limits!

Recursion –a programming strategy for solving large problems –Think “divide and conquer” –Solve large problem by splitting into smaller problems of same

Recursion Chapter 11. The Basics of Recursion: Outline Introduction to Recursion How Recursion Works Recursion versus Iteration Recursive Methods That

Curt Westcott

Recursion - Basic and Complex Recursion - Lehighcoral.ie.lehigh.edu/~ted/files/ie172/lectures/recursionslides.pdf · Objectives What Is Recursion? Stack Frames: Implementing Recursion

Recursion Recursion Recursion Recursion Recursion Recursion Recursion Recursion Recursion

Recursion Road Map Introduction to Recursion Recursion Example #1: World’s Simplest Recursion Program Visualizing Recursion –Using Stacks Recursion Example

Recursion Recursion is the process of ... - cs.bgu.ac.ilipc191/wiki.files/Class_Java_6.pdf · Recursion in Java Recursion: Recursion is the process of defining something in terms

To Understand Recursion… Recursion – Real Life Examples

COSC 1P03 Data Structures and Abstraction 8.1 Recursion Recursion Recursion Recursion Recursion Recursion Recursion Recursion Recursion Just be thankful

Closed and Open Recursion · Open Recursion RALF HINZE Introduction Recursive functions Recursive objects Recursive functions revisited Conclusion Appendix Open recursion Open recursion

To Understand Recursion … Recursion –Real Life Examples · ¨ Recursion exercises ¨ … ¨ Final exam date is set: Sunday, May 21stat 2:00pm To Understand Recursion … 3 Recursion

Induction & Recursion Weiss: ch 7.1. Recursion –a programming strategy for solving large problems –Think “divide and conquer” –Solve large problem by

1 Chapter 11 l Basics of Recursion l Programming with Recursion Recursion

15-112 Fundamentals of Programming · Fundamentals of Programming Week 5 - Lecture 2: Recursion June 21, 2016. What is recursion? recursion (n): See recursion. What is recursion in

Recursion - George Mason Universitymarks/112/slides/8.recursion.pdf · Recursion •recursion: something defined in terms of itself. •function recursion: when a function calls itself

CS240 recursion Fall 2014 n -zh n] 1. See “recursion” Mike ... · CS240 Fall 2014 Mike Lam, Professor Recursion recursion n. [ri-kur-zhuh n] 1. See “recursion”

7 8 - Recursion · 2008-10-15 · recursion) to end recursion; otherwise infinite recursion Lecture 7 Object-Oriented Programming 6 Recursion • Recursion solves a problem by solving

RECURSION CITS1001. 2 Scope of this lecture Concept of recursion Simple examples of recursion

Chapter 17 Recursion. Chapter Scope The concept of recursion Recursive methods Infinite recursion When to use (and not use) recursion Using recursion