如果你做了一个二进制斩试图找到“正确”的平方根，你可以很容易地检测到你得到的值是否足够接近：

(n+1)^2 = n^2 + 2n + 1
(n-1)^2 = n^2 - 2n + 1

因此，在计算了n^2之后，选项如下：

n ^2=目标：已完成，返回truen^2+2n+1>target>n^2:你很接近，但并不完美：return falsen^2-2n+1<目标<n^2：同上目标<n^2-2n+1：低位n上的二进制斩波目标>n^2+2n+1：较高n上的二进制斩波

（抱歉，这使用n作为您当前的猜测，并将其作为参数的目标。对此感到困惑深表歉意！）

我不知道这是否会更快，但值得一试。

编辑：二进制斩不必接受整个整数范围，或者（2^x）^2=2^（2x），所以一旦你在目标中找到了最高位（这可以用一个小技巧来完成；我完全忘记了怎么做），你就可以快速得到一系列可能的答案。请注意，一个简单的二进制斩仍然只需要31或32次迭代。

使用牛顿的方法计算整数平方根，然后对这个数字进行平方并进行检查，这应该快得多，就像您在当前解决方案中所做的那样。牛顿方法是其他答案中提到的卡马克解的基础。你应该能够得到更快的答案，因为你只对根的整数部分感兴趣，这样你就可以更快地停止近似算法。

另一个可以尝试的优化：如果数字的数字根不以1、4、7或9这个数字不是一个完美的正方形。这可以作为在应用较慢的平方根算法之前消除60%输入的快速方法。

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

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);
    }
}

当观察到正方形的最后n位时，我检查了所有可能的结果。通过连续检查更多位，可以消除多达5/6的输入。我实际上是为了实现费马的因子分解算法而设计的，而且速度非常快。

public static boolean isSquare(final long val) {
   if ((val & 2) == 2 || (val & 7) == 5) {
     return false;
   }
   if ((val & 11) == 8 || (val & 31) == 20) {
     return false;
   }

   if ((val & 47) == 32 || (val & 127) == 80) {
     return false;
   }

   if ((val & 191) == 128 || (val & 511) == 320) {
     return false;
   }

   // if((val & a == b) || (val & c == d){
   //   return false;
   // }

   if (!modSq[(int) (val % modSq.length)]) {
        return false;
   }

   final long root = (long) Math.sqrt(val);
   return root * root == val;
}

伪代码的最后一位可用于扩展测试以消除更多值。上述测试针对k=0、1、2、3

a的形式为（3<<2k）-1b的形式为（2<<2k）c的形式为（2<<2k+2）-1d的形式为（2<<2k-1）*10

它首先测试它是否具有幂模为2的平方残差，然后根据最终模量进行测试，然后使用Math.sqrt进行最终测试。我从最上面的帖子中提出了这个想法，并试图扩展它。我感谢任何评论或建议。

更新：使用模数（modSq）和44352的模数基数的测试，我的测试在OP更新中的96%的时间内运行，最多可达1000000000。

用牛顿法计算平方根的速度快得惊人。。。只要起始值是合理的。然而，没有合理的起始值，在实践中，我们以平分和对数（2^64）行为结束。要真正做到快速，我们需要一种快速的方法来获得一个合理的初始值，这意味着我们需要进入机器语言。如果一个处理器在奔腾中提供了一个像POPCNT这样的指令，它对前导零进行计数，我们可以使用它来获得一个具有一半有效位的起始值。小心地，我们可以找到一个固定数量的牛顿步数，这将总是足够的。（因此，前面提到了需要循环并具有非常快的执行。）

第二种解决方案是通过浮点设备，它可能具有快速的sqrt计算（如i87协处理器）。即使通过exp（）和log（）进行偏移，也可能比牛顿退化为二进制搜索更快。这有一个棘手的方面，即依赖于处理器的分析，以确定后续是否需要改进。

第三种解决方案解决了一个稍有不同的问题，但很值得一提，因为问题中描述了情况。如果你想为稍有不同的数字计算很多平方根，你可以使用牛顿迭代，如果你从来没有重新初始化起始值，但只需将其保留在之前的计算停止的地方。我已经在至少一个欧拉问题中成功地使用了这一方法。

我喜欢对一些输入使用几乎正确的方法。这是一个“偏移”更高的版本。代码似乎有效，并通过了我的简单测试用例。

只需替换您的：

if(n < 410881L){...}

使用此代码：

if (n < 11043908100L) {
    //John Carmack hack, converted to Java.
    // See: http://www.codemaestro.com/reviews/9
    int i;
    float x2, y;

    x2 = n * 0.5F;
    y = n;
    i = Float.floatToRawIntBits(y);
    //using the magic number from 
    //http://www.lomont.org/Math/Papers/2003/InvSqrt.pdf
    //since it more accurate
    i = 0x5f375a86 - (i >> 1);
    y = Float.intBitsToFloat(i);
    y = y * (1.5F - (x2 * y * y));
    y = y * (1.5F - (x2 * y * y)); //Newton iteration, more accurate

    sqrt = Math.round(1.0F / y);
} else {
    //Carmack hack gives incorrect answer for n >= 11043908100.
    sqrt = (long) Math.sqrt(n);
}