2.1 二进制中1的个数

1. 前言

本文的一些图片, 资料 截取自编程之美

2. 问题描述

3. 问题分析

这个问题就是给定一个8个0/ 1, 然后求解其中1的个数

书上给出了五种思路
第一种 : 将这个数模上2, 如果结果为1, 则说明最后一位为1, counter++, 然后再将这个数除以2, 直到这个数为0, counter即为所求
第二种 : 利用位操作优化上面的算法, 思路基本一致, 优化了求模 和除法
第三种 : 通过((input) & (input - 1) )去掉最后一个零, 迭代操作, 直到这个数为0
第四种 : 利用分支操作, switch, 因为八个位 数量有限, 也就是256种选择, 依次switch出来[这里是为了导出第五种算法]
第五种 : 利用hashtable 记录0-255, 的1的位数, 然后需要的时候, 查表即可 o(1)

4. 代码

/**
 * file name : Test06GetAll1OfByte.java
 * created at : 9:59:29 AM May 19, 2015
 * created by 970655147
 */

package com.hx.test03;

public class Test06NumberOf1InOneByte {

    // 统计一个字节中1的个数
    public static void main(String []args) {

//      byte b = 12;
//      false false false false true true false false

//      byte b = 86;
//      false true false true false true true false 

        Integer i;

        byte b = 86;
        getNumOf1InByte01(b);
        getNumOf1InByte02(b);
        getNumOf1InByte03(b);
        getNumOf1InByte04(b);

    }

    // 通过 "%2是否为1" 判定该位是否是1
    public static void getNumOf1InByte01(byte b) {
        boolean[] data = new boolean[8];
        byte MASK = 0x00000001;
        for(int i=0; i<8; i++) {
            data[7-i] = (b % 2 == 1);
            b /= 2;
        }

        Log.log(data);
    }

    // 移位操作    无符号右移 防止b为负数  造成死循环
    public static void getNumOf1InByte02(byte b) {
        byte tmp = b;
        boolean[] data = new boolean[8];
        byte MASK = 0x00000001;
        for(int i=0; i<8; i++) {
            data[7-i] = ((tmp & MASK) == 1);
            tmp >>>= 1;
        }

        Log.log(data);
    }

    // 移位MASK  来代替移位b
    public static void getNumOf1InByte03(byte b) {
        boolean[] data = new boolean[8];
        byte MASK = 0x00000001;
        for(int i=0; i<8; i++) {
            data[7-i] = ((b & MASK) != 0);
            MASK <<= 1;
        }

        Log.log(data);
    }

    // 通过b & (b-1) b的最低1位之后的数据必然均为0 实现
    public static void getNumOf1InByte04(byte b) {
        byte tmp = b;
        int num = 0;
        do{
            tmp &= tmp-1;
            num ++;
        } while(tmp > 0);

        Log.log(num);
    }

//  ... 太怂  是为了引出第六种解法
    public static void getNumOf1InByte05(byte b) {
        int num = 0;
        switch(b) {
            case 0:
                num = 0;
                break;
            case 1:
                num = 1;
                break;
            case 2:
                num = 1;
                break;
//          ....  省略若干
            case 126:
                num = 6;
                break;
            case 127:
                num = 7;
                break;
        }
        Log.log(num);
    }

    static int[] countTable = {
        0, 1, 1, 2, 1, // ...省略若干
        // ... 省略若干
        7, 6, 7, 7, 8
    };
    // 第六种解法, 空间换时间
    public static void getNumOf1InByte06(byte b) {
        Log.log(countTable[b]);
    }

}

5. 运行结果

6. 总结

对于第一种思路, 很容易想到, 通常人想到的第一种方法应该就是这种
第二种 则需要有相关的专业知识了, 比如 << 1 替换 /2, & 1 替换 %2, 这些对于计算机相关专业的同学来说，应该作为常识记住
第三种 则更为巧妙,每次 将最后一位1变成0
第四种 咳咳，就不说了，范围小点还有一定的可行性
第五种 典型的空间换时间, 但是有时候是非常有用的, 比如 另一种典型的空间换时间, hashtable 排序[一定范围内]

注 : 因为作者的水平有限，必然可能出现一些bug, 所以请大家指出！