1. CS 201 Computer Systems Programming Chapter 6 “Recursion”
Herbert G. Mayer, PSU CS
Status 9/27/2012

2. Syllabus Definition of Recursion Recursion vs. Iteration Q-Sequence
Ackermann Function
Simulate Recursion via Iteration
References

3. Definition of Recursion
An algorithms is recursive, if it is partly defined by simpler versions of itself [1]
A recursive program is an implementation of a recursive algorithm
What can user of a programming language do that is non-recursive (e.g. standard Fortran) and wishes to express a recursive algorithm in that very language? --See later!
What then are the other parts of a recursive algorithm?
Correct recursive algorithm requires a starting point, formally known as “base case”
Base case could be multiple steps
Recursive algorithm a() uses a base case as origin of computation, plus the actual function body, including some recursive use of a()
Recursive body can be indirectly recursive through intermediate function
a()-> b()-> a() – through intermediate function b()
Primitive examples are the factorial( n ) function; or Fibonacci( n ), for non-negative arguments n; the latter shown here:
Base case 1: Fibo(0) = 0
Base case 2: Fibo(1) = 1
Recursive Definition: Fibo( n ) for n > 1 = Fibo( n-1 ) + Fibo( n-2 )

4. Recursion vs. Iteration
Iteration is expressed in programming languages by loops; e.g. for-, while-, do-, or repeat loops
These are readable and efficient methods for expressing iteration, but are not necessary
Recursion can easily replace such iterative steps; yet for some people this seems hard to understand
In reality, neophytes are sometime unused to recursion; yet recursion can be as intuitive as the simplest iteration 

5. Q-Sequence, Definition
Q-Sequence defined by Douglas Hofstadter in [1] as a function q(n) for positive integers n > 0
Base case n = 1: q(1) = 1
Base case n = 2: q(2) = 1
Recursive definition of q(n), for positive n > 2
q( n ) = q( n – q( n - 1 ) ) + q( n – q( n - 2 ) )
Q-Sequence reminds us of Fibonacci( n ) function, but with surprising difference in the type of result:
The function results of Fibonacci( n ) are monotonically increasing with increasing argument
Results of q( n ) are non-monotonic!
Note also # of calls: calls(q( 40 ))=1,137,454,741

6. Q-Sequence, Coded in C #define MAX 100 // arbitrary limit
int calls; // will be initialized each time
int q( int arg )
{ // q
calls++; // track another call
if ( arg <= 2 ) {
return 1; // base case
}else{ // now recurse!
return q( arg - q( arg-1 ) ) + q( arg - q( arg-2 ) );
} //end if
} //end q
void main()
{ // main
for( int i = 1; i < MAX; i++ ) {
calls = 0; // initially no calls yet
printf( "Q(%2d) = %3d, #calls = %10d\n", i, q(i), calls );
} //end for
} // end main

7. Q-Sequence Results
Q( 1) = 1, #calls = Q( 2) = 1, #calls = Q( 3) = 2, #calls = Q( 4) = 3, #calls = Q( 5) = 3, #calls = Q( 6) = 4, #calls = Q( 7) = 5, #calls = Q( 8) = 5, #calls = Q( 9) = 6, #calls = Q(10) = 6, #calls = Q(11) = 6, #calls =
. . .
Q(26) = 14, #calls = Q(27) = 16, #calls = Q(28) = 16, #calls = Q(29) = 16, #calls = Q(30) = 16, #calls = Q(31) = 20, #calls = Q(32) = 17, #calls = Q(33) = 17, #calls = Q(34) = 20, #calls = Q(35) = 21, #calls = Q(36) = 19, #calls = Q(37) = 20, #calls = Q(38) = 22, #calls = Q(39) = 21, #calls = Q(40) = 22, #calls =
. . . Will never reach Q(100) in your life time 

8. Ackermann Definition
Ackermann a( m, n ) is defined as a function of two non-negative integers m and n
Base case 1: a( 0, n ) = n + 1
Base case 2: a( m, 0 ) = a( m - 1, 1 )
Recursive definition of a( m, n ), m, n > 0
a( m, n ) = a( m - 1, a( m, n - 1 ) )
Ackermann complexity grows awfully fast; e.g. a(4,2) is an integer number with 19,729 decimal digits; greater than the US debt!

9. Ackermann Coded in C unsigned a( unsigned m, unsigned n ) { // a
calls++; // global unsigned
if ( 0 == m ) { // note operand order
return n + 1; // first base case
}else if ( 0 == n ) { // m > 0
return a( m - 1, 1 ); // other base case
}else{ // m > 0, n > 0
return a( m-1, a( m, n-1 ) ); // recurse!
} //end if
} //end q
void main()
{ // main
for( int i = 0; i < MAX; i++ ) {
printf( "\nFor m = %d\n", i );
for( int j = 0; j < MAX; j++ ) {
calls = 0;
printf( "a(%1d,%1d) = %10u, calls = %12u\n",
i, j, a( i, j ), calls );
} //end for
} // end main

10. Ackermann Results For m = 0 a(0,0) = 1, calls = 1 . . .
a(1,7) = , calls = For m = 2 a(2,0) = , calls = a(2,1) = , calls = a(2,2) = , calls = a(2,3) = , calls = a(2,4) = , calls = a(2,5) = , calls = a(2,6) = , calls = a(2,7) = , calls = For m = 3 a(3,0) = , calls = a(3,1) = , calls = a(3,2) = , calls = a(3,3) = , calls = a(3,4) = , calls = a(3,5) = , calls = a(3,6) = , calls = a(3,7) = , calls = For m = 4 a(4,0) = , calls =
don’t even dream about computing a(4,2)  or higher!

11. Simulate Recursion via Iteration
Important to understand for systems programmer
What to do, if you implement a recursive algorithm using a language that does not support recursion?
Replace the recursive by a non-recursive algorithm!
Or simulate recursion via non-recursive methods
After all, a computer chip has no notion of recursion; it is a sequential machine that “simulates recursion” via non-recursive methods; the compiler plus run- time system perform this transformation!
Done so at local industry in the past: FPS used Fortran to implement System SW and compilers
Here are the actual steps of simulating recursion via iteration; good to use a language with Goto:

12. Steps of Simulating Recursion
consider directly-recursive calls, i.e. calls from within recursive function:
Define explicit stack with top of stack (tos) index, initially tos=0; like a real stack, it may overflow, you better include code to check; holds all parameters, function return value, return location (labels after a recursive call), and automatic locals
Define labels for each point of recursive call, more precisely at each point of return; number these labels, for example l1, l2, l3 etc. There will be branches to these points of return
At each point of recursive call:
Increment the tos: tos++
Manually move parameters for “this call” onto stack; e.g.
stack[ tos ].arg1 = … stack[ tos ].arg2 = …
Store the place of return:
stack[ tos ].ret = 1, or 2, or 3 alluding to l1, l2, l3
Initialize local, automatic objects
Jump to the head of the function, not including initializing code

13. Steps of Simulating Recursion
4. Ideally, all explicitly coded returns and the implied return at the end of the recursive function body can be re-coded into a single place; if not, the code before each return is replicated:
Decrement the top of stack index: tos--
Check, to which of the stored labels the flow of control has to branch=goto to continue execution; e.g.:
if ( stack[ tos ].ret == xyz ) goto label_xyz;
And if no other branch is open, then fall through the end
For void functions this is a literal fall-through
For true functions, the return value has to be computed before the fall-through, e.g.:
stack[ tos ].return_val = …
5. For nested recursive calls or several recursive calls in a row or both: “be creative”  ; see an example later

14. Simulate Recursion, fact()
#include <stdio.h>
#define MAX_STACK 100 // never reached or exceeded!
#define MAX 14 // higher factorial overflows 32bits
unsigned calls; // track # of calls
typedef struct s_tp {
unsigned arg;
unsigned fact;
unsigned ret;
} struct_s_tp;
// first the recursive fact() function for reference
// includes tracking # of calls
unsigned fact( unsigned arg )
{ // fact
calls++; // gotta be global
if ( 0 == arg ) { // why strange order?
return 1;
}else{
return fact( arg - 1 ) * arg;
} //end if
} //end fact

15. Simulate Recursion, fact()
unsigned nrfact( unsigned arg )
{ // nrfact
struct_s_tp s[ MAX_STACK ]; // local stack, no recursion!
unsigned top = 0;
s[ top ].arg = arg; // this call’s argument
s[ top ].ret = 3; // 3 alludes to label l3
l1: if ( 0 == s[ top ].arg ) {
s[ top ].fact = 1;
}else{
top++; // recurse soon
s[ top ].arg = s[ top-1 ].arg-1;
s[ top ].ret = 2; // remember label l2
goto l1; // here simulate recursion
l2:
// back from recursive call.
top--; // back from call
s[ top ].fact = s[ top + 1 ].fact * s[ top ].arg;
} //end if
if ( s[ top ].ret == 2 ) { // test, where to branch to
goto l2; // unstructured goto into if
l3:
return s[ top ].fact;
} //end nrfact

16. Simulate Recursion, fact() Result
r_fact( 0) = , calls = r_fact( 1) = , calls = r_fact( 2) = , calls = r_fact( 3) = , calls = r_fact( 4) = , calls = r_fact( 5) = , calls = r_fact( 6) = , calls = r_fact( 7) = , calls = r_fact( 8) = , calls = r_fact( 9) = , calls = r_fact(10) = , calls = r_fact(11) = , calls = r_fact(12) = , calls = r_fact(13) = , calls = nr_fact( 0) = nr_fact( 1) = nr_fact( 2) = nr_fact( 3) = nr_fact( 4) = nr_fact( 5) = nr_fact( 6) = nr_fact( 7) = nr_fact( 8) = nr_fact( 9) = nr_fact(10) = nr_fact(11) = nr_fact(12) = nr_fact(13) =

17. Simulate Recursion, fibo()
#define MAX_STACK 100 // never to be reached or exceeded!
#define MAX 30 // higher fibo(n) not computed
unsigned calls; // in case we track # of calls
typedef struct s_tp { // type of stack
unsigned arg; // copy of fibo’s arg
unsigned fibo; // return value for fibo
unsigned ret; // to which label to goto?
} struct_s_tp;
// recursive function for reference:
unsigned fibo( unsigned arg )
{ // fibo
calls++;
if ( arg <= 1 ) { // base case?
return arg; // if so: done
}else{
return fibo( arg-1 ) + fibo( arg-2 );
} //end if
} //end fibo

18. Simulate Recursion, fibo()
unsigned nr_fibo( unsigned arg )
{ //nr_fibo
struct_s_tp s[ MAX_STACK ]; // stack can be local
unsigned top = 0; // initially
s[ top ].arg = arg; // copy arg to stack
s[ top ].ret = 4; // if all fails, return
l1: if ( s[ top ].arg <= 1 ) {
s[ top ].fibo = s[ top ].arg;
}else{
top++; // ready to recurse
s[ top ].arg = s[ top - 1 ].arg - 1;
s[ top ].ret = 2; // to place of 1. return
goto l1; // recurse
l2: top++; // ready to recurse again
s[ top ].arg = s[ top - 2 ].arg - 2;
s[ top ].ret = 3; // to place of 2nd return
l3: // two returns simulated
top -= 2; // simulate 2 returns
s[ top ].fibo = s[ top+1 ].fibo + s[ top+2 ].fibo;
} //end if
if ( 2 == s[ top ].ret ) { // second recursive call
goto l2;
}else if ( 3 == s[ top ].ret ) {
goto l3;
l4: return s[ top ].fibo; // all done
} //end nr_fibo

19. Simulate Recursion, fibo() Result
r_fibo( 0) = , calls = r_fibo( 1) = , calls = r_fibo( 2) = , calls =
r_fibo( 3) = , calls = r_fibo( 4) = , calls =
r_fibo(22) = , calls = r_fibo(23) = , calls = r_fibo(24) = , calls = r_fibo(25) = , calls = r_fibo(26) = , calls = r_fibo(27) = , calls = r_fibo(28) = , calls = r_fibo(29) = , calls = nr_fibo( 0) = nr_fibo( 1) = nr_fibo( 2) = nr_fibo( 3) = nr_fibo( 4) =
nr_fibo(22) = nr_fibo(23) = nr_fibo(24) = nr_fibo(25) = nr_fibo(26) = nr_fibo(27) = nr_fibo(28) = nr_fibo(29) =

20. Simulating Return of fibo()
Must the computation of the continuation place be after the if-statement? Or can we relocate it into the Else-Clause?
That would lead to a partial simulation, in which only the case arg > 1 continues correctly
Yet even cases for arg <= 1 must compute the right continuation via (unstructured) brute-force gotos:
if ( 2 == s[ top ].ret ) { // second recursive call
goto l2;
}else if ( 3 == s[ top ].ret ) {
goto l3;
} //end if

21. Simulate Recursion, fibo2()
unsigned nr_fibo2( unsigned arg )
{ //nr_fibo2
struct_s_tp s[ MAX_STACK ]; // stack can be local
unsigned top = 0; // initially
s[ top ].arg = arg; // copy arg to stack
s[ top ].ret = 4; // if all fails, return
l1: if ( s[ top ].arg <= 1 ) {
s[ top ].fibo = s[ top ].arg;
if ( 2 == s[ top ].ret ) { // second recursive call
goto l2;
}else if ( 3 == s[ top ].ret ) {
goto l3;
} //end if
}else{
top++; // ready to recurse
s[ top ].arg = s[ top - 1 ].arg - 1;
s[ top ].ret = 2; // to place of 1. return
goto l1; // recurse
l2: top++; // ready to recurse again
s[ top ].arg = s[ top - 2 ].arg - 2;
s[ top ].ret = 3; // to place of 2nd return
l3: // two returns simulated
top -= 2; // simulate 2 returns
s[ top ].fibo = s[ top+1 ].fibo + s[ top+2 ].fibo;
l4: return s[ top ].fibo; // all done
} //end nr_fibo2

22. Towers of Hanoi
The game of the “Towers of Hanoi” is a game to move a stack of discs, while obeying certain rules
All n discs are of different sizes, residing on top of one another, always a smaller disc on top of a larger one
The goal is to move the whole tower from start, to the goal position, using one additional buffer location
But only moving 1 single disc at a time
And never placing a larger disc on top of a smaller one
During various times, any disc may be placed on the start position, the goal, or the buffer

23. Towers of hanoi(), Recursive
#include <iostream.h>
#define MAX … some small integer < 32
void hanoi( int discs, char* start, char* goal, char* buff )
{ // hanoi
if ( discs > 0 ){
hanoi( discs-1, start, buff, goal );
cout << "move disc " << discs << " from " << start << " to “
<< goal << endl;
hanoi( discs-1, buff, goal, start );
} //end if
} // end hanoi
int main()
{ // main
for ( int discs = 1; discs <= MAX; discs++ ) {
cout << ” hanoi for " << discs << " discs" << endl;
hanoi( discs, "start", "goal ", "buff " );
cout << endl;
} //end for
return 0;
} //end main

24. Towers of hanoi(), Output Rec.
move disc 1 from start to goal < For 1 disc
move disc 1 from start to buff < For 2 discs
move disc 2 from start to goal
move disc 1 from buff to goal
move disc 1 from start to goal < For 3 discs
move disc 2 from start to buff
move disc 1 from goal to buff
move disc 3 from start to goal
move disc 1 from buff to start
move disc 2 from buff to goal
move disc 1 from start to goal
move disc 1 from start to buff < For 4 discs
move disc 3 from start to buff
move disc 1 from goal to start
move disc 2 from goal to buff
move disc 1 from start to buff
move disc 4 from start to goal
move disc 2 from buff to start
move disc 3 from buff to goal

25. Simulate Recursion, hanoi()
void nr_hanoi( unsigned discs, char* start, char* goal, char* buff )
{ // nr_hanoi
struct_h_type s[ MAX_STACK ]; unsigned top = 0;
s[ top ].discs = discs;
s[ top ].start = start;
s[ top ].buff = buff;
s[ top ].goal = goal;
s[ top ].ret = 4;
l1: if ( s[ top ].discs > 0 ) {
top++;
s[ top ].discs = s[ top-1 ].discs - 1;
s[ top ].start = s[ top-1 ].start;
s[ top ].buff = s[ top-1 ].goal;
s[ top ].goal = s[ top-1 ].buff;
s[ top ].ret = 2;
goto l1;
l2: cout << "nr move disc “ << s[ top ].discs << “ from “
<< s[ top ].start << “ to “ << s[ top ].goal << endl;
s[ top ].start = s[ top-1 ].buff;
s[ top ].buff = s[ top-1 ].start;
s[ top ].goal = s[ top-1 ].goal;
s[ top ].ret = 3;
} //end if
l3: if ( 2 == s[ top ].ret ) {
top--;
goto l2;
}else if ( 3 == s[ top ].ret ) {
goto l3;
} //end nr_hanoi

26. References
Douglas R. Hofstadter, “Gödel, Escher, Bach: an eternal golden braid”, Basic Books, 1999, ISBN
Ackermann functiona at NIST:
Herbert G Mayer: “Advanced C Programming on the IBM PC”, 1989, Windcrest, ISBN
Non-recursive solution to Towers of Hanoi: