Sqrt(x) x 的平方根

实现 int sqrt(int x) 函数。

计算并返回 x 的平方根，其中 x 是非负整数。

由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。

示例 1:

输入: 4
输出: 2

示例 2:

输入: 8
输出: 2
说明: 8 的平方根是 2.82842..., 
     由于返回类型是整数，小数部分将被舍去。

思路：

采用二分查找的思想，每次把划分区间分为3部分[0,mid)，mid，(mid,end]，从而不断缩小空间，这里和传统的二分查找不太一样，如果按照如下所写的代码会出现下图的情况：

在循环过程中会出现下次循环的范围不包含正确答案的情况，虽然最后能返回正确答案，但是这种二分迭代的情况不利于我们思考，对于这种特殊的情况我们记住程序就好了。如下图所示：如果输入15，正确答案返回3，其中某一次循环中出现的情况：

第一次：start=0，mid=7，end=15

第二次：start=0，mid=3，end=6

以第二次为例，这是情况如下：

由于3^3=9<15，所以第三次会在[4,6]中寻找答案，继续

第三次：start=4，mid=5，end=6

第四次：start=4，mid=4，end=4

第四次还是不满足条件，这是end=mid-1=3，刚好是正确答案。。。

所以这种解法比较巧，记住就好了。

代码如下：

    int mySqrt(int x) {
	if (x <= 1) {
		return x;
	}
	int start = 0;
	int end = x/2+1;
	while (start <= end) {
		long long mid = (start + end) / 2;
		long long sq = mid * mid;
		if (sq == x) {
			return mid;
		}
		if (sq > x) {
			end = mid - 1;
		}
		else {
			start = mid + 1;
		}
		
	}
	return end;
    }

方法2：

第二种是用递归做，由于为了避免上述方法一出现的情况，所以递归的边界条件变多（为了保证每次递归的范围一定包含解），边界分为以下几种情况：

1：如果start*start==target，则返回start

2：如果start*start>target，则返回start-1（换句话说范围内最小值的平方都比目标值大，则答案一定是start-1）

3：如果end*end==target，则返回end

4：如果end*end<target，则返回end（换句话说如果范围内最大值的平方都比目标值小，则答案一定就是最大值）

5：接下来才对mid分常规的3中分类：如果mid*mid==target，返回mid

6：如果mid*mid>target，则end=mid-1

7：如果mid*mid<target，则start=mid+1

这里强调一点，上述所说递归范围内一定包含解有点不妥，应该是递归+-1范围内一定包含解，这种思考过程清晰明了。

代码如下：

int mySqrtCore(int x, int start, int end) {
	if ((x / start) < start) {
		return start - 1;
	}
	if ((x / start) == start) {
		return start;
	}
	if ((x / end) >=end ) {
		return end;
	}
	int mid = (start + end) / 2;
	if ((x / mid) == mid) {
		return mid;
	}
	if ((x / mid) > mid) {
		return mySqrtCore(x, mid + 1, end);
	}
	else {
		return mySqrtCore(x, start, mid - 1);
	}
}
int mySqrt(int x) {
	if (x <= 1) {
		return x;
	}
	return mySqrtCore(x, 1, x/2+1);
}