Introduction to algorithm design and recursion

CS125 Spring 2007

Arthur Kantor

Algorithm

• An algorithm is a computational process for solving a problem.– computational: a computer must be able to

perform the steps of the process• This concept was formalized by Alan Turing and

Alonzo Church in the 1930ies• One of the great results of computer science

Algorithm

• An algorithm is a computational process for solving a problem.– solving

• The algorithm must actually give the correct solution after it terminates

– problem• Typically the problem is somewhat general.

– E.g. “Sort any list of numbers” instead of “Sort this particular list of numbers”

Algorithm design

• The next few weeks we will be talking about designing algorithms to solve problems– We can talk about whether the algorithm is

described precisely enough so that it can be translated into a computer program

– We can talk about whether the algorithm solves the given problem

– We do not need to discuss the actual code

Recursive algorithm

• A recursive algorithm solves the problem by possibly using the result of applying itself to a simpler problem

• Example: Draw this picture

Another example

• Draw this picture

Properties of all recursive algorithms

• 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’

Another example

• The factorial function: multiply together all numbers from 1 to n.

• denoted n!n!=n*(n-1)*(n-2)*…2*1

n!= n*(n-1)! if n>0

1 if n==0

Another example

• The factorial function: multiply together all numbers from 1 to n.

• denoted n!n!=n*(n-1)*(n-2)*…2*1

n!= n*(n-1)! if n>0

1 if n==0

General case: Uses a solution to a simpler sub-problem

Base case: Solution is given directly

4! Walk-through

4!=

n!= n*(n-1)! if n>0 1 if n==0

Java implementation of n!

public int factorial(int n){

if (n==0)

return 1;

else

return n*factorial(n-1);

}

n!= n*(n-1)! if n>0 1 if n==0

factorial(4);

factorial(4)

public int factorial(int n){ if (n==0)

return 1; else

return n*factorial(n-1);

}

factorial(4);

factorial(4)

public int factorial(int n){ if (n==0)

return 1; else

return n*factorial(n-1);

}

n=4Returns 4*factorial(3)

factorial(4);

factorial(4)

public int factorial(int n){ if (n==0)

return 1; else

return n*factorial(n-1);

}

n=4Returns 4*factorial(3)

n=3Returns 3*factorial(2)

factorial(4);

factorial(4)

public int factorial(int n){ if (n==0)

return 1; else

return n*factorial(n-1);

}

n=4Returns 4*factorial(3)

n=3Returns 3*factorial(2)

n=2Returns 2*factorial(1)

factorial(4);

factorial(4)

public int factorial(int n){ if (n==0)

return 1; else

return n*factorial(n-1);

}

n=4Returns 4*factorial(3)

n=3Returns 3*factorial(2)

n=2Returns 2*factorial(1)

n=1Returns 1*factorial(0)

factorial(4);

factorial(4)

public int factorial(int n){ if (n==0)

return 1; else

return n*factorial(n-1);

}

n=4Returns 4*factorial(3)

n=3Returns 3*factorial(2)

n=2Returns 2*factorial(1)

n=1Returns 1*factorial(0)

n=0Returns 1

factorial(4);

factorial(4)

public int factorial(int n){ if (n==0)

return 1; else

return n*factorial(n-1);

}

n=4Returns 4*factorial(3)

n=3Returns 3*factorial(2)

n=2Returns 2*factorial(1)

n=1Returns 1*factorial(0)

1

factorial(4);

factorial(4)

public int factorial(int n){ if (n==0)

return 1; else

return n*factorial(n-1);

}

n=4Returns 4*factorial(3)

n=3Returns 3*factorial(2)

n=2Returns 2*factorial(1)

1

factorial(4);

factorial(4)

public int factorial(int n){ if (n==0)

return 1; else

return n*factorial(n-1);

}

n=4Returns 4*factorial(3)

n=3Returns 3*factorial(2)

2

factorial(4);

factorial(4)

public int factorial(int n){ if (n==0)

return 1; else

return n*factorial(n-1);

}

n=4Returns 4*factorial(3)

6

factorial(4);

factorial(4)

public int factorial(int n){ if (n==0)

return 1; else

return n*factorial(n-1);

}

24

How the computer does it

• The computer remembers the entire stack of partially completed function calls

• The execution of caller is paused until the called function returns with its answer

n=4Returns 4*factorial(3)

n=3Returns 3*factorial(2)

Execution of factorial(4) is paused until factorial(3) returns with its answer

Once factorial(3) returns, execution of factorial(4) continues

Why recursion?

• We could have implemented n! using a while loop (how?)

• In general, any recursively defined function can be re-implmented with a while loop.

• Sometimes it is much more natural to specify a function recursively than with a loop

Another example

• prod(list) returns a product of all the numbers in the list

• prod({1,3,3,4}) should return 36

Implementation of prod()

float prod(float[] list){return helperProd(list, 0);

}

float helperProd(float[] list, int k){if (k==list.length)

return 1;else

return list[k]*helperProd(list,k+1);}

walkthrough

helperProd({1,3,3,4},0)

float helperProd(float[] list, int k){ if (k==list.length) return 1; else return list[k]*helperProd(list,k+1);}

Recursion in real life