001. 整数除法
给定两个整数 a 和 b ,求它们的除法的商 a/b ,要求不得使用乘号 '*'、除号 '/' 以及求余符号 '%' 。
注意:
整数除法的结果应当截去(truncate)其小数部分,例如:truncate(8.345) = 8 以及 truncate(-2.7335) = -2
假设我们的环境只能存储 32 位有符号整数,其数值范围是 [−,
−1]。本题中,如果除法结果溢出,则返回
− 1
示例 1:
输入:a = 15, b = 2
输出:7
解释:15/2 = truncate(7.5) = 7
示例 2:输入:a = 7, b = -3
输出:-2
解释:7/-3 = truncate(-2.33333..) = -2
示例 3:输入:a = 0, b = 1
输出:0
示例 4:输入:a = 1, b = 1
输出:1
提示:
- -
<= a, b <=
- 1
- b != 0
我最开始写的不成熟代码(就想着用减法代替除法)
class Solution {
public int divide(int a, int b) {
int i=0;
if(a==-2147483648&&b==-1)return 2147483647;
if(a>=0&&b>0)
{
while((a-=b)>=0){
i++;
}
}else if(a<0&&b>0){
a=-a;
while((a-=b)>=0){
i--;
}
}else if(a>=0&&b<0){
b=-b;
while((a-=b)>=0){
i--;
}
}else if(a<0&&b<0){
a=-a;
b=-b;
while((a-=b)>=0){
i++;
}
}
return i;
}
}
可发现编译总是超时,简单的优化也无济于事,即使运行成功也是勉强通过。
下面是别人的代码,值得学习借鉴。(但是也超时了)
一.
class Solution {
public int divide(int a, int b) {
// 32 位最大值:2^31 - 1 = 2147483647
// 32 位最小值:-2^31 = -2147483648
// -2147483648 / (-1) = 2147483648 > 2147483647 越界了
if (a == Integer.MIN_VALUE && b == -1)
return Integer.MAX_VALUE;
int sign = (a > 0) ^ (b > 0) ? -1 : 1;
// 环境只支持存储 32 位整数
if (a > 0) a = -a;
if (b > 0) b = -b;
int res = 0;
while (a <= b) {
a -= b;
res++;
}
// bug 修复:因为不能使用乘号,所以将乘号换成三目运算符
return sign == 1 ? res : -res;
}
}
- 时间复杂度:O(n)
- 空间复杂度:O(1)
会超时的原因:
当被除数很大而除数很小的情况下,while会循环很多次。会很慢!!!!
二.尝试去减掉除数的倍数
// 时间复杂度:O(logn * logn),n 是最大值 2147483647 --> 10^10
public int divide(int a, int b) {
if (a == Integer.MIN_VALUE && b == -1)
return Integer.MAX_VALUE;
int sign = (a > 0) ^ (b > 0) ? -1 : 1;
if (a > 0) a = -a;
if (b > 0) b = -b;
int res = 0;
while (a <= b) {
int value = b;
int k = 1;
// 0xc0000000 是十进制 -2^30 的十六进制的表示
// 判断 value >= 0xc0000000 的原因:保证 value + value 不会溢出
// 可以这样判断的原因是:0xc0000000 是最小值 -2^31 的一半,
// 而 a 的值不可能比 -2^31 还要小,所以 value 不可能比 0xc0000000 小
// -2^31 / 2 = -2^30
while (value >= 0xc0000000 && a <= value + value) {
value += value;
k += k;
}
a -= value;
res += k;
}
// bug 修复:因为不能使用乘号,所以将乘号换成三目运算符
return sign == 1 ? res : -res;
}
- 时间复杂度:O(logn * logn) ,使用 python 和 javascript 会超时,看下面的优化
- 空间复杂度:O(1)
这个理解也简单:
就是成倍数去减,减到不能减就换个除数重新开始减,再累加倍数。
值得学习的点:
- 用sign来判断最后的结果是正还是负
- 灵活使用三目运算符
- 要尽可能的去减少运算量
改变方法------位运算
class Solution {
public int divide(int a, int b) {
if (a == Integer.MIN_VALUE && b == -1)
return Integer.MAX_VALUE;
int sign = (a > 0) ^ (b > 0) ? -1 : 1;
a = Math.abs(a);
b = Math.abs(b);
int res = 0;
for (int i = 31; i >= 0; i--) {
// 首先,右移的话,再怎么着也不会越界
// 其次,无符号右移的目的是:将 -2147483648 看成 2147483648
// 注意,这里不能是 (a >>> i) >= b 而应该是 (a >>> i) - b >= 0
// 这个也是为了避免 b = -2147483648,如果 b = -2147483648
// 那么 (a >>> i) >= b 永远为 true,但是 (a >>> i) - b >= 0 为 false
if ((a >>> i) - b >= 0) { // a >= (b << i)
a -= (b << i);
res += (1 << i);
}
}
// bug 修复:因为不能使用乘号,所以将乘号换成三目运算符
return sign == 1 ? res : -res;
}
}
- 时间复杂度:O(1)
- 空间复杂度:O(1)