别人家的面试题：统计“1”的个数

小胡子哥@Barret李靖给我推荐了一个写算法刷题的地方leetcode.com，没有ACM那么难，但题目颇有趣。并且听说这些题目都来源于一些公司的面试题。好吧，解解别人公司的面试题其实很好玩，既能整理思路锻炼能力，又不用担忧漏题 ╮(╯▽╰)╭。

长话短说，让咱们来看一道题：

统计“1”的个数

给定一个非负整数num，对于任意i，0 ≤ i ≤ num，计算i的值对应的二进制数中“1” 的个数，将这些结果返回为一个数组。

例如：

当num = 5时，返回值为[0,1,1,2,1,2]。

/** 
  * @param {number} num 
  * @return {number[]} 
  * /
var countBits = function(num) {
    //在此处实现代码
};

解题思路

这道题咋一看还挺简单的，无非是：

• 实现一个方法countBit，对任意非负整数n，计算它的二进制数中“1”的个数

• 循环i从0到num，求countBit(i)，将值放在数组中返回。

JavaScript中，计算countBit能够取巧：

function countBit(n){
    return n.toString(2).replace(/0/g,"").length;
}

上面的代码里，咱们直接对n用toString(2)转成二进制表示的字符串，而后去掉其中的0，剩下的就是“1”的个数。

而后，咱们写一下完整的程序：

function countBit(n){
    return n.toString(2).replace(/0/g,'').length;
}
function countBits(nums){
    var ret = [];   
    for(var i = 0; i <= nums; i++){
        ret.push(countBit(i));
    }
    return ret;
}

上面这种写法十分讨巧，好处是countBit利用JavaScript语言特性实现得十分简洁，坏处是若是未来要将它改写成其余语言的版本，就有可能懵B了，它不是很通用，并且它的性能还取决于Number.prototype.toString(2)和String.prototype.replace的实现。

因此为了追求更好的写法，咱们有必要考虑一下countBit的通用实现法。

咱们说，求一个整数的二进制表示中“1”的个数，最普通的固然是一个O(logN) 的方法：

function countBit(n){
    var ret = 0;
    while(n > 0){
        ret += n & 1;
        n >>= 1;
    }
    return ret;
}

这么实现也很简洁不是吗？可是这么实现是否最优？建议此处思考10秒钟再往下看。

---

更快的countBit

上一个版本的countBit的时间复杂度已是O(logN) 了，难道还能够更快吗？固然是能够的，咱们不须要去判断每一位是否是“1”，也能知道n的二进制中有几个“1”。

有一个诀窍，是基于如下一个定律：

• 对于任意 n， n ≥ 1，有以下等式成立：

countBit(n & (n - 1)) === countBit(n) - 1

这个很容易理解，你们只要想一下，对于任意n，n – 1的二进制数表示正好是n的二进制数的最末一个“1”退位，所以n & n – 1正好将n的最末一位“1”消去，例如：

• 6的二进制数是110， 5 = 6 – 1的二进制数是101，6 & 5的二进制数是110 & 101 == 100

• 88的二进制数是1011000，87 = 88 – 1的二进制数是 1010111，88 & 87的二进制数是1011000 & 1010111 == 1010000

因而，咱们有了一个更快的算法：

function countBit(n){
    var ret = 0;
    while(n > 0){
        ret++;
        n &= n - 1;
    }
    return ret;
}
function countBits(nums){
    var ret = [];
    for(var i = 0; i <= nums; i++){
        ret.push(countBit(i));
    }
    return ret;
}

上面的countBit(88)只循环3次，而上一版本的countBit(88)却须要循环7次。

优化到了这个程度，是否是一切都结束了呢？从算法上来讲彷佛已是极致了？真的吗？再给你们 30 秒时间思考一下，而后再往下看。

---

countBits的时间复杂度

考虑countBits， 上面的算法：

• 最第一版本的时间复杂度是O(N*M)，M取决于Number.prototype.toString和String.prototype.replace的复杂度。

• 第二版本的时间复杂度是O(N*logN)

• 最后版本的时间复杂度是O(N*M)，M是N的二进制数中的“1”的个数，介于1 ~ logN之间。

上面三个版本的countBits的时间复杂度都大于O(N)。那么有没有时间复杂度O(N)的算法呢？

实际上，最后版本已经为咱们提示了答案，答案就在上面的那个定律里，我把那个等式再写一遍：

countBit(n & (n - 1)) === countBit(n) - 1

也就是说，若是咱们知道了countBit(n & (n - 1))，那么咱们也就知道了countBit(n)！

而咱们知道countBit(0)的值是 0，因而，咱们能够很简单的递推：

function countBits(nums){
    var ret = [0];
    for(var i = 1; i <= nums; i++){
        ret.push(ret[i & i - 1] + 1);
    }
    return ret;
}

原来就这么简单，你想到了吗 ╮(╯▽╰)╭

以上就是全部的内容，简单的题目思考起来颇有意思吧？程序员就应该追求完美的算法，不是吗？

转载整理自：http://web.jobbole.com