【LeetCode】数值运算（除法、乘方）

C/C++数字范围（32位系统）

bool：  ~     // 1 字节
char    // 1 字节
short： - ~     // 2 字节
int： - ～     // 4 字节
unsigned：  ～     // 4 字节
size_t：  ~     // 4 字节
long： - ～     // 4 字节，Linux64位下的long占 8 字节！！！
unsigned long：  ～     // 4 字节
long long： - ～     // 8 字节
unsigned long long：  ～     // 8 字节
__int64： - ～     // 8 字节
unsigned __int64：  ～     // 8 字节
float： 1.17549- ~ 3.40282e+038    // 4 字节
double： 2.22507e-308 ~ 1.79769e+308    // 8 字节
long double： 3.3621e-4932 ~ 1.18973e+4932    // 12 字节

1. 整数除法

实现整数除法，不使用 * 、/ 、% 三个运算符。若结果越界，返回 INT_MAX。

原理：

假设计算 15 除以 3，15 是 dividend 被除数，3 是 divisor 除数。

“除法”需要知道 dividend 能够减去 divisor 多少次而不使 dividend 为负。

开始计算叭~将结果记录在 result 中（初始化为0）。

首先 15 - 3 = 12 > 0；尝试减去更大的数，把 3 左移一位 (0011)₂ -> (0110)₂ 得到 6，15 - 6 > 0；再左移一位得到 12，15 - 12 > 0；继续左移一位得到24，15 - 24 < 0。这样我们知道 dividend (15) 最多能减 12。12 是由 divisor (3) 左移 2 次得到，左移 2 次相等于 × 4，4 即为 (0001)₂ 左移 2 次得到，因此将 4 加到 result 中。

接下来 dividend 15 - 12 后剩余 3，重复上述计算，将 1 加到 result 中得到最终答案 5。

被除数和除数若含有负数，则统一化为正数按上述算法计算后，再判断 result 符号即可。

C++实现：

 int divide(int dividend, int divisor) {
     // 整数除法，因此只有当 dividend == -231，divisor == -1 时结果才会越界
     if (!divisor || (dividend == INT_MIN && divisor == -))
         return INT_MAX;
     /* ！使用 异或 操作符判断符号值得学习！ */
     int sign = ((dividend < ) ^ (divisor < )) ? - : ;
     // dividend == -231时，取绝对值后仍赋值给 int 则会越界，因此存储在 long long
     long long dvd = labs(dividend);
     long long dvs = labs(divisor);
     int res = ;
     while (dvd >= dvs) {
         long long temp = dvs, multiple = ;
         while (dvd >= (temp << )) {
             temp <<= ;
             multiple <<= ;
         }
         dvd -= temp;
         res += multiple;
     }
     return sign ==  ? res : -res;
 }

2. 乘方

实现 Pow(x, n)。

若用类似于求 n 的阶乘的递归方法计算，时间复杂度为 O(n)。

但考虑到 n 个 x 相乘式子的对称关系，可以采用二分法，xⁿ = x^n/2 * x^n/2 * x^n%2，时间复杂度为 O(logn)。

C++实现：

 double myPow(double x, int n) {
     if (!n)
         return ;
     if (n < ) {
         n = -n;
         x =  / x;
     }
     return (n %  == ) ? myPow(x * x, n / ) : x * myPow(x * x, n / );
 }

但这段代码并没有做边界条件判断，n 取值 INT_MIN 时，-n 并不是 INT_MAX

需要在 n < 0 的条件下增加判断

if (n == INT_MIN)
    return  / (x * myPow(x, INT_MAX));

或者改为

if (n < ) {
    return  / (x * myPow(x, -(n + )));
}

最后可以用位运算加快执行速度

 double myPow(double x, int n) {
     if (!n)
         return ;
     if (n < ) {
         return  / (x * myPow(x, ~n));
     }
     return ((n & ) == ) ? myPow(x * x, n >> ) : x * myPow(x * x, n >> );
 }

用 ~n 代替 -(n + 1)。

e.g. n = 15，求 ~n。

 n的源码 = 00000000  00000000  00000000  00001111

正数的补码是自身（计算机以补码存储数据）
 n的补码 = 00000000  00000000  00000000  00001111

按位取反（包括符号位）
~n的补码 = 11111111  11111111  11111111  11110000

负数的补码是源码取反加1，源码也是补码取反加1（符号位不变）
~n的源码 = 10000000  00000000  00000000  00010000

求得 ~n 为 -16。同理 n = -15 时，求得 ~n = 14。

if ((n & 1) == 0) 判断奇偶效率更高，虽然编译器都会将 n % 2 优化为位运算。

但值得注意的是，& 作为“按位与”而不是“取地址符”时，其优先级低于 == 和 !=，因此如果不写括号的话 (n & 1 == 0) 为永 false 的。

编写更加易读的代码比起过多考虑细枝末节的效率问题更加重要！若想高效，建议改进算法，而不是改进写法！

递归虽然很好理解，但会占用递归栈的空间，因此用迭代的方法更加高效。

考虑 n 的二进制表示，例如 n = (1000 1011)₂，那么xⁿ = x^1+2+8+128 = x¹ * x² * x⁸ * x¹²⁸。

因此可以循环 n 的每一位，如果该位置是 1，就把 xⁱ 乘到结果中去，时间复杂度为 O(logn)。

任何数与 1 相与结果不是 0 就是 1，一般用 n & 1 判断 n 的奇偶，这里则是不断把 n 右移一位，判断 n 的最后一位是不是 1，如果是 1，就把 xⁱ 乘到结果中去。

 double myPow(double x, int n) {
     if (!n)
         return ;
     if (n < ) {
         return  / (x * myPow(x, ~n));
     }
     double result = ;
     for(; n > ; x *= x, n >>= ) {
          if (n &  > )
             result *= x;
     }
     return result;
 }

3.