CSE200 Lecture 6: RECURSION

Transcription

1 Table of Contents Review of functions (using factorial example)... 1 Recursion... 1 Step by step run through of recursive factorial... 2 Recursion vs. iteration (for and while loops)... 3 Helper functions:... 3 *Practice problems!... 4 Review of functions (using factorial example) Function definitions include three things: a function name, the function inputs, and the function outputs. The inputs of a function can be thought of as variables (parameters). Whenever the function is used these inputs will be defined (arguments). The body of the function performs actions on the input(s), then gives back the result in the form of function output. The output of the function should be assigned a value at some point in the function body. Functions are written generally (in terms of variables), we must then use the function and supply a specific set of inputs to be used (just like the MATLAB functions we've been using all semester such as sin(x), min(x), length(x), etc.): facti(4) facti(7) As usual, we use comments to explain the thought process behind a function. Any questions about functions? It is important to have a firm grasp of how functions work before tackling the next concept: Recursion "To understand recursion one must first understand recursion." Recursion is the act of a function calling itself. In other words, somewhere in the function body there will be a call to the function that is currently running! This can get a bit mind bending: If a function calls itself over and over again, will it ever stop? (infinite recursion). Why would we even want to do such a thing? Won't it just compute the same value over and over again? Recursion is not as simple as adding in a function call. To use recursion effectively there are certain rules that need to be followed: 1. Each time the function is called, it should be working on a DIFFERENT problem. Never use recursion to compute the same value over and over again. Even more, the problem being worked on by each sucessive recursive function call should be SIMPLER than the one before it (i.e. it gets closer to the answer). 1

2 This point ensures that recursion is actually doing something worthwhile, and not recomputing the same thing over and over again. Let's take a look at factorial again, but this time written recursively. Notice that when the recursion takes place it is using the function to compute the factorial of x - 1. Since we know that this will eventually get us to 1, this computation is simpler (closer to our answer). 2. When using recursion you MUST define a termination condition. Look again at our factorial function: in the case for 1 there is no recursion, we simply define our answer to the known value of 1. These two important rules make recursion effective, and ensure that we never get stuck in infinite recursion. If the problem is continuously getting simpler and we have defined a point when it should stop then we know that it will eventually hit this termination point. Step by step run through of recursive factorial Due to the somewhat confusing nature of recursion it can be helpful to run through it step by step to see how it works: Recursive factr steps: factr(4) %The function will execute in the following order: %factr(4) = 4 * factr(3) %factr(3) = 3 * factr(2) %factr(2) = 2 * factr(1) %factr(1) = 1 %Once we hit our base case, the recursion will put all of the pieces %together and give back our result: %factr(1) = 1 %factr(2) = 2 * 1 = 2 %factr(3) = 2 * 3 = 6 %factr(4) = 6 * 4 = 24 Notice the path we took: we drilled down to our base case, which then allowed us to evaluate each function call back up the chain until we hit our result. This can be written in general terms as: %fact(n) = n * (n - 1) * (n - 2) *... * 1 %fact(n) = n * fact(n - 1) <-- our recursive case Compare this with how the loop version computed the answer: %y = 1 * 1 = 1 %y = 1 * 2 = 2 %y = 2 * 3 = 6 %y = 6 * 4 = 24 %Look familiar? Writing the iterative version of the function can give you great insight into the recursive version. 2

3 Recursion vs. iteration (for and while loops) Believe it or not, if you can solve a problem with iteration (loops) you can also solve it wih recursion. The two methods share some qualities: Both iteration and recursion break the problem down into smaller pieces. Both have the potential to run indefinitely if not used properly (infinite loop / recursion). Both use repetition to achieve a goal. There are differences as well: There are multiple types of loops, and how long a loop runs can even be specified before execution (for i = 1:10). It is not clear until execution how many times a recursive function will run. Loops don't require the use of a function at all. The process of using a function over and over again can actually reduce the effeciency of recursion, because using functions requires extra processing time. %Q. So when should you use recursion over iteration? %A. Whenever you'd like! It usually comes down to personal preference. Some %people (arguably a majority) can analyze a problem better using loops. %Some people can analyze problems better using recursion. Since they both %achieve the same goal, it usually doesn't matter which method you choose. Even if you are more comfortable with one method over the other, it is still important to understand how each method works. You will see both approaches used in the wild. One general exception deals with particularly complex problems. While most of the problems we tackle in this class are meant to foster concept building and are generally simple, real world problems are not always straightforward. It has been shown that when dealing with certain complex problems, recursion can actually simplify the computation more than loops can. If you continue into upper level computer science courses you will run into these examples. Helper functions: The final topic dealing with recursion is the use of helper functions. Typically there is a "non-recursive" part to each function (things such as checking input, displaying plots, etc.). It is common practice to handle these things in the main function and section off the recursion such that it is contained in it's own function away from everything else. This function is typically called a helper function and an example can be seen in the multiplication example. %Q: Why is this useful? %A: We don't necessarily want EVERYTHING in the function to happen over and %over again. We can check it once and be done with it. Helper functions %make this possible. 3

4 Also, since recursion can be fairly complicated, it is often beneficial to isolate it for simplicity's sake. These helper functions are typically written as subfunctions -- functions within the same file as the main function. The examples we're about to look at will make this clear. These concepts are all you need to know to understand recursion, however since it is a tricky concept to wrap your head around I've prepared a few more examples. Each example has been done iteratively and recursively so that you can compare the two and see that it is always possible to use both methods to solve a problem. This mirrors what is asked of you on this week's lab. You will be writing four functions, twice each -- once using iteration and once using recursion. When looking at the recursive examples, be sure to think about the following: 1. What is the termination condition? 2. How does the problem get simpler? 3. Can we be absolutely sure that the recursion will terminate? 4. (If applicable) What is the purpose of using a helper function? Now that you understand recursion, go home and google it. (Seriously!) *Practice problems! 1. Write a recursive function called sumdownby2 which takes in a positive integer (n) and returns the sum of the positive numbers counting down by two. For example: %sumdownby2(7) = = 16 %sumdownby2(4) = = 6 Before writing the function, do the following: Write a general form of the equation in terms of n. Try writing the iterative version of the function. What is your base case? Your recursive step? Finally, write the recursive version. Once you have written the recursive version, write down all of the steps that would be taken when it executes sumdownby2(7). 2.Write a recursive version of the strcmp function. This function takes in two strings and compares them. If they are the same it returns true, otherwise it returns false. The iterative version of the problem is displayed to help you out. Write a general form of the function. What is your base case? Your recursive step? Write the recursive function. You will need a helper function! What should go in the wrapper function? The helper function? 4

5 Once you've written the function, write down all of the steps that would be taken when it executes strcmpr('paid', 'pair'); Lecture notes for CSE200 (Fall 2015) at Washington University in St. Louis by Marion Neumann (based on materials from Doug Shook). Published with MATLAB R2015a 5