Data Structures and Algorithms

Recursion
The mirrors
Acknowledgement
 The contents of these slides have origin from
School of Computing, National University of
Singapore.
 We greatly appreciate support from Mr. Aaron
Tan Tuck Choy, and Dr. Low Kok Lim for
kindly sharing these materials.

2
Policies for students
 These contents are only used for students
PERSONALLY.
 Students are NOT allowed to modify or
deliver these contents to anywhere or anyone
for any purpose.

3
Objectives
• Strengthening the concept of recursion
1 learned in 501042 (or equivalent)

• Demonstrating the application of recursion

2 on some classic computer science problems

• Applying recursion on data structures

3

• Understanding recursion as a problem-

solving technique known as divide-and-
4 conquer paradigm

[501043 Lecture 10: Recursion]

4
References

Book
• Chapter 3: Recursion: The Mirrors
• Chapter 6: Recursion as a
Problem-Solving Technique, pages
337 to 345.

[501043 Lecture 10: Recursion]

5
Outline
1. Basic Idea
2. How Recursion Works?
3. Examples
 Count down
 Display an integer in base b
 Printing a Linked List
 Printing a Linked List in reverse order
 Inserting an element into a Sorted Linked List
 Towers of Hanoi
 Combinations: n choose k
 Binary Search in a Sorted Array
 Kth Smallest Number
 Permutations of a string
 The 8 Queens Problem

[501043 Lecture 10: Recursion]

6
1 Basic Idea

Also known as a central idea in CS

 1.1 Pictorial examples
Some examples of recursion (inside and outside CS):

Garfield dreaming
recursively.

Sierpinksi triangle

Droste effect
Recursive tree

Recursion is the process of repeating items in a self-

similar way but with smaller size.

[501043 Lecture 10: Recursion]

8
 1.2 Textual examples
Definitions based on recursion:
Dictionary entry:
Recursive definitions: Recursion: See recursion.
1. A person is a descendant of another if
 the former is the latter’s child, or
 the former is one of the descendants of the latter’s child.
2. A list of numbers is
 a number, or
 a number followed by a list of numbers.
To understand
Recursive acronyms:
recursion, you must
1. GNU = GNU’s Not Unix first understand
2. PHP = PHP: Hypertext Preprocessor
recursion.

[501043 Lecture 10: Recursion]

9
1.3 Divide-and-Conquer
 Divide: In top-down design (for program design or
problem solving), break up a problem into sub-problems
of the same type.
 Conquer: Solve the problem with the use of a function
that calls itself to solve each sub-problem
 one or more of these sub-problems are so simple that they can
be solved directly without calling the function
A paradigm where
the solution to a problem
depends on
solutions to smaller instances
of the SAME problem.

[501043 Lecture 10: Recursion]

10
1.4 Why recursion?
 Many algorithms can be expressed naturally in
recursive form
 Problems that are complex or extremely difficult
to solve using linear techniques may have
simple recursive solutions
 It usually takes the following form:
SolveIt (problem) {
if (problem is trivial) return result;
else { Calls itself!
simplify problem;
return SolveIt (simplified problem) ;
}
}
[501043 Lecture 10: Recursion]
11
2 How Recursion Works

Understanding Recursion
2.1 Recursion in 501042
 In 501042, you learned simple recursion
 No recursion on data structures
 Code consists of ‘if’ statement, no loop
 How to trace recursive codes
 Examples covered in 501042
 Factorial (classic example)
 Fibonacci (classic example)
 Greatest Common Divisor (classic example)
 Other examples

[501043 Lecture 10: Recursion]

13
2.1 Recursion in 501042: Factorial (1/2)
𝑛 !=
{ 1 , 𝑛=0
¿ 𝑛× ( 𝑛 − 1 ) × ⋯ × 2× 1 ,𝑛> 0
𝑛 !=
{ 1, 𝑛=0
¿ 𝑛× ( 𝑛 − 1 ) ! , 𝑛>0

Iterative solution
Recurrence relation
// Precond: n >= 0 // Precond: n >= 0
int fact(int n) { int fact(int n) {
int result = 1; if (n == 0)
for (int i=1;i<=n;i++) return 1;
result *= i; else
return result; return n * fact(n-
} 1);
}
Remember to document pre-conditions,
which are common for recursive codes. Base
Recursive case
call
[501043 Lecture 10: Recursion]
14
2.1 Recursion in 501042: Factorial (2/2)
120 Tracing recursion
fact(5) 5* fact(4) 24
fact(n):
if (n == 0) return 1;
4* fact(3)
6 else return n * fact(n-1);

3* fact(2)
2

2* fact(1)
1

1* fact(0) 1
1

[501043 Lecture 10: Recursion]

15
 2.1 Recursion in 501042: Fibonacci (1/4)
 Fibonacci numbers: 1, 1, 2, 3, 5, 8, 13, 21, …
 The first two Fibonacci numbers are both 1 (arbitrary numbers)
 The rest are obtained by adding the previous two together.
 Calculating the nth Fibonacci number recursively:
Fib(n) = 1 for n=1, 2
= Fib(n-1) + Fib(n-2) for n > 2

Elegant but extremely

// Precond: n > 0
inefficient. Which is correct?
int fib(int n) {
if (n <= 2) 1. Recursion doesn’t reach
return 1; base case
else 2. A lot of repeated work
return fib(n-1) + fib(n-2); 3. Should put recursive
} case above base case

[501043 Lecture 10: Recursion]
16
2.1 Recursion in 501042: Fibonacci (2/4)
Tracing recursive fib(6)
Three duplicate
calls to fib(3)!
Fibonacci:
fib(5) fib(4)

fib(4) fib(3) fib(3) fib(2)

fib(3) fib(2) fib(2) fib(1) fib(2) fib(1)

fib(2) fib(1)  Note the many duplicated fib()’s!

 The same computations are done
over and over again!
[501043 Lecture 10: Recursion]
17
 2.1 Recursion in 501042: Fibonacci (3/4)
Iterative Fibonacci
int fib(int n) { Q: Which part of the
if (n <= 2) code is the key to the
return 1; improved efficiency?
else {
int prev1=1, prev2=1, curr;
for (int i=3; i<=n; i++) {
(1) Part A (red)
curr = prev1 + prev2; (2) Part B (blue)
prev2 = prev1;
prev1 = curr;
}
return curr;
}
}


[501043 Lecture 10: Recursion]
18
 2.1 Recursion in 501042: Fibonacci (4/4)
 Closed-form formula for Fibonacci numbers
 Take the ratio of 2 successive Fibonacci numbers (say A and B).
The bigger the pair of numbers, the closer their ratio is to the
Golden ratio j which is  1.618034…

A 2 3 5 8 … 144 233
B 3 5 8 13 … 233 377
B/A 1.5 1.666… 1.6 1.625 … 1.61805… 1.61802…

 Using j to compute the Fibonacci number xn:

See
http://www.maths.surrey.ac.uk/hosted-sites/R.Knott/Fibonacci/fibFormula.html

[501043 Lecture 10: Recursion]

19
 2.1 Recursion in 501042: GCD (1/2)
 Greatest Common Divisor of two integers a and b,
where a and b are non-negative and not both zeroes
 Iterative method given in Practice Exercise 11

// Precond: a, b non-negative,
// not both zeroes
int gcd(int a, int b) {
int rem;
while (b > 0) {
rem = a % b;
a = b;
b = rem;
}
return a;
}

[501043 Lecture 10: Recursion]

20
 2.1 Recursion in 501042: GCD (2/2)
 Recurrence relation:
gcd(a, b) = a, if b = 0
gcd(b, a%b), if b > 0

// Precond: a, b non-negative,
// not both zeroes
int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}

[501043 Lecture 10: Recursion]

21
 2.2 Visualizing Recursion
Artwork credit: ollie.olarte

 It’s easy to visualize the execution of non-

recursive programs by stepping through the
source code.
 However, this can be confusing for programs
containing recursion.
 Have to imagine each call of a method generating a
copy of the method (including all local variables), so
that if the same method is called several times,
several copies are present.

[501043 Lecture 10: Recursion]

22
2.2 Stacks for recursion visualization
int j = fact(5) Use
push() for new recursive call
fact(0) 1
pop() to return a value from
fact(1) 1 1
a call to the caller.

fact(2) 2 1 Example: fact (n)

if (n == 0) return 1;
fact(3) 3 2 else return n * fact (n-1);
fact(4) 4 6

fact(5) 5  24 j =120

[501043 Lecture 10: Recursion]

23
2.3 Recipe for Recursion
Sometimes we call #1
the “inductive step”

To formulate a recursive solution:

1. General (recursive) case: Identify “simpler”
instances of the same problem (so that we can
make recursive calls to solve them)
2. Base case: Identify the “simplest” instance (so
that we can solve it without recursion)
3. Be sure we are able to reach the “simplest”
instance (so that we will not end up with infinite
recursion)

[501043 Lecture 10: Recursion]

24
 2.4 Bad Recursion
funct(n) = 1 if (n==0)
= funct(n – 2)/n if (n>0)

Q: What principle does the above code violate?

1. Doesn’t have a simpler step.
2. No base case.
3. Can’t reach the base case.
4. All’s good. It’s a ~trick~!


[501043 Lecture 10: Recursion]
25
3 Examples

How recursion can be used

 3.1 Countdown
Example 1

CountDown.java
public class CountDown {

public static void countDown(int n) {

if (n <= 0) // don’t use == (why?)
System.out.println (“BLAST OFF!!!!”);
else {
System.out.println("Count down at time " + n);
countDown(n-1);
}
}

public static void main(String[] args) {

countDown(10);
}
}


[501043 Lecture 10: Recursion]
27
 3.2 Display an integer in base b
Example 2

 See ConvertBase.java
E.g. One hundred twenty three is 123 in base 10; 173 in base 8
public static void displayInBase(int n, int base) {
if (n > 0) {
What is the
displayInBase(n / base, base);
System.out.print(n % base); precondition for
parameter base?
}
}

Example 1: Example 2:
n = 123, base = 8
n = 123, base = 10 123/8 = 15 123 % 8 = 3
123/10 =12 123 % 10 = 3 15/8 = 1 15 % 8 = 7
12/10 = 1 12 % 10 = 2 1/8 = 0 1 % 8 = 1
1/10 = 0 1 % 10 = 1 Answer: 173
Answer: 123
[501043 Lecture 10: Recursion]
28
 3.3 Printing a Linked List recursively
Example 3

 See SortedLinkedList.java and TestSortedList.java

public static void printLL(ListNode n) {
if (n != null) {
System.out.print(n.value); Q: What is the base case?
printLL(n.next);
} Q: How about printing in reverse order?
} head
printLL (head)  printLL
5
printLL
Output:
8
5 8 9 printLL

9
printLL
[501043 Lecture 10: Recursion]
29
 3.4 Printing a Linked List recursively in
Example 4

reverse order
 See SortedLinkedList.java and TestSortedList.java
public static void printRev
printLL (ListNode n) {
if (n!=null) {
printRev(n.next);
System.out.print(n.value); Just change the name!
System.out.print(n.value);
printRev
printLL (n.next); … Sure, right!
} head
}
printRev(head)  printRev
5
printRev
Output:
8
9 8 5 printRev

9
printRev
[501043 Lecture 10: Recursion]
30
 3.5 Sorted Linked List Insertion (1/2)
Example 5

 Insert an item v into the sorted linked list with head p

Case 1: Tail insertion

v
p == null

Case 2: Insert before p

insert(p,v)
v < p.element
v p.element

v >= p.element
Case 3: Insert after p (recursion)
p.element

p.next p.element
insert ( p.next ,v)

[501043 Lecture 10: Recursion]

31
 3.5 Sorted Linked List Insertion (2/2)
Example 5

public static ListNode insert(ListNode p, int v) {

// Find the first node whose value is bigger than v
// and insert before it.
// p is the “head” of the current recursion.
// Returns the “head” after the current recursion.
if (p == null || v < p.element)
return new ListNode(v, p);
else {
p.next = insert(p.next, v);
return p;
} To call this method:
} head = insert(head, newItem);

[501043 Lecture 10: Recursion]

32
 3.6 Towers of Hanoi
Example 6

 Given a stack of discs on peg A, move them to

peg B, one disc at a time, with the help of peg C.
 A larger disc cannot be stacked onto a smaller
one.
Only the
first 3 steps
initial state
shown.
A B C

final state
A B C

[501043 Lecture 10: Recursion]

33
 3.6 Towers of Hanoi – Quiz
Example 6

 What’s the base case?

 A: 1 disc
 B: 0 disc
From en.wikipedia.org
 What’s the inductive step?
 A: Move the top n-1 disks to another peg
 B: Move the bottom n-1 disks to another peg
 How many times do I need to call the inductive
step?
 A: Once
 B: Twice
 C: Three times


[501043 Lecture 10: Recursion]
34
 3.6 Tower of Hanoi solution
Example 6

public static void Towers(int numDisks, char src, char dest, char temp) {
if (numDisks == 1) {
System.out.println("Move top disk from pole " + src + " to pole " + dest);
} else {
Towers(numDisks – 1, src, temp, dest); // first recursive call
Towers(1, src, dest, temp);
Towers(numDisks – 1, temp, dest, src); // second recursive call
}
}

[501043 Lecture 10: Recursion]

35
 3.6 Tower of Hanoi iterative solution (1/2)
Example 6

public static void LinearTowers(int orig_numDisks, char orig_src,

char orig_dest, char orig_temp) {
int numDisksStack[] = new int[100]; // Maintain the stacks manually!
char srcStack[] = new char[100];
char destStack[] = new char[100];
char tempStack[] = new char[100];
int stacktop = 0;
numDisksStack[0] = orig_numDisks; // Init the stack with the 1st call
srcStack[0] = orig_src;
destStack[0] = orig_dest;
tempStack[0] = orig_temp; Complex!
stacktop++; This and the next slide are
only for your reference.

[501043 Lecture 10: Recursion]

36
 3.6 Tower of Hanoi iterative solution (2/2)
Example 6

while (stacktop>0) {
stacktop--; // pop current off stack
int numDisks = numDisksStack[stacktop];
char src = srcStack[stacktop]; char dest = destStack[stacktop];
char temp = tempStack[stacktop];
if (numDisks == 1) {
System.out.println("Move top disk from pole "+src+" to pole "+dest);
} else {
/* Towers(numDisks-1,temp,dest,src); */ // second recursive call
numDisksStack[stacktop] = numDisks -1;
srcStack[stacktop] = temp; Q: Which version runs faster?
destStack[stacktop] = dest; A: Recursive
tempStack[stacktop++] = src;
/* Towers(1,src,dest,temp); */ B: Iterative (this version)
numDisksStack[stacktop] =1;
srcStack[stacktop] = src; destStack[stacktop] = dest;
tempStack[stacktop++] = temp;
/* Towers(numDisks-1,src,temp,dest); */ // first recursive call
numDisksStack[stacktop] = numDisks -1;
srcStack[stacktop] = src; destStack[stacktop] = temp;
tempStack[stacktop++] = dest;
}
}
[501043 Lecture 10: Recursion]
37
 3.6 Towers of Hanoi
Example 6

Towers(4, src, dest, temp)

3 src temp dest

1 src dest temp
3 temp dest src

numDiskStack srcStack destStack tempStack

[501043 Lecture 10: Recursion]

 3.6 Time Efficiency of Towers()
Example 6

Num of discs, n Num of moves, f(n) Time (1 sec per move)

1 1 1 sec
2 3 3 sec
3 3+1+3 = 7 7 sec
4 7+1+7 = 15 15 sec
5 15+1+15 = 31 31 sec

6 31+1+31 = 63 1 min
… … …
16 65,536 18 hours
32 4.295 billion 136 years
64 1.8 × 1010 billion 584 billion years
N 2N – 1

[501043 Lecture 10: Recursion]

39
 3.7 Being choosy…
Example 7

Suppose you visit an ice cream

store with your parents.
You’ve been good so they let
you choose 2 flavors of ice
cream.
The ice cream store stocks 10
“Photo” credits: Torley
(this pic is from 2nd life) flavors today. How many
different ways can you choose
your ice creams?

[501043 Lecture 10: Recursion]

40
 3.7 n choose k
Example 7

 See Combination.java

X selected
choose k-1 out of n-1

or
choose k out of n

X not selected choose k out of n-1

k==n k==0 public static int choose(int n, int k) {

if (k>n) return 0;
if (k==n || k==0) return 1;
return choose(n-1, k-1) + choose(n-1, k);
1 1 }

[501043 Lecture 10: Recursion]

41
 3.7 Compute c(4,2)
Example 7

c(4,2)
Return c(3,1) + c(3,2)

c(3,1) c(3,2)
Return c(2,0) + c(2,1) Return c(2,1) + c(2,2)

c(2,0) c(2,1) c(2,1) c(2,2)

Return 1 Return c(1,0) + c(1,1) Return c(1,0) + c(1,1) Return 1

c(1,0) c(1,1) c(1,0) c(1,1)

Return 1 Return 1 Return 1 Return 1


[501043 Lecture 10: Recursion]
42
 3.8 Searching within a sorted array
Example 8

 Idea: narrow the search space by half at

every iteration until a single element is
reached.
Problem: Given a sorted int array a of n
elements and int x, determine if x is in a.
a= 1 5 6 13 14 19 21 24 32

x = 15

[501043 Lecture 10: Recursion]

43
 3.8 Binary Search by Recursion
Example 8

public static int binarySearch(int [] a, int x, int low, int high)

throws ItemNotFound {
// low: index of the low value in the subarray
// high: index of the highest value in the subarray
if (low > high) // Base case 1: item not found
throw new ItemNotFound("Not Found");
Q: Here, do we assume
int mid = (low + high) / 2; that the array is sorted
if (x > a[mid]) in ascending or
return binarySearch(a, x, mid + 1, high); descending order?
A: Ascending
else if (x < a[mid]) B: Descending
return binarySearch(a, x, low, mid - 1);
else
return mid; // Base case 2: item found
}

[501043 Lecture 10: Recursion]

44
 3.8 Auxiliary functions for recursion
Example 8

 Hard to use this function as it is.

 Users just want to find something in an array.
They don’t want to (or may not know how to)
specify the low and high indices.
 Write an auxiliary function to call the recursive function
 Using overloading, the auxiliary function can have the
same name as the actual recursive function it calls

boolean binarySearch(int[] a, int x) {

Auxiliary return binarySearch(a, x, 0, a.length-1);
function }
Recursive function
[501043 Lecture 10: Recursion]
45
 3.9 Find kth smallest (unsorted array)
Example 9

public static int kthSmallest(int k, int[] a) { // k >= 1

// Choose a pivot element p from a[]
// and partition (how?) the array into 2 parts where Map the lines to the
// left = elements that are <= p
// right = elements that are > p slots
… A: 1i, 2ii, 3iii, 4iv, 5v
int numLeft = sizeOf(left); B: 1i, 2ii, 3v, 4iii, 5iv
if (1_________) 3__________; C: 1ii, 2i, 3v, 4iii, 5iv
if (2_________) { D: 1i, 2ii, 3v, 4iv, 5iii
return 4_________;
else where
return 5_________; i. k == numLeft
} ii. k < numLeft
iii. return kthSmallest(k, left);
left right
iv. return kthSmallest(k – numLeft, right);
v. return p;
p

[501043 Lecture 10: Recursion]
46
 3.10 Find all Permutations of a String (1/3)
Example 10

 For example, if the user types a word say east, the

program should print all 24 permutations (anagrams),
including eats, etas, teas, and non-words like tsae.
 Idea to generate all permutation:
 Given east, we would place the first character i.e. e in front of all 6
permutations of the other 3 characters ast — ast, ats, sat, sta, tas,
and tsa — to arrive at east, eats, esat, esta, etas, and etsa, then
 we would place the second character, i.e. a in front of all 6 permutations of
est, then
 the third character i.e. s in front of all 6 permutations of eat, and
 finally the last character i.e. t in front of all 6 permutations of eas.
 Thus, there will be 4 (the size of the word) recursive calls to display
all permutations of a four-letter word.
 Of course, when we’re going through the permutations of
the 3-character string e.g. ast, we would follow the same
procedure.
[501043 Lecture 10: Recursion]
47
 3.10 Find all Permutations of a String (2/3)
Example 10

 Recall overloaded substring() methods in String

class

String substring(int beginIndex)

Returns a new string that is a substring of this string.
The substring begins with the character at beginIndex
and extends to the end of this string.

String substring(int beginIndex, int endIndex)

Returns a new string that is a substring of this string.
The substring begins at beginIndex and extends to the
character at index endIndex - 1. Thus the length of the
substring is endIndex – beginIndex.

[501043 Lecture 10: Recursion]

48
 3.10 Find all Permutations of a String (3/3)
Example 10

public class Permutations {
public static void main(String args[]) {
permuteString("", "String");
}

public static void permuteString(String beginningString, String endingString) {
if (endingString.length() <= 1)
System.out.println(beginningString + endingString);
else
for (int i = 0; i < endingString.length(); i++) {
try {
String newString = endingString.substring(0,i) + endingString.substring(i+1);
// newString is the endingString but without character at index i
permuteString(beginningString + endingString.charAt(i), newString);
} catch (StringIndexOutOfBoundsException exception) {
exception.printStackTrace();
}
}
}
}
[501043 Lecture 10: Recursion]
49
Exercise: Eight Queens Problem

 Place eight Queens on the chess board so that

they cannot attack one another

 Q: How do you formulate

this as a recursion problem?
Work with a partner on this.

http://en.wikipedia.org/wiki/Eight_queens_puzzle

[501043 Lecture 10: Recursion]

50
Backtracking
 Recursion and stacks illustrate a key concept in
search: backtracking
 We can show that the recursion technique can
exhaustively search all possible results in a
systematic manner
 Learn more about searching spaces in other CS
classes.

[501043 Lecture 10: Recursion]

51
More Recursion later
 You will see more examples of recursion later
when we cover more advanced sorting
algorithms
 Examples: Quick Sort, Merge Sort

[501043 Lecture 10: Recursion]

52
5 Summary
 Recursion – The Mirrors
 Base Case:
 Simplest possible version of the problem which can be
solved easily
 Inductive Step:
 Must simplify
 Must arrive at some base case
 Easily visualized by a Stack
 Operations before and after the recursive calls
come in FIFO and LIFO order, respectively
 Elegant, but not always the best (most efficient)
way to solve a problem
[501043 Lecture 10: Recursion]
53
End of file