Question

Had a question on how to reduce the amount of recursive calls on a self implementation of the pow method. Here is what I wrote, can this be improved?

public static int pow(double a, int b) {
    boolean isNegative = false;

    if(b < 0) {
        isNegative = true;
    }

    if(b == 0) {
        return 1;
    } 
    else if(b == 1) {
        return (isNegative ? (1 / b) : b);
    }

    return (isNegative ? ((1 / b) * (1 / b) * pow(a, b + 2)) : (b * b * pow(a, b - 2)));
}

Answer 1

Yes, it can be improved.

Think about it this way:

• If b is even, then a^b = a^(b/2) * a^(b/2).
• If b is odd, then a^b = a^(b/2) * a^(b/2) * a (where / means integer division).

Code (brain-compiled, coffee hasn’t kicked in yet, etc.):

public static double pow(double a, int b) {
    if (b < 0)
        return 1 / pow(a, -b);
    if (b == 0)
        return 1;
    double halfPow = pow(a, b/2);
    if (b % 2 == 0)
        return halfPow * halfPow;
    else
        return halfPow * halfPow * a;
}

This gives you O(log b) recursive calls, as opposed to O(n) in your solution.