1 Introduction to Recursion and Recursive Algorithms CS2110
Feb 25, 2016
1
Introduction to Recursion and
Recursive Algorithms
CS2110
2
Different Views of RecursionRecursive Definition: n! = n * (n-1)!
(non-math examples are common too)Recursive Procedure: a procedure that
calls itself.Recursive Data Structure: a data structure that contains a pointer to an instance of itself: public class ListNode {Object nodeItem;ListNode next, previous;…}
3
Recursion in Algorithms• Recursion is a technique that is useful
– for defining relationships, and– for designing algorithms that implement
those relationships.• Recursion is a natural way to express
many algorithms.• For recursive data-structures, recursive
algorithms are a natural choice
4
What Is Recursion?• A Definition Is Recursive If It Is Defined
In Terms Of Itself– We use them in grammar school e.g.
what is a noun phrase?• a noun
• an adjective followed by a noun phrase
– Descendants• the person’s children
• all the children’s descendants
5
What Is Recursion?• Think self-referential definition• A definition is recursive if it is defined in
terms of itself– Exponentiation - x raised to the y
power• if y is 0, then 1•otherwise
it’s x * (x raised to the y-1 power)
6
Other recursive definitions in mathematics
• Factorial:n! = n (n-1)! and 0! = 1! = 1
• Fibonacci numbers: F(0) = F(1) = 1
F(n) = F(n-1) + F(n-2) for n > 1• Note base case
– Definition can’t be completely self-referential
– Must eventually come down to something that’s solved “directly”
7
I know the steps needed to write a simple recursive method in
Java1. Strongly Agree2. Agree3. Disagree4. Strongly
Disagree
8
Recursive Factorialpublic static int factorial (int n) {if (n == 1)
return 1;else
return n * factorial(n-1);}
• Exercise: trace execution (show method calls) for n=5
9
Why Do Recursive Methods Work?
Activation Records on the Run-time Stack are the key:
• Each time you call a function (any function) you get a new activation record.
• Each activation record contains a copy of all local variables and parameters for that invocation.
• The activation record remains on the stack until the function returns, then it is destroyed.
Try yourself: use your IDE’s debugger and put a breakpoint in the recursive algorithmLook at the call-stack.
10
Broken Recursive Factorialpublic static int Brokenfactorial(int n){int x = Brokenfactorial(n-1);if (n == 1)return 1;else return n * x;
}• What’s wrong here? Trace calls “by hand”
– BrFact(2) -> BrFact(1) -> BrFact(0) -> BrFact(-1) -> BrFact(-2) -> …
– Problem: we do the recursive call first before checking for the base case
– Never stops! Like an infinite loop!
11
Recursive DesignRecursive methods/functions require:
1) One or more (non-recursive) base cases that will cause the recursion to end.if (n == 1) return 1;2) One or more recursive cases that operate on smaller problems and get you closer to the base case.return n * factorial(n-1);
Note: The base case(s) should always be checked before the recursive call.
12
Rules for Recursive Algorithms
• Base case - must have a way to end the recursion
• Recursive call - must change at least one of the parameters and make progress towards the base case– exponentiation (x,y)
• base: if y is 0 then return 1• recursive: else return (multiply x times
exponentiation(x,y-1))
13
How to Think/Design with Recursion
• Many people have a hard time writing recursive algorithms
• The key: focus only at the current “stage” of the recursion– Handle the base case, then…– Decide what recursive-calls need to be
made•Assume they work (as if by magic)
– Determine how to use these calls’ results
14
Example: List Processing• Is an item in a list? First, get a
reference current to the first node– (Base case) If current is null, return false– (Base case #2) If the first item equals
the target, return true– (Recursive case – might be on the
remainder of the list)• current = current.next• return result of recursive call on new current
15
Next: Trees and Grammars• Lab on binary tree data structures• Maybe: HW5 on grammars
• Lecture Later: Recursion vs. iteration– Which to choose?– Does it matter?
• Maybe Later: recursion as an design strategy
16
Next: Time Complexity and Recursion• Recursion vs. iteration
– Which to choose?– Does it matter?
• Later: recursion as an design strategy
17
Recursion vs. IterationInteresting fact: Any recursive
algorithm can be re-written as an iterative algorithm (loops)
• Not all programming languages support recursion: COBOL, early FORTRAN.
• Some programming languages rely on recursion heavily: LISP, Prolog, Scheme.
18
To Recurse or Not To Recurse?• Recursive solutions often seem elegant• Sometimes recursion is an efficient design
strategy• But sometimes it’s definitely not
– Important! we can define recursively and implement non-recursively
– Many recursive algorithms can be re-written non-recursively
• Use an explicit stack• Remove tail-recursion (compilers often do this for
you)
19
To Recurse or Not to Recurse?
• Sorting– Selection sort vs. mergesort – which to
choose?• Factorial
– Could just write a loop.– Any advantage to the recursive version?
• Binary search– We’ll see two versions. Which to choose?
• Fibonacci– Let’s consider Fibonacci carefully…
20
Recursive Fibonacci method• This is elegant code, no?
long fib(int n) { if ( n == 0 ) return 1; if ( n == 1 ) return 1; return fib(n-1) + fib(n-2);}
• Let’s start to trace it for fib(6)
21
Trace of fib(5)• For fib(5), we call fib(4) and fib(3)
– For fib(4), we call fib(3) and fib(2)• For fib(3), we call fib(2) and fib(1)
– For fib(2), we call fib(1) and fib(0). Base cases!– fib(1). Base case!
• For fib(2), we call fib(1) and fib(0). Base cases!– For fib(3), we call fib(2) and fib(1)
• For fib(2), we call fib(1) and fib(0). Base cases!• fib(1). Base case!
22
Fibonacci: recursion is a bad choice
• Note that subproblems (like fib(2) ) repeat, and solved again and again– We don’t remember that we’ve solved
one of our subproblems before– For this problem, better to store
partial solutions instead of recalculating values repeatedly
– Turns out to have exponential time-complexity!
23
Non-recursive Fibonacci• Two bottom-up iterative solutions:
– Create an array of size n, and fill with values starting from 1 and going up to n
– Or, have a loop from small values going up, but• only remember two previous Fibonacci
values• use them to compute the next one• (See next slide)
24
Iterative Fibonaccilong fib(int n) { if ( n < 2 ) return 1;
long answer; long prevFib=1, prev2Fib=1; // fib(0) & fib(1) for (int k = 2; k <= n; ++k) {
answer = prevFib + prev2Fib; prev2Fib = prevFib; prevFib = answer; } return answer; }
25
Next: Putting Recursion to Work• Divide and Conquer design
strategy– Its form– Examples:
• Binary Search• Merge Sort
– Time complexity issues
26
Divide and Conquer
• It is often easier to solve several small instances of a problem than one large one.– divide the problem into smaller instances of
the same problem– solve (conquer) the smaller instances
recursively– combine the solutions to obtain the solution
for original input– Must be able to solve one or more small inputs
directly• This is an algorithm design strategy
– Computer scientists learn many more of these
27
General Strategy for Div. & Conq.
Solve (an input I)n = size(I)if (n <= smallsize)
solution = directlySolve(I);else
divide I into I1, …, Ik.for each i in {1, …, k}
Si = solve(Ii);solution = combine(S1, …, Sk);
return solution;
28
Why Divide and Conquer?• Sometimes it’s the simplest approach• Divide and Conquer is often more
efficient than “obvious” approaches– E.g. BinarySearch vs. Sequential Search– E.g. Mergesort, Quicksort vs. SelectionSort
• But, not necessarily efficient– Might be the same or worse than another
approach• We must analyze each algorithm's time
complexity• Note: divide and conquer may or may
not be implemented recursively
29
Top-Down Strategy• Divide and Conquer algorithms illustrate
a top-down strategy– Given a large problem, identify and break
into smaller subproblems– Solve those, and combine results
• Most recursive algorithms work this way• The alternative? Bottom-up
– Identify and solve smallest subproblems first
– Combine to get larger solutions until solve entire problem
30
Binary Search of a Sorted Array
• Strategy– Find the midpoint of the array– Is target equal to the item at midpoint?– If smaller, look in the first half– If larger, look in second half
first mid last
31
Binary Search (non-recursive)
int binSearch ( array[], target) { int first = 0; int last = array.length-1; while ( first <= last ) {
mid = (first + last) / 2;if ( target == array[mid] ) return mid; // found itelse if ( target < array[mid] ) // must be in 1st halflast = mid -1;else // must be in 2nd halffirst = mid + 1}return -1; // only got here if not found above
}
32
Binary Search (recursive)int binSearch ( array[], first, last, target) {
if ( first <= last ) {mid = (first + last) / 2;if ( target == array[mid] ) // found it!
return mid; else if ( target < array[mid] ) // must be in 1st halfreturn binSearch( array, first, mid-1, target);else // must be in 2nd halfreturn binSearch(array, mid+1, last, target);}return -1;
}• No loop! Recursive calls takes its place
– But don’t think about that if it confuses you!• Base cases checked first? (Why? Zero items? One item?)
33
Mergesort is Classic Divide & Conquer
34
Algorithm: Mergesort• Specification:
– Input: Array E and indexes first, and Last, such that the elements E[i] are defined for first <= i <= last.
– Output: E[first], …, E[last] is sorted rearrangement of the same elements
• Algorithm:void mergeSort(Element[] E, int first, int last){ if (first < last) {
int mid = (first+last)/2;mergeSort(E, first, mid);mergeSort(E, mid+1, last);merge(E, first, mid, last); // merge 2 sorted halves
}}
35
Exercise: Trace Mergesort Execution
• Can you trace MergeSort() on this list? A = {8, 3, 2, 9, 7, 1, 5, 4};
36
Efficiency of Mergesort
• Wait for CS2150 and CS4102 to study efficiency of this and other recursive algorithms
• But…– It is more efficient that other sorts like
Selection Sort, Bubble Sort, Insertion Sort– It’s O(n lg n) which is the same order-class as the
most efficient sorts (also quicksort and heapsort)• The point is that the D&C approach matters
here, and a recursive definition and implementation is a “win”
37
Merging Sorted Sequences• Problem:
– Given two sequences A and B sorted in non-decreasing order, merge them to create one sorted sequence C
– Input size: C has n items, and A and B have n/2• Strategy:
– Determine the first item in C: it should be the smaller of the first item in A and the first in B.
– Suppose it is the first item of A. Copy that to C.– Then continue merging B with “rest of A”
(without the item copied to C). Repeat!
38
Algorithm: Mergemerge(A, B, C)
if (A is empty)append what’s left in B to C
else if (B is empty)append what’s left in A to C
else if (first item in A <= first item in B)append first item in A to Cmerge (rest of A, B, C)
else // first item in B is smallerappend first item in B to Cmerge (A, rest of B, C)
return
39
Summary of Recursion Concepts
• Recursion is a natural way to solve many problems– Sometimes it’s a clever way to solve
a problem that is not clearly recursive• Sometimes recursion produces an
efficient solution (e.g. mergesort)– Sometimes it doesn’t (e.g. fibonacci)
• To use recursion or not is a design decision for your “toolbox”
40
Recursion: Design and Implementation
• “The Rules”– Identify one or more base (simple) cases
that can be solved without recursion• In your code, handle these first!!!
– Determine what recursive call(s) are needed for which subproblems
– Also, how to use results to solve the larger problem
– Hint: At this step, don’t think about how recursive calls process smaller inputs! Just assume they work!
41
Exercise: Find Max and Min• Given a list of elements, find both the
maximum element and the minimum element• Obvious solution:
– Consider first element to be max– Consider first element to be min– Scan linearly from 2nd to last, and update if
something larger then max or if something smaller than min
• Class exercise:– Write a recursive function that solves this using
divide and conquer.• Prototype: void maxmin (list, first, last, max, min);• Base case(s)? Subproblems? How to combine results?
42
What’s Next?• Recursive Data Structures
– Binary trees• Representation• Recursive algorithms
– Binary Search Trees• Binary Trees with constraints
• Parallel Programming using Threads