二进制求和

最近在做一些算法题目，就在这里做个记录。

题目：

Given two binary strings, return their sum (also a binary string).
For example,
a = "11"
b = "1"
Return "100".

1. 按位累加

2. 考虑进位

3. 结果长度是较长字符串长度或者较长字符串长度+1

不太会表达，直接贴源码了。

c++实现：

 1 class Solution {
 2 public:
 3     string addBinary(string a, string b) {
 4         int len_a = a.size();
 5         int len_b = b.size();
 6         if (len_a < len_b) {
 7             string tmp = a;
 8             a = b;
 9             b = tmp;
10         }
11         int len_l = a.size() - 1;  // length long
12         int len_s = b.size() - 1;  // length short
13         bool carry_flag = false;  // 进位标记
14         char* ret = new char[len_l + 2];
15         ret[len_l+1] = 0;
16         for (; len_s >= 0; len_s--, len_l--) {
17             /**
18                     三种情况
19                 1. a[len_s] == b[len_s] = ‘1‘  有进位
20                 2. a[len_s] != b[len_s] (0,1) or (1,0)
21                 3. a[len_s] == b[len_s] = 0
22             */
23             if (a[len_l] == b[len_s] && a[len_l] == ‘1‘) {
24                 if (carry_flag) {  // 如果已经有进位
25                     ret[len_l] = ‘1‘;
26                 } else {  // 如果没有进位
27                     ret[len_l] = ‘0‘;
28                     carry_flag = true;
29                 }
30             }
31             if (a[len_l] != b[len_s]) {
32                 if (carry_flag) {  // 如果有进位
33                     ret[len_l] = ‘0‘;
34                 } else {
35                     ret[len_l] = ‘1‘;
36                     carry_flag = false;
37                 }
38             }
39             if (a[len_l] == b[len_s] && a[len_l] == ‘0‘) {
40                 if (carry_flag) {
41                     ret[len_l] = ‘1‘;
42                 } else {
43                     ret[len_l] = ‘0‘;
44                 }
45                 carry_flag = false;
46             }
47         }
48         for (; len_l >= 0; len_l--) {
49             if (carry_flag) {
50                 if (a[len_l] == ‘1‘) {
51                     ret[len_l] = ‘0‘;
52                 } else {
53                     ret[len_l] = ‘1‘;
54                     carry_flag = false;
55                 }
56             } else {
57                 ret[len_l] = a[len_l];
58             }
59         }
60         string str_ret = "";
61         if (carry_flag) {
62             str_ret = "1" + string(ret);
63         } else {
64             str_ret = string(ret);
65         }
66         delete[] ret;
67         return str_ret;
68     }
69 };

Java实现：

注： Java代码不是自己写的了，在网上看到的，摘录在这里。

 1 public class Solution {
 2     public String addBinary(String a, String b) {
 3         if(a.length() < b.length()) {
 4             String temp = a;
 5             a =b;
 6             b = temp;
 7         }
 8         int la = a.length()-1;
 9         int lb = b.length()-1;
10         int carries = 0;  //进位
11         String res = "";  //结果值
12         while(lb >= 0) {  //先依据短字符串的长度依次计算
13             int sum = (int)(a.charAt(la)-‘0‘)+(int)(b.charAt(lb)-‘0‘)+carries;
14             res = String.valueOf(sum%2)+res;
15             carries =sum/2;
16             la--;
17             lb--;
18         }
19         while(la>=0){//再依据长字符串的长度依次计算
20             int sum = (int)(a.charAt(la)-‘0‘)+carries;
21             res = String.valueOf(sum%2)+res;
22             carries =sum/2;
23             la--;
24         }
25         if (carries==1){
26             res ="1"+res;//计算最后的进位
27         }
28         return res;
29     }
30 }

Python实现：

这段Python代码是同事写的，表示只有一句话啊，不过，我们一致认为，这不是正解。但是以后碰到进制转换可以使用这种。

1 class Solution(object):
2     def addBinary(self, a, b):
3         """
4         :type a: str
5         :type b: str
6         :rtype: str
7         """
8         return str(bin(int(a, 2) + int(b, 2)))[2:]

耗时都差不多