1/ 22

COP 3503 FALL 2012SHAYAN JAVED

LECTURE 17

Programming Fundamentals using Java

2/ 22

Recursion

3/ 22

Definition

Method where:

Solution to a problem depends on solutions of smaller instances of the same problem.

4/ 22

Example: Merge Sort

Split

Now Sort and Merge

i 0 1 2 3 4 5

A 55 19 100 45 87 33

0 1 2

55 19 100

3 4 5

45 87 33

0

55

1 2

19 100

3

45

4 5

87 33

5/ 22

Recursive Function

A function which calls itself to solve a problem.

Alternative to iterative solutions

Most programming languages support recursion Some only support recursion (Functional languages)

6/ 22

Problems solved by Recursion

Mathematical problems (Factorial, Fibonacci sequence, etc.)

Searching and sorting algorithms (binary search, merge sort, etc.)

Traversing file systems

Traversing data structures (linked lists, trees)

Etc…

7/ 22

Defining a Recursive Function

1. When does the recursion stop? Have to stop at some point otherwise you’ll run into

problems Also known as the “base case”

2. Repeat the process by calling the function again

8/ 22

Defining a Recursive Function

Example:

int recursiveMethod(parameters) {if (baseCase)

return someValue;else

return recursiveMethod(modifiedParameters);

}

9/ 22

Fibonacci sequence

A sequence of numbers:0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, …

How would you implement this recursively?

10/ 22

Fibonacci sequence

int fibonacci(int n) {if (n == 0)

return 0;else if (n == 1)

return 1;else

return fibonacci(n-1) + fibonacci(n-2);}

11/ 22

Fibonacci sequenceHow would you implement this iteratively? (Using loops)

int fibonacci(int n) {int fn1 = 0, fn2 = 1;int prev;

for(int i = 0; i < num; i++) {prev = fn1;fn1 = fn2;fn2 = fn2 + prev;}

return fn1;}

Let’s run both

12/ 22

Fibonacci sequence

Recursive version seems to be much slower.

Why?

What happens when a function call is made?

13/ 22

Function calls

When a method is called:

The method reference and arguments/parameters are pushed onto the calling method’s operand stack

A new stack frame is created for the method which is called. Contains variables, operand stack, etc. for it.

Stack frame is pushed onto the Java Stack.

When method is done, it is popped from the Java Stack.

14/ 22

Function calls

Java Stack Approximation after calling fibonacci(2):

1 is returned to Main

MainMain

fib(2)

Main

1

Main

fib(2)

fib(1)

Main

1

fib(0)

fib(2)

Main

1

0

fib(2)

15/ 22

Function calls

Program counters have to be updated, local variables, stacks, method references, etc.

So a lot of work is done when methods are called.

Imagine calling fibonacci(1000). Results in “stack overflow” (no available memory on

the call stack)

16/ 22

Recursion

Advantages: Very simple to write Programs are short Sometimes recursion is the only option

Disadvantages: Extra storage required Slow

17/ 22

More Examples

Iterative version of Binary Search:

int binarySearch(int[] array, int key, int left, int right){while (left <= right) {int middle = (left + right)/2; // Compute mid pointif (key < array[mid]) {right = mid-1; // repeat search in bottom half} else if (key > array[mid]) {left = mid + 1; // Repeat search in top half} else {return mid; // found!}}return -1; // Not found

}How would you implement recursively?

18/ 22

Binary Search

Identify base case first When do we stop?

When do you repeat?

19/ 22

Binary Search

int binarySearch(int[] array, int key, int left, int right) {if (left > right) // base case 1: not foundreturn -1;

int mid = (left + right)/2; // Compute mid point

if (key == array[mid]) // base case 2: found!return middle; else if (key < array[mid]) // repeat search in upper halfreturn binarySearch(array, key, left, mid-1);else // lower halfreturn binarySearch(array, key, mid, right);

}

20/ 22

File Systems

What happens when you run this command in Linux?

rm –r *

Recursively (“-r”) goes through every file in the directory and sub-directories and deletes it.

Has to use recursion

21/ 22

File Systems

How do you think the program “rm” is implemented?

Probably something like this (pseudocode):

function rm(directory):File[] files = directory.getAllFiles();for each file in files:if (file is directory)rm(file);elsedelete file;

22/ 22

Summary

Recursion is useful for writing simple programs.

Alternative to iterative solutions, but slower and requires more space.

Some solutions require recursion (file directory traversal)