Recursion - see Recursion - PowerPoint PPT Presentation

Loading...

PPT – Recursion - see Recursion PowerPoint presentation | free to download - id: 76895c-MTQ4Y



Loading


The Adobe Flash plugin is needed to view this content

Get the plugin now

View by Category
About This Presentation
Title:

Recursion - see Recursion

Description:

Recursion - see Recursion – PowerPoint PPT presentation

Number of Views:57
Avg rating:3.0/5.0
Slides: 32
Provided by: PerL54
Learn more at: http://laerer.rhs.dk
Category:

less

Write a Comment
User Comments (0)
Transcript and Presenter's Notes

Title: Recursion - see Recursion


1
Recursion- see Recursion
2
Recursion
  • We know that
  • We can define classes
  • We can define methods on classes
  • Mehtods can call other methods
  • Butcan a method call itself?

3
Recursion
  • public void callMe()
  • System.out.println(Hello)
  • callMe()

4
Recursion
  • Previous method definition was legal, but hardly
    useful
  • Just calling the same method will result in an
    infinite loop
  • BUT what if we
  • Supply a parameter to the method
  • Change the parameter in each call
  • Stop calling ourselves for some specific value

5
Recursion
  • public void callMe(int calls)
  • if (calls gt 0)
  • System.out.println(Hello)
  • int fewercalls calls 1
  • callMe(fewercalls)

6
Recursion
  • Calling methods like this is often called
    recursion
  • The previous example could easily be rewritten as
    a traditional loop, and would even be more
    efficient
  • However, quite a lot of problems can be solved
    very elegantly by recursion

7
Recursion
  • Example the factorial function
  • The factorial function F(n) is defined as
  • F(n) n (n-1) (n-2) 2 1
  • But you could also define F(n) as
  • F(n) n F(n-1)

8
Recursion
  • public void factorial(int n)
  • int result 1
  • for (int val 1 val lt n val)
  • result result val
  • return result

9
Recursion
  • public void factorial(int n)
  • if (n lt 1)
  • return 1
  • else
  • return (n factorial(n-1))

10
Thinking recursively
  • Thinking in terms of recursion may seem quite
    confusing at first
  • However, one should try not to think about how it
    works in detail ?
  • Think in terms of how a problem can be solved, by
    solving simpler versions of the same problem

11
Thinking recursively
  • Solving a problem by recursion
  • Control step Does the problem have a simple
    solution?
  • Division step Split the problem into a simpler
    problem, plus a residual
  • Solution step Solve the simpler problem
  • Combination step Combine the solution to the
    simpler problem with the residual, in order to
    solve the original problem

12
Thinking recursively
  • Solving the factorial function by recursion
  • Control step
  • Is n lt 1? If so, the result is 1
  • Division step
  • Original problem F(n)
  • Simpler problem F(n-1)
  • Residual n

13
Thinking recursively
  • Solving the factorial function by recursion
  • Solution step
  • Solve F(n-1) (go to top)
  • Combination step
  • Combine by multiplying F(n-1) with n

14
Thinking recursively
  • public void factorial(int n)
  • if (n lt 1)
  • return 1
  • else
  • return (n factorial(n-1))

Control Step
Division Step
Solution Step
Combination Step
15
Thinking recursively
  • A slightly harder problem is string permutations
  • Given a string of text, find all possible
    permutations of the characters in the string
  • A string of length n will have n! different
    permutations

16
Thinking recursively
  • The string cat has 3! 6 permutations
  • cat
  • cta
  • act
  • atc
  • tac
  • tca

17
Thinking recursively
  • Solving string permutations by recursion
  • Control step
  • Does the string have length 1? If so, the result
    is the string itself

18
Thinking recursively
  • Solving string permutations by recursion
  • Division step
  • For each character c in the string
  • Let c be the residual
  • Remove c from the original string.
  • The resulting string is then the simpler problem

19
Thinking recursively
  • Solving string permutations by recursion
  • Solution step
  • For each string S generated during the division
    step
  • Find all permutations of S

20
Thinking recursively
  • Solving string permutations by recursion
  • Combination step
  • For each string S generated during the solution
    step
  • Combine S with the residual character c, by
    adding c to the front of S (permutation c S)
  • Add the permutation to the result set

21
Thinking recursively
  • Solving string permutation by recursion is not
    trivial
  • but try to write an algorithm for string
    permutation without using recursion!
  • Trust that it works! ?
  • When there is a simple solution to simple inputs,
    and the problem can be solved by solving it for
    simpler inputs, it will work!

22
Recursive helper methods
  • It is sometimes easier to solve a more general
    problem by recursion
  • Example How to find a palindrome (a string which
    is equal to its own reverse)
  • Possible interface to a Sentence class
  • Sentence(String theSentence)
  • boolean isPalindrome()

23
Recursive helper methods
  • public boolean isPalindrome()
  • int len text.length()
  • if (len lt 2)
  • return true
  • if ((text.substring(0,1).equals(text.substring(le
    n-1,len)))
  • Sentence newSen new Sentence(text.substring(1,
    len-1))
  • return newSen.isPalindrome()
  • else
  • return false

24
Recursive helper methods
  • Previous implementation works, but is somewhat
    inefficient
  • We create a lot of Sentence objects
  • Let us include a helper method, that checks if a
    substring is a palindrome
  • boolean isPalindrome(int start, int end)

25
Recursive helper methods
  • public boolean isPalindrome(int start, int end)
  • int len end start
  • if (len lt 2)
  • return true
  • if ((text.substring(start,start1).equals(
  • text.substring(end-1,end)))
  • return isPalindrome(start1,end-1)
  • else
  • return false

26
Recursive helper methods
  • Finally, implement original method by using the
    helper method
  • public boolean isPalindrome()
  • return isPalindrome(0, lext.length() 1)

27
Efficiency of recursion
  • Recursion is a very elegant principle, but not
    always the correct strategy
  • Can result in very inefficient algorithms, if
    care is not taken
  • Common pitfall is to calculate identical values
    over and over

28
Efficiency of recursion
  • Example Calculating Fibonacci numbers
  • Fib(1) 1
  • Fib(2) 1
  • Fib(n) Fib(n-1) Fib(n-2)
  • Looks like a recursive solution is a no-brainer

29
Efficiency of recursion
  • public long fib(int n)
  • if (n lt 2)
  • return 1
  • else
  • return (fib(n-1) fib(n-2))

30
Efficiency of recursion
  • Method does work, but is very inefficient
  • We calculate same values over and over

Fib(n)
Fib(n-1)
Fib(n-2)
Fib(n-2)
Fib(n-3)
31
Recursion summary
  • Recursion is a powerful and elegant tool for
    algorithm development
  • Many algoritms are very easy to under-stand, if
    you understand recursion
  • No silver bullet recursive algorithms can be
    very slow
  • Always consider (iterative) alternatives
About PowerShow.com