C language, using recursive rewriting of the power function so that it can calculate negative expone

include recursively overrides the power() function so that it can output negative exponents.

double power(double n,int p)double pow,s;

if(n==0&&p ||n==1)

return n;

else if(p>0) {

pow=n*power(n,p-1);

return pow;

else if(p<0) {

s=power(n,-p);There is an error in this place!!

return 1/s;

else return 1;

int main (void)

double x;

int n;

scanf("%lf%d",&x,&n);

power(x,n);

printf("%.3lf to the power %d is %.5lf",x,n,power(x,n));

return 0;

The landlord should also note that the power of 0 is 1

else y=1/x*power(x,n+1);The order of operation is (1 x)*power(x,n+1); x is a negative number, 1 x is meaningless, and it will naturally collapse In addition, the content in double quotation marks of scanf does not need to be commas.

int ex(int a)

This paragraph only sets the condition that a is not equal to 1, that is, the function is nested, but does not take into account the case when a=1, that is, when a=1, it should return 1.

Replace it with something like this: int ex(int a).

elsereturn 1;}

include Take a look at your environment and what header files are needed.

int ex(int a)

int main()

b is not assigned an initial value, and the recursive constraints are not perfect. Therefore: 1. When a>1, b in the function ex() is assigned as ex(a-1)*a, and the result is correct; 2. When a=1, b is not assigned, and b outputs a random value; 3. When a<1, since b=ex(a-1)*a, and the end condition is a==1, it will be infinitely recursive and become an endless loop.

In addition, the function declaration should be outside the function body.

fourth line: int ex(int a); Why?

Function declarations? It should be written outside of the main function.

This can also be calculated to the power.

#include

main()

As for your program, you put the penultimate line **.

pow=n*power_negative(n,q-1);

change to pow=n*power positive(n,q-1); Try it.

Someone has already corrected it for you, so I'll point out your mistake in **.

if(q>0)

pow=n*power_negative(n,q-1);

re=1/pow;

On the face of it, it's true, however, according to re=1 pow. Then the previous ones should all be positive to the power. For example, a (-3) first loop p1=a*p(a,-2), second loop, p2=a*(a,-1), and a third cycle, while recursion has at least one specific value when a certain value is specific and cannot be called all the time.

Regardless of the specific value for the time being, the last time we re=1 pow, what is the previous pow??? The logic is confused... You should think about it.

This program is really redundant to implement with recursion, of course, you are training recursion, it is recommended that you use recursion to practice.

Brother: This is because the final return value is not the number you want to return at all, for example, if you change return a to return, the result is still the original result.

In recursive terms, only the function that runs for the first time can return the value returned for the final result, and the return value of other functions cannot be the most effective function, such as your function.

Probably the process is like this.

f( ) I'll change yours a little bit and yours will work.

#include

#include

float f(int i, float a)else }

int main()

You didn't declare the function name once.

As a reminder, there is no jump out of the delivery statement, so the cycle continues.

In the case of n as an integer, when n is greater than 1, the value of (1 (n-1))+1 n) must be 0, and when 0 is passed into the function, an error like 1 0 will occur.

The recursion function, if it is wrong if you don't add return in it, recursion is calculated to the lowest level, and then return with return, layer by layer to return the result!!