CSEB 114: Principle of Programming

1
CSEB 114 Principle of Programming

• Chapter 6 Function Simple Recursion

2
Simple Recursion

• Recursion is where a function calls itself.
• Concept of recursive function
• A recursive function is called to solve a problem
• The function only knows how to solve the simplest
  case of the problem. When the simplest case is
  given as an input, the function will immediately
  return with an answer.
• However, if a more complex input is given, a
  recursive function will divide the problem into 2
  pieces a part that it knows how to solve and
  another part that it does not know how to solve.

3
Simple Recursion cont

• The part that it does not know how to solve
  always resembles the original problem, but of a
  slightly simpler version.
• Therefore, the function calls itself to solve
  this simpler piece of problem that it does now
  know how to solve. This is called the recursion
  step.
• The recursion step is done until the problem
  converges to become the simplest case.
• This simplest case will be solved by the function
  which will then return the answer to the previous
  copy of the function.
• The sequence of returns will then go all the way
  up until the original call of the function
  finally return the result.

4
Simple Recursion cont

• Any problem that can be solved recursively can
  also be solved iteratively (using loop).
• Recursive functions are slow and takes a lot of
  memory space compared to iterative functions
• So why bother with recursion? There are 2
  reasons
• Recursion approach more naturally resembles the
  problem and therefore the program is easier to
  understand and debug.
• Iterative solution might not be apparent.

5
Example 1 - xy

• In this example, we want to calculate x to the
  power of y (i.e. xy)
• If we analyze the formula for xy, we could see
  that xy could be written as (x being multiplied
  to itself, y times).
• An example is 24, which can be written as
• 24 2 x 2 x 2 x 2 (in this case, x 2, y 4)
• 24 could also be rewritten as
• 24 21 x 23 where 21 2 (i.e the number
  itself)
• Therefore, we could divide the problem into two
  stage
• Simplest case when y 1, the answer is x
• Recursive case, we need to solve for x x(y-1)

6
Example 1 - xy

• include ltstdio.hgt
• double XpowerY(double,int)
• void main(void)
• double power, x
• int y
• printf("Enter the value of x and y")
• scanf("lfd",x,y)
• power XpowerY(x,y)
• printf(".2f to the power of d is
  .2f\n\n",x,y,power)

7
Example 1 - xy

• double XpowerY(double x, int y)
• if (y 1 )
• return x
• else
• return x XpowerY(x, y-1)

Sample Output Enter the value of x and y
2 3 2.0 to the power of 3 is 8.00
8
Example 2 - Factorial

• Analysis
• n! n (n-1) (n-2) (n-3) (n-4) 1
• n! could be rewritten as n (n-1)!
• Example
• 5! 5 4 3 2 1 5 (4)!, where n 5
• Fact 0! Or 1! is equal to 1
• Therefore, we could divide this problem into two
  stages for n!
• Simplest case if (n lt 1), answer is 1
• Recursive case we need to solve for n (n-1)!

9
Example 2 - Factorial

• include ltstdio.hgt
• double fact(double)
• void main(void)
• double n, result
• printf("Please enter the value of n")
• scanf("lf",n)
• result fact(n)
• printf(" .f! .2f\n\n",n,result)

10
Example 2 - Factorial

• double fact(double n)
• if (n lt 1)
• return 1
• else
• return n fact(n-1)

Sample Output Please enter the value of n 3 3!
6.00