Java中的二进制算法

从理论上讲，二进制算法很简单，但作为一名初级程序员，我发现要想出二进制数的加法、减法、乘法和除法的算法有点困难

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

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

二进制字符串转换为int:

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

然后你可以用这两个整数做任何你想做的事情，例如：

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

要将它们恢复为二进制字符串：

String s = Integer.toBinaryString(i);

---

将二进制字符串转换为整数，然后对整数进行运算，例如

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

---

来自维基百科的算法：

添加：

计算机中最简单的算术运算 二进制是加法。加两个 一位数的二进制数是 相对简单，使用一种 携带：

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”中减去“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的乘积如下：

101（A） ×10（B） --------- 0 0 0 0 ← 对应于B中的零 + 1 0 1 1 ← 对应于B中的a + 0 0 0 0 + 1 0 1 1 --------------- = 1 1 0 1 1 1 0

---

内置类非常直接地用于位级操作。

使用二进制算法与更熟悉的基数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

---

其余操作的工作方式也类似：您对base 10使用的流程与对base 2使用的流程相同。同样，它实际上更简单，因为只有2个“数字”，0和1。这种简单性就是硬件喜欢二进制系统的原因。

下面的代码实现二进制加法，而不实际执行任何算术、二进制或其他操作。实际的“加法”是通过

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"));
    }
}

---

你想学习如何实现实际的算法，还是只对这些字符串进行算术运算？达夫，我想学习如何实现算法。对不起，我应该注意到，我需要避免将它们转换为int或long。

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

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"));
    }
}

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;
}