Recursion
Data and File Structures Laboratory
http://www.isical.ac.in/~dfslab/2018/index.html
DFS Lab (ISI) Recursion 1 / 20
Function calls
1 void main(void)
2 { ...
3 u = f(x, y*z);
4 ...
5 }
6
7 int f(int a, int b)
8 { ...
9 if (a > 0)
10 p = g(b);
11 else
12 p = h(b / 2);
13 return p;
14 }
15
16 int g(int m)
17 { ... }
18
19 int h(int n)
20 { ... }
DFS Lab (ISI) Recursion 2 / 20
Function calls
1 void main(void)
2 { ...
3 u = f(x, y*z); 1. Let a = x, b = y*z.
4 ...
5 } 2. Execute the statements in f().
6 (a) If a is positive, let m = b.
7 int f(int a, int b) Execute the statements in g(), and
8 { ...
store the obtained value in p.
9 if (a > 0)
10 p = g(b); (b) Otherwise, let n = b/2.
11 else Execute the statements in h(), and
12 p = h(b / 2); store the obtained value in p.
13 return p;
(c) In either case, return value of p to
14 }
15
calling function.
16 int g(int m)
17 { ... }
3. Store the value returned by f in u.
18 4. Continue from line 4.
19 int h(int n)
20 { ... }
DFS Lab (ISI) Recursion 2 / 20
Terminology
Caller
Callee
Formal parameters (or simply parameters)
Example: a, b – formal parameters for f
Actual parameters (or actuals / arguments)
Example: x, y*z – arguments passed to f on line 3
DFS Lab (ISI) Recursion 3 / 20
Call by value
Arguments evaluated, copied into local storage area of called function
Changes made to parameters in called function not reflected in caller
C — call by value,
DFS Lab (ISI) Recursion 4 / 20
Call by value
Arguments evaluated, copied into local storage area of called function
Changes made to parameters in called function not reflected in caller
C — call by value, but arrays are interpreted as pointers
DFS Lab (ISI) Recursion 4 / 20
Other parameter passing mechanisms
Call by reference: changes made to argument variables in callee are
reflected in caller
Call by name: parameters are literally replaced in body of callee by
arguments (like string replacement)
C macros use call by name
DFS Lab (ISI) Recursion 5 / 20
Passing parameters using pointers in C
For arrays
To “simulate” call by reference
For efficiency
DFS Lab (ISI) Recursion 6 / 20
Definition
A recursive function is a function that calls itself.
The task should be decomposable into sub-tasks that are smaller, but
otherwise identical in structure to the original problem.
The simplest sub-tasks (called the base case) should be (easily)
solvable directly, i.e., without decomposing it into similar
sub-problems.
DFS Lab (ISI) Recursion 7 / 20
Recursive vs. iterative implementations
1 int factorial ( int n ) {
2 int prod;
3
4 if (n < 0) return (-1);
5 prod = 1;
6 while (n > 0) {
7 prod *= n;
8 n = n - 1;
9 }
10 return (prod);
11 }
DFS Lab (ISI) Recursion 8 / 20
Recursive vs. iterative implementations
1 int factorial ( int n ) /* Recursive implementation */
2 {
3 if (n < 0) return (-1); /* Error condition */
4 if (n == 0) return (1); /* Base case */
5 return(n * factorial(n-1)); /* Recursive call */
6 }
DFS Lab (ISI) Recursion 9 / 20
Z curve
.
Problem statement
.
Consider a 2-D matrix of size 2m × 2m . The entries of the matrix are, in
row-major order, 1, 2, 3, . . . , 22m . Print the entries of the matrix in Z-curve
order (as shown in the picture below).
DFS Lab (ISI) Recursion 10 / 20
Z curve: structure
(0, 0) Problem structure:
Base case: single
element
Recursive structure:
break given square
into 4 sub-squares
process squares in
Z-curve order
(N − 1, N − 1)
DFS Lab (ISI) Recursion 11 / 20
Z curve: code I
void z_curve(int top_left_row, int top_left_column,
int bottom_right_row, int bottom_right_column,
int **matrix)
{
/* Base case */
if (top_left_row == bottom_right_row &&
top_left_column == bottom_right_column) {
printf("%d ", matrix[top_left_row][top_left_column]);
return;
}
/* Recurse */
/* upper-left sub-square */
z_curve(top_left_row,
top_left_column,
(top_left_row + bottom_right_row)/2,
(top_left_column + bottom_right_column)/2,
matrix);
DFS Lab (ISI) Recursion 12 / 20
Z curve: code II
/* upper-right sub-square */
z_curve(top_left_row,
(top_left_column + bottom_right_column)/2 + 1
(top_left_row + bottom_right_row)/2,
bottom_right_column,
matrix);
/* lower-left sub-square */
z_curve((top_left_row + bottom_right_row)/2 + 1,
top_left_column,
bottom_right_row,
(top_left_column + bottom_right_column)/2,
matrix);
/* lower-right sub-square */
z_curve((top_left_row + bottom_right_row)/2 + 1,
(top_left_column + bottom_right_column)/2 + 1,
bottom_right_row, bottom_right_column,
matrix);
return;
}
DFS Lab (ISI) Recursion 13 / 20
Permutations
.
Algorithm
.
To generate all permutations of 1, 2, 3, . . . , n, do the following:
1. Generate all permutations of 2, 3, . . . , n, and add 1 to the beginning.
2. Generate all permutations of 1, 3, 4, . . . , n and add 2 to the beginning.
...
n. Generate all permutations of 1, 2, . . . , n − 1 and add n to the
. beginning.
DFS Lab (ISI) Recursion 14 / 20
Permutations: code
void permute(int *A, int k, int n)
{
int i;
if(k==n) {
for (i = 0; i < n; i++) {
printf("%d ", A[i]);
}
putchar(’\n’);
return;
}
for(i = k; i < n; i++){
SWAP(A, i, k);
permute(A, k+1, n);
SWAP(A, k, i);
}
return;
}
DFS Lab (ISI) Recursion 15 / 20
Review question – slide I
Which of read data1, read data2, read data3 is best?
1 typedef struct {
2 char name[64];
3 int roll, rank;
4 float percent;
5 } STUDENT;
6
7 STUDENT *read_data1(void)
8 { STUDENT s;
9 scanf("%s %d %d %f",
10 &(s.name[0]), &(s.roll),
11 &(s.rank), &(s.percent));
12 return &s;
13 }
DFS Lab (ISI) Recursion 16 / 20
Review question – slide II
14
15 STUDENT read_data2(void)
16 { STUDENT s;
17 scanf("%s %d %d %f",
18 &(s.name[0]), &(s.roll),
19 &(s.rank), &(s.percent));
20 return s;
21 }
22
23 STUDENT *read_data3(STUDENT *s)
24 { scanf("%s %d %d %f",
25 &(s->name[0]), &(s->roll),
26 &(s->rank), &(s->percent));
27 return s;
28 }
DFS Lab (ISI) Recursion 17 / 20
Problems – I
1. Towers of Hanoi: see
https://en.wikipedia.org/wiki/Tower_of_Hanoi
CC BY-SA 3.0, https://commons.wikimedia.org/w/index.php?curid=228623
2. Write a recursive function with prototype int C(int n, int r); to
compute the binomial coefficient using the following definition:
( ) ( ) ( )
n n−1 n−1
= +
r r r−1
Supply appropriate boundary conditions.
DFS Lab (ISI) Recursion 18 / 20
Problems – II
3. Define a function G(n) as:
0 if n = 0
1 if n = 1
G(n) =
2 if n = 2
G(n − 1) + G(n − 2) + G(n − 3) if n ≥ 3
Write recursive and iterative (i.e., non-recursive) functions to compute
G(n).
DFS Lab (ISI) Recursion 19 / 20
Problems – III
4. What does the following function compute?
int f ( int n )
{
int s = 0;
while (n--) s += 1 + f(n);
return s;
}
5. http://cse.iitkgp.ac.in/~abhij/course/lab/PDS/Spring15/
A4.pdf
DFS Lab (ISI) Recursion 20 / 20
