Java中二进制算法的算法

时间:2010-03-09 21:15:22

标签: java algorithm string binary math

在纸面上,二进制算法很简单,但作为一个初级程序员,我发现有点难以提出二进制数的加法,减法,乘法和除法算法。

我有两个二进制数存储为字符串,假设已删除任何前导零。我将如何对这两个数字执行这些操作?

编辑:我需要避免将它们转换为int或long。

6 个答案:

答案 0 :(得分:11)

二进制字符串到int:

int i = Integer.parseInt("10101011", 2);
int j = Integer.parseInt("00010", 2);

然后你可以用两个整数做任何事情,例如:

i = i + j;
i = i - j;

让他们回到二进制字符串:

String s = Integer.toBinaryString(i);

答案 1 :(得分:5)

来自维基百科的算法:

<强>增加:

  

最简单的算术运算   二进制是补充。加两个   单位二进制数是   比较简单,使用一种形式   携带:

0 + 0 → 0
0 + 1 → 1
1 + 0 → 1
1 + 1 → 0, carry 1 (since 1 + 1 = 0 + 1 × 10 in binary)
     

添加两个“1”数字会产生一个数字   “0”,而1必须加入   下一栏。

<强>减法

  

减法的作用大致相同   方式:

0 − 0 → 0
0 − 1 → 1, borrow 1
1 − 0 → 1
1 − 1 → 0
     

从“0”减去“1”数字   数字产生数字“1”,而1   必须从中减去   下一栏。这被称为   借款。原理是一样的   至于携带。当一个结果   减法小于0,最小   数字的可能值,   程序是“借”赤字   除以基数(即10/10)   从左边开始,从中减去它   下一个位置值。

<强>乘法

  

二进制中的乘法类似于   它的十进制对应。两个数字A.   和B可以乘以部分   产品:B中的每个数字   A中该数字的乘积是   计算并写在新线上,   向左移动,使其最右边   数字与B中的数字对齐   那是用的。所有这些的总和   部分产品给出了最终结果   结果

     

因为只有两位数字   二进制,只有两种可能   每个部分的结果   乘法:

* If the digit in B is 0, the partial product is also 0
* If the digit in B is 1, the partial product is equal to A
     

例如,二进制数1011   和1010乘以如下:


            1 0 1 1   (A)
          × 1 0 1 0   (B)
          ---------
            0 0 0 0   ← Corresponds to a zero in B
    +     1 0 1 1     ← Corresponds to a one in B
    +   0 0 0 0
    + 1 0 1 1      
    --------------- 
    = 1 1 0 1 1 1 0

答案 2 :(得分:4)

以下代码实现二进制加法而不实际执行任何算术,二进制或其他操作。实际的“添加”由lookupTable完成,其他一切都是直接的字符串操作。我写这篇文章的目的是让它尽可能具有指导性,强调过程而不是效率。希望它有所帮助。

public class BinaryArithmetic {
    static String[] lookupTable = {
        "0+0+0=00",
        "0+0+1=01",
        "0+1+0=01", 
        "0+1+1=10",
        "1+0+0=01",
        "1+0+1=10",
        "1+1+0=10",
        "1+1+1=11",
    };
    static String lookup(char b1, char b2, char c) {
        String formula = String.format("%c+%c+%c=", b1, b2, c);
        for (String s : lookupTable) {
            if (s.startsWith(formula)) {
                return s.substring(s.indexOf("=") + 1);
            }
        }
        throw new IllegalArgumentException();
    }
    static String zeroPad(String s, int length) {
        while (s.length() < length) {
            s = "0" + s;
        }
        return s;
    }   
    static String add(String s1, String s2) {
        int length = Math.max(s1.length(), s2.length());
        s1 = zeroPad(s1, length);
        s2 = zeroPad(s2, length);
        String result = "";
        char carry = '0';
        for (int i = length - 1; i >= 0; i--) {
            String columnResult = lookup(s1.charAt(i), s2.charAt(i), carry);
            result = columnResult.charAt(1) + result;
            carry = columnResult.charAt(0);
        }
        if (carry == '1') {
            result = carry + result;
        }
        return result;
    }
    public static void main(String args[]) {
        System.out.println(add("11101", "1001"));
    }
}

虽然我们正在努力,但我也可以做multiply

static String multiply(String s1, String s2) {
    String result = "";
    String zeroSuffix = "";
    for (int i = s2.length() - 1; i >= 0; i--) {
        if (s2.charAt(i) == '1') {
            result = add(result, s1 + zeroSuffix);
        }
        zeroSuffix += "0";
    }
    return result;
}

答案 3 :(得分:2)

使用二进制算法与更熟悉的基数10没什么区别。让我们再加上例如

                 (1)     (1)
182      182      182      182      182
845      845      845      845      845
--- +    --- +    --- +    --- +    --- +
           7       27      027     1027

那你做了什么?你右对齐要添加的数字,然后从右到左,一次添加一个数字,必要时向左移动+1。

在二进制中,过程完全相同。事实上,它更简单,因为你现在只有2个“数字”,0和1!

             (1)                           (1)       (1)
11101      11101      11101      11101      11101      11101      11101
 1001       1001       1001       1001       1001       1001       1001 
----- +    ----- +    ----- +    ----- +    ----- +    ----- +    ----- +
               0         10        110       0110      00110     100110

其余的操作也同样工作:你用于基数10的过程相同,适用于基数2.再次,它实际上更简单,因为只有2个“数字”,0和1.这简单就是为什么硬件喜欢二进制系统。

答案 4 :(得分:1)

将二进制字符串转换为整数,然后对整数进行操作,例如

String add(String s1, String s2) {
    int i1 = Integer.parseInt(s1);
    int i2 = Integer.parseInt(s2);
    return Integer.toBinaryString(i1 + i2);
}

答案 5 :(得分:0)

内置的BitSet类非常简单,可用于位级操作。