Why recursion

To such people, the iterative approach typically using loops feels more natural. Those of us who cut our programming teeth on procedural or object-oriented programming have often been told to avoid recursion because it's error prone. We're often told that recursion is slow. Calling and returning from a routine repeatedly involves a lot of stack pushing and popping, which is slower than looping.

I think some languages handle this better than others, and those languages are most likely not those where the dominant paradigm is procedural or object-oriented. For at least a couple of programming languages I've used, I remember hearing recommendations not to use recursion if it gets beyond a certain depth because its stack isn't that deep.

A recursive statement is one in which you define the process of what to do next as a combination of the inputs and what you have already done. Of course, the tricky thing about recursion is that if you want to define things in terms of what you have already done, there needs to be some place to start.

It can be a bit confusing to get your head around at first, but just look at a bunch of examples and it should all come together. If you want a much deeper understanding of the concept, study mathematical induction. Also, be aware that some languages optimize for recursive calls while others do not.

It's pretty easy to make insanely slow recursive functions if you're not careful, but there are also techniques to make them performant in most cases. I like this definition: In recursion, a routine solves a small part of a problem itself, divides the problem into smaller pieces, and then calls itself to solve each of the smaller pieces.

One problem with computer-science textbooks is that they present silly examples of recursion. The typical examples are computing a factorial or computing a Fibonacci sequence. Recursion is a powerful tool, and it's really dumb to use it in either of those cases. If a programmer who worked for me used recursion to compute a factorial, I'd hire someone else.

I thought this was a very interesting point to raise and may be a reason why recursion is often misunderstood. People use recursion only when it is very complex to write iterative code. For example, tree traversal techniques like preorder, postorder can be made both iterative and recursive. But usually we use recursive because of its simplicity.

Here's a simple example: how many elements in a set. There's a lot more useful examples traversing a tree, for example which I'm sure other people will cover.

Well, that's a pretty decent definition you have. And wikipedia has a good definition too. So I'll add another probably worse definition for you. When people refer to "recursion", they're usually talking about a function they've written which calls itself repeatedly until it is done with its work.

Recursion can be helpful when traversing hierarchies in data structures. An example: A recursive definition of a staircase is: A staircase consists of: - a single step and a staircase recursion - or only a single step termination. To recurse on a solved problem: do nothing, you're done.

To recurse on an open problem: do the next step, then recurse on the rest. You have a lot of apples in front of you on a table and you want to know how many apples there are. A recursive function is a function that contains a call to itself. A recursive struct is a struct that contains an instance of itself. You can combine the two as a recursive class. Consider two mirrors facing each other. We've seen the neat infinity effect they make.

Each reflection is an instance of a mirror, which is contained within another instance of a mirror, etc. The mirror containing a reflection of itself is recursion.

A binary search tree is a good programming example of recursion. The structure is recursive with each Node containing 2 instances of a Node.

Functions to work on a binary search tree are also recursive. This is an old question, but I want to add an answer from logistical point of view i. I use Java for work, and Java doesn't support nested function. As such, if I want to do recursion, I might have to define an external function which exists only because my code bumps against Java's bureaucratic rule , or I might have to refactor the code altogether which I really hate to do.

Thus, I often avoid recursion, and use stack operation instead, because recursion itself is essentially a stack operation. Recursion as it applies to programming is basically calling a function from inside its own definition inside itself , with different parameters so as to accomplish a task.

Recursion is a problem-solving strategy for huge problems, where at every step just, "turn 2 small things into one bigger thing," each time with the same hammer.

Suppose your desk is covered with a disorganized mess of papers. How do you make one neat, clean stack of papers from the mess, using recursion? Notice that this is pretty intuitive, aside from counting everything which isn't strictly necessary.

You might not go all the way down to 1-sheet stacks, in reality, but you could and it would still work. The important part is the hammer: With your arms, you can always put one stack on top of the other to make a bigger stack, and it doesn't matter within reason how big either stack is. Recursion is the process where a method call iself to be able to perform a certain task. It reduces redundency of code. Most recurssive functions or methods must have a condifiton to break the recussive call i.

Not all functions are suited to be used recursively. Jack manages 2 programmers, John - 3, and Morgan - 5. The answer is obvious - but what if 2 of Morgan-s employees are also managers? HERE comes the recursion. You'll never know, how much cycles will you go before getting an answer, though you know how many managers you have and how many Budget can you spend.

Recursion is a tree, with branches and leaves, called parents and children respectively. When you use a recursion algorithm, you more or less consciously are building a tree from the data. Any algorithm exhibits structural recursion on a datatype if basically consists of a switch-statement with a case for each case of the datatype. Stack Overflow for Teams — Collaborate and share knowledge with a private group.

Create a free Team What is Teams? Collectives on Stack Overflow. Learn more. What is recursion and when should I use it? Ask Question. Asked 13 years, 3 months ago. Active 4 years, 10 months ago. Viewed k times. Mike Minutillo. And maybe this helps: stackoverflow. This may help grasp the concept: navigate to the link provided on the second comment of the question on this page and do what the comments say to do: stackoverflow.

Active Oldest Votes. To see why, walk through the steps that the above languages use to call a function: space is carved out on the stack for the function's arguments and local variables the function's arguments are copied into this new space control jumps to the function the function's code runs the function's result is copied into a return value the stack is rewound to its previous position control jumps back to where the function was called Doing all of these steps takes time, usually a little bit more than it takes to iterate through a loop.

Good to see an explanation of the inherent overhead of recursion. I touched on that in my answer as well. But to me, the big strength with recursion is what you can do with the call stack. See my answer for an example. Very disappointed to find the top answer to a question titled "What is recursion and when should I use it? You're probably right Dukeling.

For context, when I wrote this answer there were many great explanations of recursion already written and I wrote this intending to be an adjunct to that info, not the top answer. In practice when I need to walk a tree or handle any other nested data structure I usually turn to recursion and I've yet to hit a stack overflow of my own making in the wild. Add a comment. Simple english example of recursion. A child couldn't sleep, so her mother told her a story about a little frog, who couldn't sleep, so the frog's mother told her a story about a little bear, who couldn't sleep, so the bear's mother told her a story about a little weasel There is a similar story like this for little kids who won't fall asleep in Chinese folk tales, I just remembered that one, and it reminds me how real world recursion works.

Direct mutual recursion is virtually always intentional and designed by the programmer. But unexpected mutual recursion can lead to bugs. When we talk about concurrency later in the course, reentrancy will come up again, since in a concurrent program, a method may be called at the same time by different parts of the program that are running concurrently. Reentrant code is safer from bugs and can be used in more situations, like concurrency, callbacks, or mutual recursion.

Another reason to use recursion is to take more advantage of immutability. In an ideal recursive implementation, all variables are final, all data is immutable, and the recursive methods are all pure functions in the sense that they do not mutate anything.

The behavior of a method can be understood simply as a relationship between its parameters and its return value, with no side effects on any other part of the program. This kind of paradigm is called functional programming , and it is far easier to reason about than imperative programming with loops and variables. In iterative implementations, by contrast, you inevitably have non-final variables or mutable objects that are modified during the course of the iteration.

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.

On the bright side, what would be an infinite loop in an iterative implementation usually becomes a StackOverflowError in a recursive implementation. A buggy recursive program fails faster. For subsequences "" , how deep does its recursive call stack get? How many recursive calls to subsequences can be active at the same time? Safe from bugs. Recursive code is simpler and often uses immutable variables and immutable objects. Easy to understand.

Recursive implementations for naturally recursive problems and recursive data are often shorter and easier to understand than iterative solutions. Ready for change. Recursive code is also naturally reentrant, which makes it safer from bugs and ready to use in more situations. Software in 6. Communicating clearly with future programmers, including future you.

Designed to accommodate change without rewriting. A recursive function is defined in terms of base cases and recursive steps. In a base case, we compute the result immediately given the inputs to the function call. In a recursive step, we compute the result with the help of one or more recursive calls to this same function, but with the inputs somehow reduced in size or complexity, closer to a base case.

Consider writing a function to compute factorial. Reading exercises Recursive factorial. Consider this recursive implementation of the factorial function. Recursive Fibonacci. Consider this recursive implementation of the Fibonacci sequence. What does subsequences "c" return? What does subsequences "gc" return? Reading exercises Recursive structure.

Reading exercises Unhelpful 1. What does subsequencesLouis "c" return? Unhelpful 2. Unhelpful 3. It will produce these recursive calls to subsequencesLouis : 1. Reading exercises Implementing stringValue. In the output, value from 3 to 1 are printed and then 1 to 3 are printed. The memory stack has been shown in below diagram. For basic understanding please read the following articles. Basic understanding of Recursion.

The time complexity of the given program can depend on the function call. What are the disadvantages of recursive programming over iterative programming? Note that both recursive and iterative programs have the same problem-solving powers, i. The recursive program has greater space requirements than iterative program as all functions will remain in the stack until the base case is reached.

It also has greater time requirements because of function calls and returns overhead. What are the advantages of recursive programming over iterative programming? Recursion provides a clean and simple way to write code. Some problems are inherently recursive like tree traversals, Tower of Hanoi , etc. For such problems, it is preferred to write recursive code. We can write such codes also iteratively with the help of a stack data structure. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.

See your article appearing on the GeeksforGeeks main page and help other Geeks. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. Skip to content. Change Language. Related Articles. Table of Contents. Save Article. Improve Article. Like Article. A Python 3 program to.