Recursive Function Called Again Despite Returning False C

Recursion in C

By Alex Allain

Recursion is a programming technique that allows the developer to limited operations in terms of themselves. In C, this takes the form of a function that calls itself. A useful way to think of recursive functions is to imagine them as a process being performed where one of the instructions is to "repeat the procedure". This makes it sound very similar to a loop because it repeats the same lawmaking, and in some ways it is similar to looping. On the other mitt, recursion makes it easier to express ideas in which the effect of the recursive call is necessary to complete the task. Of course, it must exist possible for the "process" to sometimes be completed without the recursive phone call. One simple example is the idea of building a wall that is ten anxiety high; if I want to build a x pes loftier wall, then I will first build a nine foot high wall, and so add an extra pes of bricks. Conceptually, this is like maxim the "build wall" office takes a height and if that height is greater than one, first calls itself to build a lower wall, and then adds one a foot of bricks.

A simple example of recursion would be:

void recurse() {     recurse(); /* Function calls itself */ }  int master() {     recurse(); /* Sets off the recursion */     render 0; }        

This programme will non go along forever, yet. The computer keeps function calls on a stack and once likewise many are called without ending, the program will crash. Why not write a program to see how many times the function is called earlier the program terminates?

#include <stdio.h>  void recurse ( int count ) /* Each call gets its ain copy of count */ {     printf( "%d\n", count );     /* It is not necessary to increment count since each function's        variables are carve up (then each count volition be initialized one greater)      */     recurse ( count + 1 ); }  int master() {   recurse ( one ); /* First function call, so it starts at one */   render 0; }        

This uncomplicated program will show the number of times the recurse function has been called past initializing each individual function telephone call'southward count variable one greater than information technology was previous by passing in count + 1. Keep in mind that information technology is non a part call restarting itself; it is hundreds of part calls that are each unfinished.

The best way to retrieve of recursion is that each function telephone call is a "process" being carried out by the computer. If we call back of a programme as being carried out by a grouping of people who tin can laissez passer effectually information about the state of a task and instructions on performing the task, each recursive office call is a chip similar each person asking the next person to follow the same set up of instructions on some function of the job while the first person waits for the issue.

At some point, nosotros're going to run out of people to comport out the instructions, simply every bit our previous recursive functions ran out of space on the stack. There needs to be a mode to avoid this! To halt a series of recursive calls, a recursive function will accept a condition that controls when the office will finally stop calling itself. The condition where the function will not call itself is termed the base case of the office. Basically, it will usually exist an if-statement that checks some variable for a status (such every bit a number existence less than nothing, or greater than some other number) and if that condition is true, it volition not allow the part to phone call itself over again. (Or, it could check if a certain condition is true and just and then allow the function to telephone call itself).

A quick example:

void count_to_ten ( int count ) {     /* we merely keep counting if we have a value less than ten */        if ( count < 10 )           {            count_to_ten( count + 1 );        } } int chief() {   count_to_ten ( 0 );  }        

This program ends when we've counted to ten, or more than precisely, when count is no longer less than ten. This is a good base example considering it means that if we accept an input greater than ten, nosotros'll stop immediately. If we'd chosen to stop when count equaled 10, then if the function were chosen with the input 11, it would run out of retentivity before stopping.

Notice that so far, we haven't washed anything with the outcome of a recursive function telephone call. Each phone call takes identify and performs some action that is so ignored by the caller. Information technology is possible to get a value back from the caller, nevertheless. It'southward besides possible to take reward of the side effects of the previous call. In either case, once a role has called itself, it volition be set to go to the adjacent line after the phone call. It can still perform operations. One function you could write could impress out the numbers 123456789987654321. How tin you use recursion to write a function to exercise this? Simply have it keep incrementing a variable passed in, and and then output the variable twice: once before the function recurses, and once after.

#include <stdio.h> void printnum ( int begin ) {     printf( "%d", begin );     if ( begin < ix )         /* The base case is when brainstorm is no longer */     {                           /* less than 9 */         printnum ( begin + one );      }     /* brandish begin again afterward nosotros've already printed everything from 1 to 9      * and from 9 to brainstorm + 1 */     printf( "%d", begin ); }  int main() {     printnum(0);     getchar(); }        

This function works because it will go through and print the numbers begin to 9, and then every bit each printnum role terminates it volition continue printing the value of brainstorm in each function from nine to brainstorm.

This is, however, just touching on the usefulness of recursion. Here's a lilliputian challenge: use recursion to write a program that returns the factorial of whatsoever number greater than 0. (Factorial is number * (number - 1) * (number - 2) ... * i).

Hint: Your function should recursively notice the factorial of the smaller numbers first, i.e., it takes a number, finds the factorial of the previous number, and multiplies the number times that factorial...have fun. :-)

Previous: Linked Lists
Adjacent: Functions with variable arguments
Back to C Tutorial Index

kingfered1985.blogspot.com

Source: https://www.cprogramming.com/tutorial/c/lesson16.html

Share this post