The Java Course provides a general introduction to programming in Java. It is based on A.B. Downey's book, How to Think Like a Computer Scientist. Click here for details. 
Home Fruitful Methods More Recursion  
See also: Recursion, Stack Diagrams for Recursive Methods, Lists and Recursion  
Search the VIAS Library  Index  
More Recursion
Now that we have methods that return values, you might be interested to know that we have a complete programming language, by which I mean that anything that can be computed can be expressed in this language. Any program ever written could be rewritten using only the language features we have used so far (actually, we would need a few commands to control devices like the keyboard, mouse, disks, etc., but that's all). Proving that that claim is true is a nontrivial exercise first accomplished by Alan Turing, one of the first computer scientists (well, some would argue that he was a mathematician, but a lot of the early computer scientists started as mathematicians). Accordingly, it is known as the Turing thesis. If you take a course on the Theory of Computation, you will have a chance to see the proof. To give you an idea of what you can do with the tools we have learned so far, let's look at some methods for evaluating recursivelydefined mathematical functions. A recursive definition is similar to a circular definition, in the sense that the definition contains a reference to the thing being defined. A truly circular definition is typically not very useful:
If you saw that definition in the dictionary, you might be annoyed. On the other hand, if you looked up the definition of the mathematical function factorial, you might get something like:
(Factorial is usually denoted with the symbol !, which is not to be confused with the Java logical operator ! which means NOT.) This definition says that the factorial of 0 is 1, and the factorial of any other value, n, is n multiplied by the factorial of n1. So 3! is 3 times 2!, which is 2 times 1!, which is 1 times 0!. Putting it all together, we get 3! equal to 3 times 2 times 1 times 1, which is 6. If you can write a recursive definition of something, you can usually write a Java program to evaluate it. The first step is to decide what the parameters are for this function, and what the return type is. With a little thought, you should conclude that factorial takes an integer as a parameter and returns an integer: public static int factorial (int n) {} If the argument happens to be zero, all we have to do is return 1: public static int factorial (int n) {if (n == 0) { return 1; } } Otherwise, and this is the interesting part, we have to make a recursive call to find the factorial of n1, and then multiply it by n. public static int factorial (int n) {if (n == 0) { return 1; } else { int recurse = factorial (n1); int result = n * recurse; return result; } } If we look at the flow of execution for this program, it is similar to nLines from the previous chapter. If we invoke factorial with the value 3: Since 3 is not zero, we take the second branch and calculate the factorial of n1... Since 2 is not zero, we take the second branch and calculate the factorial of n1... Since 1 is not zero, we take the second branch and calculate the factorial of n1... Since 0 is zero, we take the first branch and return the value 1 immediately without making any more recursive calls. The return value (1) gets multiplied by n, which is 1, and the result is returned. The return value (1) gets multiplied by n, which is 2, and the result is returned. The return value (2) gets multiplied by n, which is 3, and the result, 6, is returned to main, or whoever invoked factorial (3). Here is what the stack diagram looks like for this sequence of function calls: The return values are shown being passed back up the stack. Notice that in the last instance of factorial, the local variables recurse and result do not exist because when n=0 the branch that creates them does not execute.


Home Fruitful Methods More Recursion 