Recursion is the process of defining a problem (or the solution to a problem) in terms of (a simpler version of) itself. For example, we can define the operation “find your way home” as: If you are at home, stop moving.

In computability theory, a primitive recursive function is roughly speaking a function that can be computed by a computer program whose loops are all “for” loops (that is, an upper bound of the number of iterations of every loop can be determined before entering the loop).

A recursive function is a function that calls itself during its execution. The process may repeat several times, outputting the result and the end of each iteration. Recursive functions allow programmers to write efficient programs using a minimal amount of code.

Recursion is made for solving problems that can be broken down into smaller, repetitive problems. It is especially good for working on things that have many possible branches and are too complex for an iterative approach. One good example of this would be searching through a file system.

Answer:To solve a problem.

2. Which function will you choose to join two words? Explanation: The strcat() function is used for concatenating two strings, appends a copy of the string. char *strcat(char *s1,const char *s2);

A recursive function calls itself, the memory for a called function is allocated on top of memory allocated to calling function and different copy of local variables is created for each function call. Let us take the example how recursion works by taking a simple function.

One downside of recursion is that it may take more space than an iterative solution. Building up a stack of recursive calls consumes memory temporarily, and the stack is limited in size, which may become a limit on the size of the problem that your recursive implementation can solve.

A recursive function is simply a function that calls itself as many times as it needs to do so. It’s useful if you need to process something multiple times, but you’re unsure how many times will actually be required. In a way, you could think of a recursive function as a type of loop.

1. Step 1) Know what your function should do.
2. Step 2) Pick a subproblem and assume your function already works on it.
3. Step 3) Take the answer to your subproblem, and use it to solve for the original problem.
4. Step 4) You have already solved 99% of the problem. The remaining 1%? Base case.

Basic steps of recursive programs

1. Initialize the algorithm.
2. Check to see whether the current value(s) being processed match the base case.
3. Redefine the answer in terms of a smaller or simpler sub-problem or sub-problems.
4. Run the algorithm on the sub-problem.
5. Combine the results in the formulation of the answer.

Mechanics

1. Determine the base case of the Recursion. Base case, when reached, causes Recursion to end.
2. Implement a loop that will iterate until the base case is reached.
3. Make a progress towards the base case. Send the new arguments to the top of the loop instead to the recursive method.

Recursion is (in many, but not all) languages slightly slower, and it does have some dangers (smashing the stack), but used properly it’s a completely legitimate, valuable tool for production code.