Java [Recursion]

Recursion Definition

The idea of calling one function from another immediately suggests the possibility of a function calling itself. The function-call mechanism in Java supports this possibility, which is known as recursion.

Recursive Call in Method

When you do the recursive call in the method, the parameter is usually decremented so you can reach the base case. [NOT ALWAYS BUT USUALLY]

Two non-negative integers x and y are equal if either: Both are 0, or x-1 and y-1 are equal Write a boolean-method named equals that recursively determines whether its two int parameters are equal and returns true if they are and false otherwise

boolean equals(int x, int y) { if ((x < 0) || (y < 0)) { return false; } if ((x == 0) && (y == 0)) { return true; } return equals(x - 1, y - 1); }

The nth harmonic number is defined non-recursively as: 1 + 1/2 + 1/3 + 1/4 + ... + 1/n. Come up with a recursive definition and use it to guide you to write a method definition for a double-valued method named harmonic that accepts an int parameters n and recursively calculates and returns the nth harmonic number.

double harmonic(int n){ if(n == 0.0){ return 0.0; } return (1.0/n + harmonic(n - 1)); }

Given non-negative integers x and n, x taken to the nth power can be defined as: x to the 0th power is 1 x to the nth power can be obtained by multiplying x to the n-1'th power with x Write a long-valued method named power that accepts an two int parameters x and n (in that order) and recursively calculates and returns the value of x taken to the n'th power.

int power(int x, int n) { if (n == 1){ return x; } if (n == 0){ return 1; } return power(x, n - 1) * x; }

Without using a division or multiplication operator and without using iteration, define a recursive method named product that accepts two int parameter, m and k, and calculates and returns the integer product of m times k . You can count on m>=0 and k>=0.

int product(int m, int k){ if (k == 0) { return m; } else if (k == 1) { return (m); } else { return (product(m, k - 1) + m); } }

Consider a simple form of integer division: m / k where we are guaranteed that m>=0 and k>0. This can be computed as follows: The quotient is 0 when k is greater than m. Otherwise, the quotient is one more than (m-k)/k . Write an int method named quotient that accepts two int parameters, m and k, and recursively calculates and returns the integer quotient of m/k. You can count on m>=0 and k>0. Do not use a division operator here!

int quotient(int m, int k){ if(k ==0){ return 0; }else if(m-k == 0){ return 1; }else if(m < k){ return 0; }else{ return quotient(m - k, k) + 1; }

Call Stack

is the "counter" of a recursive method that keeps track of the values calculated in the method.

The sum of the numbers from 1 to n can be defined recursively as follows: The sum from 1 to 1 is 1. The sum from 1 to n is n more than the sum from 1 to n-1. Write a int-method named sum that accepts an int parameter, n, and recursively calculates and returns the sum of the numbers from 1 to n

public int sum(int n) { if (n == 1) { return 1; } else { return (sum(n - 1) + n); } }

Write a method called fact that recursively calculates the factorial value of its single int parameter. The value returned by fact is a long

public long fact(int n) { if (n <= 1) { return 1; } else { return (fact(n - 1) * (long) n); } }

The Fibonacci series: 0, 1, 1, 2, 3, 5, 8, 13, 21, has as its first 2 values, 0 and 1; each successive value if then calculated as the sum of the previous two values. The first element in the series is the 0'th element, thus the value 8 is element 6 of the series. The n'th element of the series, written as fib(n), is thus defined as: n if n = 0 or n = 1 fib(n-1) + fib(n-2) Write the int-valued method fib, that takes a single int parameter (say n), and recursively calculates and then returns the n'th element of the Fibonacci series.

public static int fib(int n) { if (n == 0 || n==1){ return n; } return fib(n - 1) + fib(n - 2); }

Assume the availability of a method named printStars that can be passed a non-negative integer n and print a line of n asterisks. Write a method named printTriangle that receives a non-negative integer n and prints a triangle of asterisks as follows: first a line of 1 asterisk, followed by a line of 2 asterisks, and then a line of 3 asterisks, and so on and finally a line of n asterisks. For example, if the method received 5 it would print: * * * * * * * * * * * * * * * The method must not use a loop of any kind (for, while, do-while) to accomplish its job. The method should invoke printStars to accomplish the task of printing a single line.

public void printTriangle(int n){ if(n<1){ return; } printTriangle(n-1); printStars(n); }

Assume the availability of a method named makeLine that can be passed a non-negative integer n and a character c and return a String consisting of n identical characters that are all equal to c. Write a method named printTriangle that receives two integer parameters n and k. If n is negative the method does nothing. If n happens to be an even number, its value is raised to the next odd number (e.g. 4-->5). Then, when k has the value zero, the method prints a SYMMETRIC triangle of O's (the capital letter O) as follows: first a line of n O, followed by a line of n-2 O's (indented by one space), and then a line of n-4 O's (indented by two spaces), and so on. For example, if the method received 5,0 (or 4,0) it would print: OOOOO OOO O Note: in the above output, the first line contains 0 spaces before the first O, the next line 1 space, and so on. Note: These instructions state what the method does when k is zero, but it is up to you, the programmer, to determine what it does when k is not zero and use it for your advantage. The method must not use a loop of any kind (for, while, do-while) to accomplish its job. The method should invoke makeLine to accomplish the task of creating Strings of varying lengths.

public void printTriangle(int n, int k){ if(n < 1){ return; } if(n%2==0){ n = n + 1; } System.out.println(makeLine(k, ' ') + makeLine(n, 'O')); printTriangle(n - 2, ++k); }