I have a BST and I found this function online, which prints it in the correct order, but I don't understand how.
void display()
{
inOrder(root);
}
void inOrder(treeNode* n)
{
classA foo;
if (n != NULL)
{
inOrder(n->left);
foo = *n->item;
cout << foo << endl << endl;
inOrder(n->right);
}
}
I initialize each node's left and right to NULL. Why does the if statement continue after a NULL pointer is sent in, and where does it continue from?
Say you have the following BST:
When inOrder is called with this BST,
Recursion level 0
n points to 8. So you enter the block:
inOrder(n->left);
foo = *n->item;
cout << foo << endl << endl;
inOrder(n->right);
inOrder is called using n->left as argument, which is node 3.
Recursion level 1
n points to 3. So you enter the same code block.
inOrder is called using n->left as argument, which is node 1.
Recursion level 2
n points to 1. So you enter the same code block.
inOrder is called using n->left as argument, which is NULL.
Recursion level 3
n points to NULL. So you do not enter the above code block. You simply return from the function. Now are back in the next statement in the previous recursion level.
Recursion level 2
The following lines are executed:
foo = *n->item;
cout << foo << endl << endl;
inOrder(n->right);
You print 1. Then, inOrder is called using n->right as argument, which is NULL.
Recursion level 3
n points to NULL. So you do not enter the above code block. You simply return from the function. Now are back in the next statement in the previous recursion level.
Recursion level 2
There are no more lines to execute. The function simply returns to previous recursion level.
Recursion level 1
The following lines are executed:
foo = *n->item;
cout << foo << endl << endl;
inOrder(n->right);
You print 3. Then, inOrder is called using n->right as argument, which is node 6.
You can now follow this step by step all the way. The end result is that you will end up printing the numbers in the following order.
1
3
4
6
7
8
10
13
14
Related
I have a simple recursive c++ program and I am trying to understand exactly how it works. I understand why the program prints out 3 2 1, but then I don't understand why it goes the other way and prints 1 2 3. I used a hand-simulation and walked through the program step-by-step but still don't understand how the 1 2 3 comes about. I found this article from GeeksForGeeks but am still having difficulty grasping the concept. Any explanation would be awesome.
#include <iostream>
using namespace std;
void test(int n)
{
if (n > 0)
{
cout << n << " ";
test(n - 1);
cout << n << " ";
}
}
int main()
{
test(3);
return 0;
}
The order of function calls in your recursion looks something like this:
test(3)
-- cout << 3 << " ";
-- test(2)
-- -- cout << 2 << " ";
-- -- test(1)
-- -- -- cout << 1 << " ";
-- -- -- test(0)
-- -- -- cout << 1 << " ";
-- -- cout << 2 << " ";
-- cout << 3 << " ";
Change your program to
#include <iostream>
using namespace std;
void test(int n)
{
if (n > 0)
{
cout << "enter" << n << " "; // <- add "enter" here
test(n - 1);
cout << "exit" << n << " "; // <- add "exit" here
}
}
int main()
{
test(3);
return 0;
}
and you will see next output
enter3 enter2 enter1 exit1 exit2 exit3
You can think about recursive calls as operations with a stack.
There are two operations: push and pop.
What your program does is
push test 3
push test 2
push test 1
pop test 1
pop test 2
pop test 3
On every push and pop you do cout and thus see the output 3 2 1 1 2 3.
Here you can find more about recursion.
The thing is that all the answers don't help you because even if someone got it explained to you, you will stuck in the next algorithm.
I am offering a fundamental approach that helped me a lot with understanding some search algorithms, linked lists, binary trees and much more because I am a simple mind.
What you have to do is figuring out ways to represent the data in the most creative ways you can come up with. Because programming is just flipping data in lots of ways. A few examples I came up with is using plastic cans and post its or grapes and plates, I've seen some indian video guys that draw the data flow on charts or just with circles on a sheet of paper with different colors if you want
and that works as follows:
put the data on the post its, one for each round. You got a simple algorithm and I would write a "3" because it is passed through the function.
The jars, represent the function calls, I would take a jar for every call.
Simulate the algorithm bit by bit. Like taping the 3 on the jar -> first cout "3" -> test get called "n - 1" so "2" goes in a new jar (writing 2 on the post it)
-> second cout "2" -> test get called "n - 1" so 1 goes again in a new jar. (writing 1 on the post it)
->third cout "1" -> test get called "n - 1" so 0 goes in a new jar. (writing 0 on the post it) - but wait! 0 is not bigger as 0! So that jar won't pass the if command! so the test doesn't gets called again - function over.
Now look at your place! you got still 4 jars and the second cout in the function is not even called once - now its time because every jar represents one function call that is not finished and still open. what number is in the jar you put in last? Right, a 1! So "1" get to the cout. Crumple the post it, put the jar back. What is in the next jar? a "2"? bingo - that is printed through the second cout. The last cup has a 3 in it? - right, print it with cout than crumple the post it up. No cups anymore? No data to print out? you done!
Thats how the program works!
Congrats, because I am sure you grasped it now! :)
Btw. if you come to a point where you don't know where the data flows, every good IDE has a debugger that let you run exactly the steps the program does and it stops after every step. It is really good explained how to use a debugger in alex allain "jump to c++" and he has a whole chapter on how to read and write a program, also a whole chapter about recursion and i think 6 for pointers alone. He gave the tip to find ways to represent data and I hope that helps you as much as it helped me :)
Cheers
It's because you have the cout statement after calling the "test" method in your if-statement. After it walks down all the method calls and hits the base case, it then returns out of each of those method calls moving on to the next line (the cout statement) in the reverse order the methods got called in.
To make it clear rewrite the function
void test( unsigned int n )
{
if ( n )
{
std::cout << n << " ";
test( n - 1 );
std::cout << n << " ";
}
}
the following way
void test( unsigned int n )
{
if ( n )
{
std::cout << n << " ";
std::cout << n << " ";
test( n - 1 );
}
}
That is move the second statement
std::cout << n << " ";
above the statement
test( n - 1 );
For the call test( 3 ); of the modified function you will get the following output
3 3 2 2 1 1
So each recursive call of the function two times outputs the passed value n. I hope it is clear because the function explicitly contains the same statement two times
std::cout << n << " ";
std::cout << n << " ";
Now returning to the original function definition we see that between the two outputs of the same value n the function calls itself with the value n - 1.
So each function call outputs the same value two times but between the outputs the function calls itself recursively.
Now the output can look like
3 3
|
call itself for 2
... and so on.
So I've just started C++ programming, and am a little stuck on one particular program that was used to demonstrate how recursive functions work. I do know the premise of recursive functions, that being a function which calls itself until an exit condition has been met. I understood the concept using the program for factorials,
int factorial(int n)
{
if (n==1)
{
return 1;
}
else
{
return n*factorial(n-1);
}
}
the if statement being the exit condition in the above code.
However, the code that tripped me up was from this link:
http://www.cprogramming.com/tutorial/lesson16.html
specifically this code:
#include <iostream>
using namespace std;
void printnum ( int begin )
{
cout<< begin<<endl;
if ( begin < 9 ) // The base case is when begin is greater than 9
{ // for it will not recurse after the if-statement
printnum ( begin + 1 );
}
cout<< begin<<endl; // Outputs the second begin, after the program has
// gone through and output
}
int main()
{
printnum(1);
return 0;
}
OP:
1
2
3
4
5
6
7
8
9
9
8
7
6
5
4
3
2
1
In the immediately above code, I understand the output till the first 9. But after that, why does the cout statement following the if loop cause the begin variable to start counting backwards till it reaches the value it originally was when printvalue was first called? I suppose I don't really understand the exit condition here.
Not sure what I'm missing, and any help would be greatly appreciated.
Thanks.
Each begin is unique and belongs to the "current" active function – its value never changes.
Recursive functions work exactly like other functions; it doesn't matter to one what the parameter of another is named.
If you had these:
void f(int x);
void g(int x)
{
cout << x << endl;
f(x+1);
cout << x << endl;
}
you would be very surprised (I hope) if g printed two different numbers.
Your recursion works exactly like this (much smaller) example that uses unique functions instead of recursion with a parameter:
void printnum_3()
{
cout << 3 << endl;
cout << 3 << endl;
}
void printnum_2()
{
cout << 2 << endl;
printnum_3();
cout << 2 << endl;
}
void printnum_1()
{
cout << 1 << endl;
printnum_2();
cout << 1 << endl;
}
int main()
{
printnum_1();
}
So, lets see what happens when printnum(1) is called.
begin equals 1, it is printed with cout and then printnum(2) is called.
But what happens when the program leaves printnum(2) function? It continues to execute printnum(1) from the place, where printnum(2) was called. So, the next line to execute is cout << begin. begin still equals 1, because we are executing printnum(1) function. This is why 1 is printed once again at the end. The situation is totally the same with other function calls.
For example, when printnum(9) is called, it prints 9, then the if check fails (begin is not less, than 9) and then 9 is printed once again.
why does the cout statement following the if loop cause the begin variable to start counting backwards till it reaches the value it originally was when printvalue was first called?
To start with, there is no loop. There is call stack which you need to understand. Recursive call stops when (begin < 9) becomes false i.e. when begin = 9. You are seeing the call stack unwinding.
First cout in the function is printing sequence [1..9], and second cout is printing the decreasing sequence [9..1].
Your code execution is like this:
cout<< 1 <<endl; //enter1
cout<< 2 <<endl; //enter2
cout<< 3 <<endl; //enter3
...
cout<< 8 <<endl; //enter8
cout<< 9 <<endl; //enter9
cout<< 9 <<endl; //exit9
cout<< 8 <<endl; //exit8
...
cout<< 3 <<endl; //exit3
cout<< 2 <<endl; //exit2
cout<< 1 <<endl; //exit1
I have problem understanding this code:
#include <iostream>
using namespace std;
void Print_numm(int numm){
cout<<numm;
if (numm<=4) {
Print_numm(numm+1);
}
cout<<numm;
}
int main() {
Print_numm(1);
return 0;
}
The output is 1234554321.
I understand the recursion up until it prints 123455. But why the compiler prints the rest of of numbers down to 1? Does the compiler do the second "cout" every time? And if so how it keeps the numbers until they are printed up to 5 and then prints the rest downward?
If you visualize the execution of the call it will be easier to understand:
Print_numm(1)
-> cout 1
-> Print_numm(2)
--> cout 2
-->Print_numm(3)
---> cout 3
---> Print_numm(4)
----> cout 4
----> Print_numm(5)
-----> cout 5
-----> cout 5
----> cout 4
---> cout 3
--> cout 2
-> cout 1
Are you familiar with a stack?
The function calls itself,and prints every number upwards,then it returns from the final recursive call,going downwards through the numbers,as it return from recursion repeatedly.It just executes the rest of the code that it contains after the recursive call.
A simple representation of this is:
print_numm(1):
cout << 1
print_numm(1+1):
cout << 2
print_numm(2+1):
cout << 3
print_numm(3+1):
cout << 4
print_numm(4+1):
cout << 5
//now the number is bigger than 4 so the function
//will return from recursion
cout << 5
//now the function is done,but the function that called print_numm(5) is waiting to finish
//so it executes the rest of the code printing 4,same with all waiting for print_numm(4) and so on
cout << 4
cout << 3
cout << 2
cout << 1
Here's how the code get's executed, you can easily tell this way why you get the output in discussion:
Print_numm(1)->
cout<<1
Print_numm(2)->
cout<<2
Print_numm(3)->
cout<<3
Print_numm(4)->
cout<<4
Print_num(5)->
cout<<5
cout<<5
cout<<4
cout<<3
cout<<2
cout<<1
The second cout is placed after the recursive call, this means that it will get executed after all the inner calls return.
You can see that it would do this (assuming it returns).
cout<<1;
Print_numm(2);
cout<<1;
which can be expanded to:
cout<<1;
cout<<2;
Print_numm(3);
cout<<2;
cout<<1;
and then eventually output "1234554321".
Since the condition numm<=4 become false at numm=5.
Therefore numm stops incrementing and rest of the code of the previously calling functions executed.
The function recurses from 1 to 5, and these numbers are output in the first call to cout << numm (the first line of the Print_numm function. Once the if statement evaluates to false the recursion starts to unwind, and as the calls to Print_numm return they encounter the final cout << numm line on the last line of the function and print from 5 to 1.
The execution would be easier to visualize if you added some extra diagnostics to your code. Consider this change:
#include <iostream>
using namespace std;
void Print_numm(int numm){
cout << "enter: " << numm << endl;
if (numm<=4) {
Print_numm(numm+1);
}
cout << "exit: " << numm << endl;
}
int main() {
Print_numm(1);
return 0;
}
Which produces:
enter: 1
enter: 2
enter: 3
enter: 4
enter: 5
exit: 5
exit: 4
exit: 3
exit: 2
exit: 1
You can also use a debugger to step through to help you understand this better.
One important code understanding principle. Adding good diagnostics greatly decreases the amount of mental effort and aptitude required to understand what is happening.
Hello i am learning recursion and currently i have couple of trick problems to dissect - here is one of recursive functions
int rec(int niz[], int start, int end){
if (start == end)
{
return niz[start]; // vraca zadnji
}
int temp = rec(niz, start+1, end);
// control output
cout << "\n-----\n";
cout << "start " << start << endl;
cout << "niz[start] " << niz[start] << endl;
cout << "end " << end << endl;
cout << "temp " << temp << endl;
cout << "\n-----------------------------------------\n";
//contrl output end
return ((niz[start] < temp) ? niz[start] : temp);
}
i included a cout block to control what is gong on in calls. here is main part
int niz[] = {1,2,3,4,5,6,7};
cout << rec(niz, 0, 3);
and here is my output:
-----
start 2
niz[start] 3
end 3
temp 4
------------------
-----
start 1
niz[start] 2
end 3
temp 3
------------------
-----
start 0
niz[start] 1
end 3
temp 2
------------------
1
can anyone explain me how is temp value being calculated and returned and how i am getting 1 as the return of this function?
Thank You in advance!
Recursive function is the function that calls itself.
int temp = rec(niz, start+1, end);
Here you call the "rec" function inside the one, but with the changed parameter (start + 1). You call these function inside each other until the "start" equals "end" (then it returns)
if (start == end)
{
return niz[start]; // vraca zadnji
}
After the deepest one returns the second deepest one continues its flow, printing some information.
cout << "\n-----\n";
cout << "start " << start << endl;
cout << "niz[start] " << niz[start] << endl;
cout << "end " << end << endl;
cout << "temp " << temp << endl;
cout << "\n-----------------------------------------\n";
Then it it returns the lowest value between niz[start] and temp (local values).
return ((niz[start] < temp) ? niz[start] : temp);
Then the third deepest one continues its flow and so on. Until it gets to the first function.
In your main part you set the end to 3, so it performs the operation on the first 3 elements (it gets to the fourth element, but doesn't do anything beside returning its value). You get 1 by comparing the niz[0], that you passed as start, and temp that is returned by recursive function (which happens to be the same). It equals, so the return value is niz[0] that is 1;
When using recursive functions, you should have some kind of "exit point" that prevents the recursion to become infinite, i.e.
if (start == end)
{
return niz[start];
}
In general, recursive functions look like this:
f()
{
//return condition
//some work
f();
//some work
//return
}
And you can look at them as this
f()
{
//some code
f()
{
//some code
f()
{
//some code
f()
{
...
//eventually the return condition is met
}
//some code
//return
}
//some code
//return
}
//some code
//return
}
Keep in mint that unhandled recursion may lead to possible memory leaks, because each function call comes with additional data.
f()
{
f();
}
This will lead to stack overflow due to system data that has been created;
You may want to watch "Inception" to understand it better :)
rec(niz, 0, 3) (D)
|
---->rec(niz, 1, 3) (C)
|
----> rec(niz, 2, 3) (B)
|
----> rec(niz, 3, 3) (A)
You call (D) which calls (C) to calculate temp and so on up to (A). In (A) start==end and it returns niz[3]=4.
In (B):
temp = 4 (result of (A))
start = 2
As 4 is bigger than niz[start]=3 (B) returns 3
In (C):
temp = 3 (result of (B))
start = 1
As 3 is bigger than niz[start]=2 (B) returns 2
In (D):
temp = 2 (result of (C))
start = 0
As 2 is bigger than niz[start]=1 (B) returns 1
Your recursive line is before your print statement block. By nature of recursion, it makes the function call on that recursive line and stops the caller function's execution until the callee is done. Therefore you call for the next element to be processed before you print the current element.
In your example the following is happening:
Layer 1:
Is start equal to end? No.
What is the result of the next element? Don't know yet, recurse.
Layer 2:
Is start equal to end? No.
What is the result of the next element? Don't know yet, recurse.
Layer 3:
Is start equal to end? No.
What is the result of the next element? Don't know yet, recurse.
Layer 4:
Is start equal to end? Yes!
Return the current element, 4.
End layer 4.
Layer 3:
Now know next element, start printing for the 3rd element.
Return 3.
End layer 3.
Layer 2:
Now know the next element, start printing for the 2nd element.
Return 2.
End layer 2.
Layer 1:
Now know the next element, start printing for the 1st element.
Return 1.
End layer 1.
End program.
As you can see, the array elements are printed backwards because the print statements are after the recursive call. I'd you want them to be printed in order, print them before the recursive call, or create a buffer and append each print section to the front of the buffer.
I don't understand recursive functions.
I wrote this code to help me but i don't understand why it works the way it does.
It prints backwards the steps from 0 to the number n/2 i input but don't know what makes it print every step it skipped from low to high because it went recursive. I am close but not yet there...
#include <iostream>
#include <conio.h>
using namespace std;
int recursiv(int );
int times;
int main(){
int x;
cout<<"Imput number\n";
cin>>x;
recursiv(x);
getch();
return 0;
}
int recursiv(int x){
times++;
if(x)
recursiv(x/2);
cout<<"We are now at "<<x/2<<endl;
if (!x)
cout<< "We reached "<<x<<" but it took "<<times-1<< " steps\n";
return 0;
}
When you are dealing with recursion you have to understand two main part of the function code: the one that is executed on the way forward, and the one that is executed on the way back:
void X() {
// way forward
X();
// way back
}
The way forward part is executed while calling the function over and over until the end of the recursion; the way back is executed while coming back from the last call to the first.
void print(int x) {
if (!x) return; // end of recursion
std::cout << x << " ";
print(x-1);
}
The above example contains std::cout << x on the way forward which means that the call print(5) will print: 5 4 3 2 1.
void print(int x) {
if (!x) return; // end of recursion
print(x-1);
std::cout << x << " ";
}
The above example moved the actual printing to the way back part of the function which means that the same call print(5) will print: 1 2 3 4 5.
Let's take your function (cleaned up a bit):
int recursiv(int x){
times++;
if(!x) return 0; // split
recursiv(x/2);
cout << "We are now at "<< x / 2 << endl;
return 0;
}
We can distinguish our two parts quite easily. The way forward is:
times++;
if(x) return;
In which we just increment our int parameter times (we just ignore the conditional for the end of recursion here).
The way back is:
cout<<"We are now at "<<x/2<<endl;
return 0;
Which will be executed from the last call to the first one (just like the second version of the example). Therefore taking from the lowest number (the one nearer to 0 because of the end recursion condition) which is the last called before the end of recursion to the first, just like our example.
If i understand your question correctly:
It should print from high to low, but it actually prints from low to high. why is that?
The line cout<<"We are now at "<<x/2<<endl; is after the call for recursion.
so the function calls itself with a smaller amount again and again until it hits the break criteria.
the the function with the smallest amount calls the std::cout, return the second smallest amount does the std::cout and so on until the last one does it.
If you want the result in the other order, move the mentioned line two lines higher, so each iteration echos before calling the child.
example:
int recursiv(int x, int times = 0) {
std::cout << "We are now at " << x/2 << std::endl;
if(x)
return recursiv(x/2, times + 1);
else
std::cout << "We reached " << x << " but it took " << times << " steps" << std::endl;
return 0;
}
Unrelated: Global variables are considered a bad practice. There are use cases for them, this is not one of them. I fixed that within the function.