Design and Analysis of

Algorithms
Recursive algorithms

Department of Computer Science

 Recursive definitions
❖A recursive algorithm solves a problem by solving smaller
instances of the same problem.
❖It repeatedly breaks the problem down into simpler
subproblems until it reaches a base case, which can be
solved directly.
❖General Structure:
• Base Case(s): The simple, smallest instance of the
problem which can be solved directly.
• Recursive Case: is defined in terms of itself and must
always move closer to the base case.
❖Applications of Recursion:
Widely used in algorithms that deal with hierarchical
structures (like trees), divide-and-conquer strategies, and
certain mathematical problems.
2
 Recursive algorithm

❖A recursive algorithm solves the problem by

possibly using the result of applying itself to a
simpler problem Image:SierpinskiTriangle.PNG

❖Example: Draw this picture

3
 General Recursive Design Strategy

❖ Identify the base case(s) (for direct solution)

❖ Devise a problem splitting strategy

 Subproblems must be smaller
 Subproblems must work towards a base case

❖ Devise a solution combining strategy

4
 Requirements for Recursive Solution

❖ At least one “small” case that you can solve

directly

❖ A way of breaking a larger problem down into:

 One or more smaller subproblems
 Each of the same kind as the original

❖ A way of combining subproblem results into an

overall solution to the larger problem

5
 Recursive Thinking

❖Recursion is:
 A problem-solving approach, that can ...
 Generate simple solutions to ...
 Certain kinds of problems that ...
 Would be difficult to solve in other ways

❖Recursion splits a problem:

 Into one or more simpler versions of itself

6
 Recursive Thinking:

❖The General Approach

1. if problem is “small enough”
2. solve it directly
3. else
4. break into one or more smaller
subproblems
5. solve each subproblem recursively
6. combine results into solution to whole
problem
7
 Recursive Thinking

Strategy for searching a sorted array:

1. if the array is empty
2. return -1 as the search result (not present)
3. else if the middle element == target
4. return subscript of the middle element
5. else if target < middle element
6. recursively search elements before middle
7. else
8. recursively search elements after the middle

8
 Recursive algorithm Properties

❖A recursive algorithm solves the large problem

by using its solution to a simpler sub-problem
 divide and conquer approach

❖Eventually the sub-problem is simple enough

that it can be solved without applying the
algorithm to it recursively
 This is called the ‘base case’

9
 Key Components of a Recursive Algorithm
Design
1. What is a smaller identical problem(s)?
Decomposition
2. How are the answers to smaller problems
combined to form the answer to the larger
problem?
Composition
3. Which is the smallest problem that can be solved
easily (without further decomposition)?
Base/stopping case

10
 Recursion

❖A recursive procedure can often be analyzed

by solving a recursive equation
❖Basic form:
T(n) = if (base case) then some constant
else ( time to solve subproblems +
time to combine solutions )
❖Result depends upon
 how many subproblems
 how much smaller are subproblems
 how costly it is to combine solutions (coefficients)
11
 Example: Factorial Function

❖The factorial function: multiply together all

numbers from 1 to n.
❖denoted n!
n!=n*(n-1)*(n-2)*…2*1

General case: Uses a solution to

n!= n*(n-1)! if n>0 a simpler sub-problem

1 if n==0 Base case: Solution is given

directly

12
 public static int factorial(int n)
Execution Trace {
int fact;
if (n > 1) // recursive case (decomposition)
fact = factorial(n – 1) * n; (composition)
(decomposition) else // base case
fact = 1;
return fact;
}

factorial(4)

factorial(3) 4

13
 public static int factorial(int n)
Execution Trace {
int fact;
if (n > 1) // recursive case (decomposition)
fact = factorial(n – 1) * n; (composition)
(decomposition) else // base case
fact = 1;
return fact;
}

factorial(4)

factorial(3) 4

factorial(2) 3

14
 public static int factorial(int n)
Execution Trace {
int fact;
if (n > 1) // recursive case (decomposition)
fact = factorial(n – 1) * n; (composition)
(decomposition) else // base case
fact = 1;
return fact;
}

factorial(4)

factorial(3) 4

factorial(2) 3

factorial(1) 2

15
 public static int factorial(int n)
Execution Trace {
int fact;
if (n > 1) // recursive case (decomposition)
fact = factorial(n – 1) * n; (composition)
(composition) else // base case
fact = 1;
return fact;
}

factorial(4)

*
factorial(3) 4

*
factorial(2) 3

*
factorial(1) ->1 2

16
 public static int factorial(int n)

Execution Trace {
int fact;
if (n > 1) // recursive case (decomposition)
fact = factorial(n – 1) * n; (composition)

(composition) else // base case

fact = 1;
return fact;
}

factorial(4)
*
factorial(3) 4

*
factorial(2) ->2 3

17
 public static int factorial(int n)
Execution Trace {
int fact;
if (n > 1) // recursive case (decomposition)
fact = factorial(n – 1) * n; (composition)
(composition) else // base case
fact = 1;
return fact;
}

factorial(4)
*
factorial(3) ->6 4

18
 public static int factorial(int n)
Execution Trace {
int fact;
if (n > 1) // recursive case (decomposition)
fact = factorial(n – 1) * n; (composition)
(composition) else // base case
fact = 1;
return fact;
}

factorial(4) -> 24

19
 Improved factorial Method

public static int factorial(int n)

{
int fact=1; // base case value

if (n > 1) // recursive case (decomposition)

fact = factorial(n – 1) * n; // composition
// else do nothing; base case

return fact;
}

20
 Example: Palindrome

❖Describe a palindrome recursively ( a palindrome

is a word that has the same spelling both forward
and backwards e.g. bob)

❖Base case:
 An empty string is a palindrome
 A string of one character is a palindrome
❖Recursive step
 If S is a palindrome, then aSb is also a palindrome if
a=b

21
 How Recursion Works

To understand recursion, it's crucial to first grasp how

function calls work in a program:
❖ Suspending Execution: When a function (subroutine)
is called, the current function halts execution.
❖ Control Transfer: The called function takes control of
the program and begins execution.
❖ Returning Control: Once the function completes,
control is returned to the calling function.
❖ State Preservation: Local variables and the execution
point in the calling function must be preserved to
restore the state after the function call finishes.

22
 How Recursion Works
❖To do this we use a stack.
❖Before a function is called, all relevant data is
stored in a stackframe.
❖This stackframe is then pushed onto the system
stack.
❖After the called function is finished, it simply pops
the system stack to return to the original state.
❖By using a stack, we can have functions call other
functions which can call other functions, etc.
❖Because the stack is a first-in, last-out data
structure, as the stackframes are popped, the
data comes out in the correct order.
23
 Limitations of Recursion

❖Recursive solutions may involve extensive

overhead because they use calls.
❖When a call is made, it takes time to build a
stackframe and push it onto the system stack.
❖Conversely, when a return is executed, the
stackframe must be popped from the stack and the
local variables reset to their previous values – this
also takes time.
❖Every time we make a call, we must use some of
the memory resources to make room for the
stackframe.
24
 Uses and Real-Life Applications
❖ Data Structures:
 Binary Trees: Traversing trees (in-order, pre-order, post-order).
 Graphs: DFS is implemented using recursion for exploring graph nodes.
❖ Divide and Conquer:
 Sorting Algorithms: Merge Sort, Quick Sort.
 Search Algorithms: Binary Search, Exponential Search.
❖ Mathematics & Algorithms:
 Combinatorics: Recursive algorithms for generating combinations and
permutations.
 Mathematical Proofs: Proof by induction often uses recursive steps.
❖ Artificial Intelligence:
 Backtracking: Solving puzzles like Sudoku, N-Queens, and Maze-solving.
 Minimax Algorithm: Used in decision-making for game AI (e.g., Chess).
❖ File System Traversal:
 Recursion is used in navigating directories and files in a hierarchical file
system (DFS in filesystem traversal).
25
 Recurrences

❖The expression:  c n =1

T ( n) = 
2T  n  + c n  1
  2 
is a recurrence.
 Recurrence: an equation that describes a

function in terms of its value on smaller functions

❖A recurrence relation is an equation that
recursively defines a sequence, where each term
is a function of the previous terms.

26
 Recurrence Examples

 0 n=0  0 n=0
s ( n) =  s ( n) = 
c + s(n − 1) n  0 n + s (n − 1) n  0

n =1 
 c  c n =1
 
T ( n) =  T ( n) = 
2T   + c n  1
 n  n
  2  aT   + cn n  1
 b
27
 Solving Recurrences

❖Recurrences can be solved by the following

methods
 Substitution method

 Iteration method

 Master method

 Recursive tree method

28
 The substitution method

❖A.k.a. the “making a good guess method”

❖Guess the form of the answer, then use induction
to find the constants and show that solution works

❖Examples:
 T(n) = 2T(n/2) + (n) → T(n) = (n lg n)

 T(n) = 2T(n/2) + n → T(n) = (n lg n)

 T(n) = 2T(n/2+ 17) + n → (n lg n)

29
 The Iteration method

❖Another option for solving recurrences the

“iteration method”
 Expand the recurrence

 Work some algebra to express as a summation

 Evaluate the summation

30
 The Iteration method

❖ T(n) =  c n =1
 n
2T(n/2) + c T (n) = 2T
  + c n 1
2(2T(n/2/2) + c) + c   2 
22T(n/22) + 2c + c
22(2T(n/22/2) + c) + 3c
23T(n/23) + 4c + 3c
23T(n/23) + 7c
23(2T(n/23/2) + c) + 7c
24T(n/24) + 15c
…
2kT(n/2k) + (2k - 1)c

31
 The Iteration method

❖So far for n > 2k we have

k k k
 T(n) = 2 T(n/2 ) + (2 - 1)c

❖Determine the value of 𝑘: The recursion continues

until 𝑛/2𝑘=1, which happens when 𝑘=log2(𝑛).
Therefore, at this point:
 T(n) = 2
lg n T(n/2lg n) + (2lg n - 1)c

= n T(n/n) + (n - 1)c Note: 2 lg n=n

= n T(1) + (n-1)c
= nc + (n-1)c = (2n - 1)c  c n =1
 n
T (n) = 2T
  + c n 1
  2 
32
 Proving a Recursive Method
Correct
Recall Proof by Induction:
1. Prove the theorem for the base case(s): n=0
2. Show that:
▪ If the theorem is assumed true for n,
▪ Then it must be true for n+1

Result: Theorem true for all n ≥ 0.

33
 Proving a Recursive Method Correct

Recursive proof is similar to induction:

1. Show base case recognized and solved
correctly
2. Show that
▪ If all smaller problems are solved correctly,
▪ Then original problem is also solved
correctly
3. Show that each recursive case makes
progress towards the base case 
terminates properly

34
 Recursive Versus Iterative
Methods

All recursive algorithms/methods

can be rewritten without recursion.

❖Iterative methods use loops instead of recursion

❖Iterative methods generally run faster and use

less memory--less overhead in keeping track of
method calls

35
 Recursion Versus Iteration

❖Recursion and iteration are similar

❖Iteration:
 Loop repetition test determines whether to exit
❖Recursion:
 Condition tests for a base case
❖Can always write iterative solution to a
problem solved recursively, but:
❖Recursive code often simpler than iterative
 Thus easier to write, read, and debug
36
 Efficiency of Recursion

❖Recursive method often slower than iterative;

why?
 Overhead for loop repetition smaller than
 Overhead for call and return
❖If easier to develop algorithm using recursion,
 Then code it as a recursive method:
 Software engineering benefit probably outweighs
...
 Reduction in efficiency
❖Don’t “optimize” prematurely!
37
 So When Should You Use Recursion?

❖Solutions/algorithms for some problems are

inherently recursive
 iterative implementation could be more
complicated
❖When efficiency is less important
 it might make the code easier to understand

❖Bottom line is about:

 Algorithm design
 Tradeoff between readability and efficiency
38
 Towers of Hanoi: Description

Goal: Move entire tower to another peg

Rules:
1. You can move only the top disk from a peg.
2. You can only put a smaller on a larger disk
(or on an empty peg)

39
Towers of Hanoi: Solution Strategy

40
Towers of Hanoi: Solution Strategy

41
 Towers of Hanoi: Recursion Structure

move(n, src, dst, tmp) =

if n == 1: move disk 1 from src to dst
otherwise:
move(n-1, src, tmp, dst)
move disk n from src to dst
move(n-1, tmp, dst, src)

42
 Computing Powers

❖The power function, p(x,n)=xn, can be defined

recursively:
 1 if n = 0
p ( x, n ) = 
 x  p( x, n − 1) else
❖This leads to a power function that runs in O(n)
time (for we make n recursive calls).
❖We can do better than this, however.

43
 Recursive Squaring

❖We can derive a more efficient linearly recursive

algorithm by using repeated squaring:

 1 if x = 0

p( x, n) =  x  p( x, (n − 1) / 2) if x  0 is odd
2

 p ( x , n / 2) 2
if x  0 is even


❖For example,
24 = 2(4/2)2 = (24/2)2 = (22)2 = 42 = 16
25 = 21+(4/2)2 = 2(24/2)2 = 2(22)2 = 2(42) = 32
26 = 2(6/ 2)2 = (26/2)2 = (23)2 = 82 = 64
27 = 21+(6/2)2 = 2(26/2)2 = 2(23)2 = 2(82) = 128. 44
 Analyzing the Recursive Squaring
Method

Algorithm Power(x, n):

Input: A number x and
integer n = 0
Output: The value xn Each time we make a
recursive call we halve the
if n = 0 then value of n; hence, we make
return 1 log n recursive calls. That
if n is odd then is, this method runs in
y = Power(x, (n - 1)/ 2) O(log n) time.
return x · y · y
else It is important that we
used a variable twice
y = Power(x, n/ 2)
here rather than calling
return y · y the method twice.
45
 Challenges of Recursion
❖ Stack Overflow:
 Each recursive call consumes stack space. If the recursion depth is too

large, it can lead to a stack overflow error.

 Solution: Tail recursion optimization (or converting to an iterative
solution).
❖ Efficiency:
 Recursive algorithms can have redundant calculations;

 Solution: Memoization or dynamic programming.

❖ Memory Usage:
 Each call adds a new layer to the call stack, which can increase memory

usage.
 Solution: Use iterative solutions where possible or optimize recursion.

❖ Debugging:
 Can be difficult to debug when there are multiple recursive calls.

 Solution: Add proper base cases and use debugging tools (or print

statements) to trace recursion steps.

46