double foo(int arr[], double *ave, int index){
double *s;
*s=*ave;
// calculation//
return(foo (arr,ave,index));
// other calculation//
}I did not understand what you say. the function will call itself about 560 timesanorlunda said:Hint: How many levels deep will the recursive calls go in your code?
anorlunda said:Hint: How many levels deep will the recursive calls go in your code?
Based on what you posted, the function will run until there is no more stack memory for it.anonim said:I did not understand what you say. the function will call itself about 560 times
Right, and @anorlunda's hint might have something to do with why you're getting this fault.anonym said:C:double foo(int arr[], double *ave, int index){ double *s; *s=*ave; // calculation// return(foo (arr,ave,index)); // other calculation// }
I want to keep the ave value during the recursion, because after ave is calculated, I will do another calculation is recursively in this function. But I write like this, I am getting segmentation fault.
anonim said:Homework Statement:: Calculate the Math Formula
Relevant Equations:: -
C:double foo(int arr[], double *ave, int index){ double *s; *s=*ave; // calculation// return(foo (arr,ave,index)); // other calculation// }
I want to keep the ave value during the recursion, because after ave is calculated, I will do another calculation is recursively in this function. But I write like this, I am getting segmentation fault.
Why is s a pointer here?C:double *s; *s=*ave;
Recursion is a programming technique where a function calls itself repeatedly until a certain condition is met. It is a way to solve complex problems by breaking them down into smaller, simpler versions of the same problem.
When a recursive function is called, it first checks if the stopping condition is met. If not, the function calls itself again with a modified input. This process continues until the stopping condition is reached, and then the function starts returning values from the innermost call back to the initial call.
A double recursion function is a recursive function that calls itself twice within its body. This means that the function will have two recursive calls, which can lead to a more complex and efficient solution to certain problems.
Recursion allows for more elegant and concise code, as it can solve complex problems with fewer lines of code compared to iterative solutions. It also helps in breaking down complex problems into smaller, more manageable parts, making it easier to understand and debug.
One common pitfall is the risk of infinite recursion, where the stopping condition is not properly defined or not met, causing the function to call itself infinitely. This can lead to a stack overflow error. Additionally, recursive solutions may not always be the most efficient, and they can be harder to debug compared to iterative solutions.