不确定这是否是最快的方法，但这是我（很久以前在高中）在数学课上无聊地玩计算器时偶然发现的。当时，我真的很惊讶这是有效的。。。

public static boolean isIntRoot(int number) {
    return isIntRootHelper(number, 1);
}

private static boolean isIntRootHelper(int number, int index) {
    if (number == index) {
        return true;
    }
    if (number < index) {
        return false;
    }
    else {
        return isIntRootHelper(number - 2 * index, index + 1);
    }
}

你必须做一些基准测试。最佳算法将取决于输入的分布。

您的算法可能接近最佳，但在调用平方根例程之前，您可能需要快速检查以排除某些可能性。例如，通过按位“和”查看十六进制数字的最后一位。完美的正方形只能以0、1、4或9结尾，以16为底。因此，对于75%的输入（假设它们是均匀分布的），可以避免调用平方根，以换取一些非常快的位旋转。

Kip对实现十六进制技巧的以下代码进行了基准测试。当测试数字1到100000000时，此代码的运行速度是原始代码的两倍。

public final static boolean isPerfectSquare(long n)
{
    if (n < 0)
        return false;

    switch((int)(n & 0xF))
    {
    case 0: case 1: case 4: case 9:
        long tst = (long)Math.sqrt(n);
        return tst*tst == n;

    default:
        return false;
    }
}

当我在C++中测试类似的代码时，它实际上比原始代码运行得慢。然而，当我消除switch语句时，十六进制技巧再次使代码速度提高了一倍。

int isPerfectSquare(int n)
{
    int h = n & 0xF;  // h is the last hex "digit"
    if (h > 9)
        return 0;
    // Use lazy evaluation to jump out of the if statement as soon as possible
    if (h != 2 && h != 3 && h != 5 && h != 6 && h != 7 && h != 8)
    {
        int t = (int) floor( sqrt((double) n) + 0.5 );
        return t*t == n;
    }
    return 0;
}

消除switch语句对C#代码几乎没有影响。

这是我能想到的最快的Java实现，使用了本线程中其他人建议的技术组合。

Mod-256测试不精确的mod-3465测试（避免以某些误报为代价的整数除法）浮点平方根，舍入并与输入值比较

我也尝试了这些修改，但它们对性能没有帮助：

附加mod-255测试将输入值除以4的幂快速逆平方根（要处理高N值，需要3次迭代，足以使其比硬件平方根函数慢。）

public class SquareTester {

    public static boolean isPerfectSquare(long n) {
        if (n < 0) {
            return false;
        } else {
            switch ((byte) n) {
            case -128: case -127: case -124: case -119: case -112:
            case -111: case -103: case  -95: case  -92: case  -87:
            case  -79: case  -71: case  -64: case  -63: case  -60:
            case  -55: case  -47: case  -39: case  -31: case  -28:
            case  -23: case  -15: case   -7: case    0: case    1:
            case    4: case    9: case   16: case   17: case   25:
            case   33: case   36: case   41: case   49: case   57:
            case   64: case   65: case   68: case   73: case   81:
            case   89: case   97: case  100: case  105: case  113:
            case  121:
                long i = (n * INV3465) >>> 52;
                if (! good3465[(int) i]) {
                    return false;
                } else {
                    long r = round(Math.sqrt(n));
                    return r*r == n; 
                }
            default:
                return false;
            }
        }
    }

    private static int round(double x) {
        return (int) Double.doubleToRawLongBits(x + (double) (1L << 52));
    }

    /** 3465<sup>-1</sup> modulo 2<sup>64</sup> */
    private static final long INV3465 = 0x8ffed161732e78b9L;

    private static final boolean[] good3465 =
        new boolean[0x1000];

    static {
        for (int r = 0; r < 3465; ++ r) {
            int i = (int) ((r * r * INV3465) >>> 52);
            good3465[i] = good3465[i+1] = true;
        }
    }

}

我希望此功能与所有正64位有符号整数

Math.sqrt（）使用double作为输入参数，因此对于大于2^53的整数，不会得到准确的结果。

static boolean isPerfectSquare (int input) {
  return Math.sqrt(input) == (int) Math.sqrt(input);
}

如果输入的平方根的整数值等于双倍值，则返回该值。这意味着它是一个整数，它将返回true。否则，将返回false。

标签中提到了项目Euler，其中的许多问题需要检查数字>>2^64。当您使用80字节缓冲区时，上面提到的大多数优化都不容易工作。

我使用了javaBigInteger和稍微修改过的Newton方法，它对整数更有效。问题是，精确的平方n^2收敛到（n-1）而不是n，因为n^2-1=（n-1）（n+1），最终误差仅比最终除数低一步，算法终止。在计算错误之前，通过在原始参数中添加一个参数很容易解决。（为立方体根等添加两个）

这个算法的一个优点是，你可以立即判断出这个数字是否是一个完美的平方-牛顿方法中的最终误差（不是校正）将为零。一个简单的修改也可以让您快速计算floor（sqrt（x）），而不是最接近的整数。这对于几个Euler问题很方便。