solution 1: binary search
time complexity $O(log^n)$
```Java
  float mSqrt(int x, double epsilon) {
    if (x < 0) return -1;
    if (x == 0 || x == 1) return x;

    float left = 0, right = x;
    while (left <= right) {
      float mid = left + (right - left) / 2;
      if (Math.abs(mid - x / mid) < epsilon) return mid;
      if (mid < x / mid) left = mid;
      if (mid > x / mid) right = mid;
    }

    return Float.NEGATIVE_INFINITY;
  }
```

solution 2: Isaac newton iterative method
time complexity $O(log^n * F(n))$
http://en.citizendium.org/wiki/Newton%27s_method#Computational_complexity
```Java
  float sqrtNewton(int x, double epsilon) {
    if (x < 0) return Float.NaN;
    if (x == 0 || x == 1) return x;

    float iterativeResult = x;
    while (Math.abs(iterativeResult - x / iterativeResult) > epsilon / iterativeResult) {
      iterativeResult = (x / iterativeResult + iterativeResult) / 2;
    }
    return iterativeResult;
  }
```

js实现
var mySqrt = function (x) {
    
    if (x === 0 || x === 1) return x
    
    let left = 1
    let right = x - 1
    let m
    let target
    let res
    
    while (left <= right) {
        m = Math.floor((left + right) / 2)
        target = Math.floor(x / m)
        if (target === m) {
            return m
        }
        if (target < m) {
            right = m - 1
        }
        if (target > m) {
            left = m + 1
            res = m
        }
    }
    
    return Math.floor(res)
}