两数相除
题目描述：
给定两个整数，被除数 dividend 和除数 divisor。将两数相除，要求不使用乘法、除法和 mod 运算符。
返回被除数 dividend 除以除数 divisor 得到的商。
整数除法的结果应当截去（truncate）其小数部分，例如：truncate(8.345) = 8 以及 truncate(-2.7335) = -2
思路：
我们要计算两个数相除的商，但是又不能使用乘除法和取模运算，那么就只能使用加法、减法或者位运算了。
我们知道，可以使用加法模拟乘法，使用减法模拟除法，位运算可以模拟乘2或者除2的运算；
在模拟之前我们还需要考虑几点特殊的问题：
- 整数限定的范围是32位，那么其取值范围就是 -2^31 — 2^31-1;
- 因为负数的范围比较大，当商为2^31时，会发生越界，所以我们可以通过同号为正，异号为负的方法确定结果的正负，然后将所有的正数转化为负数来求解。
- 正值运算还好说，遇到负值运算，如果被除数是-2^31 ，除数是-1，直接相除的话会产生越界的结果；所以要注意几个特殊值：
- 当divisor == INT_MIN时 ：
- 如果INT_MIN == dividend ，直接返回 1;
- 如果是其他值，直接返回0；
- 当dividend == 0时，不管divisor是多少，都直接返回0；
- 当dividend == INT_MIN时：
- 如果divisor == -1，直接返回INT_MAX;
- divisor == 1 ，我们可以直接返回INT_MIN;
- 除此之外，如果我们每次循环都只减一次divisor那么遇到特殊情况，时间复杂度将会非常高，例如dividend = 214836748，divisor = 3的情况，就需要减很多次。那么就需要采用一种方法去降低时间复杂度，我这里用的是倍增法：
- 每次增加一倍的方法去减，时间复杂度就变成了log dividend；
//这里的A和B都是负数，比较方法和正数正好相反
int helper(int a,int b)
{
//当被除数不够除时的操作
if(a >= b) return a > b ? 0 : 1;
int count = 1;//经过上面的判断，dividend至少可以减一次divisor
int tb = b;//当做减数
int res = 0; // 用来存储结果
while(a < tb)
{
//被除数每减一次除数，就要计数一次
a -= tb;
count += 1;
//使用倍增法降低时间复杂度
tb += tb;
count += count;
}
res = count;
return res + helper(a,b);
}算法是写完了，但是上面的算法在我验证的时候出了点儿错误，那就是当除数大于-2^31/2的时候，无疑出现这种情况，我们的结果就是1，但是算法没法直接得出判断，他还是会执行tb+=tb这一步，如果此时我们使用倍增法，那么就会产生overflow的错误。
如何解决呢？再写一个特例？不不不，我们的特例已经足够多了，我们只需要在执行tb += tb之前再来一次判断即可，因为要执行tb += tb 的目的是，为了降低时间复杂度，那么只需要判断a还能否再减tb,如果可以，在执行下面的条件，如果不行就跳出，如此即可完美解决问题；
//完整算法
class solution{
public:int divide(int dividend,int divisor)
{
if(dividend == 0) return 0;
if(dividend == INT_MIN)
{
if(divisor == -1) return INT_MAX;
if(divisor == 1)return INT_MIN;
}
if(divisor == INT_MIN)
{
if(dividend == INT_MIN) return 1;
else return 0;
}
int sign = -1;
if((dividend >0 &&divisor > 0) || (dividend <0 && divisor < 0))
{
sign = 1;
}
dividend = dividend > 0 ? -dividend : dividend;
divisor = divisor > 0 ? -divisor : divisor;
int ans = helper(dividend,divisor);
return sign > 0 ? ans : -ans;
}
int helper(int a , int b)
{
if(a >= b) return a > b ? 0 : 1;
int count = 1;
int res = 0;
int tb = b;
while(a < tb)
{
a -= tb;
count += 1;
if(a < tb)
{
tb += tb;
count += count;
}
}
res = count;
return res + helper(a,b);
}
}下面是官方给出的解法：
使用二分查找法：
思路：由于我们只能使用 3232 位整数，因此二分查找中会有很多细节。
首先，二分查找的下界为 11，上界为 2^31−1。唯一可能出现的答案为 2^31的情况已经被我们在「前言」部分进行了特殊处理，因此答案的最大值为 2^31−1。如果二分查找失败，那么答案一定为 0。
在实现「快速乘」时，我们需要使用加法运算，然而较大的 ZZ 也会导致加法运算溢出。例如我们要判断 A+B 是否小于 C 时（其中 A,B,C 均为负数），A+B 可能会产生溢出，因此我们必须将判断改为 A<C−B 是否成立。由于任意两个负数的差一定在 [−231,231−1][−231+1,231−1] 范围内，这样就不会产生溢出。
class Solution {
public:
int divide(int dividend, int divisor) {
// 考虑被除数为最小值的情况
if (dividend == INT_MIN)
{
if (divisor == 1) return INT_MIN;
if (divisor == -1) return INT_MAX;
}
// 考虑除数为最小值的情况
if (divisor == INT_MIN) return dividend == INT_MIN ? 1 : 0;
// 考虑被除数为 0 的情况
if (dividend == 0) {
return 0;
}
// 一般情况，使用二分查找
// 将所有的正数取相反数，这样就只需要考虑一种情况
bool rev = false;
if (dividend > 0)
{
dividend = -dividend;
rev = !rev;
}
if (divisor > 0)
{
divisor = -divisor;
rev = !rev;
}
// 快速乘
auto quickAdd = [](int y, int z, int x)
{
// x 和 y 是负数，z 是正数
// 需要判断 z * y >= x 是否成立
int result = 0, add = y;
while (z) {
if (z & 1) {
// 需要保证 result + add >= x
if (result < x - add) {
return false;
}
result += add;
}
if (z != 1) {
// 需要保证 add + add >= x
if (add < x - add) {
return false;
}
add += add;
}
// 不能使用除法
z >>= 1;
}
return true;
};
int left = 1, right = INT_MAX, ans = 0;
while (left <= right) {
// 注意溢出，并且不能使用除法
int mid = left + ((right - left) >> 1);
bool check = quickAdd(divisor, mid, dividend);
if (check) {
ans = mid;
// 注意溢出
if (mid == INT_MAX) {
break;
}
left = mid + 1;
}
else {
right = mid - 1;
}
}
return rev ? -ans : ans;
}
};
