【思路1】

思路1和思路3思路是一樣的，也是用0補齊最短字串左側，至兩字串等長，如 a = "1111", b = "1"，其基本實現就是實現 a = "1111"，b = "0001"，這樣相加，只是程式碼更簡潔：

    public String addBinary(String a, String b) {
        int maxLen = Math.max(a.length(), b.length());
        StringBuilder sb = new StringBuilder();
        int carry = 0;
        for (int i = 0; i < maxLen; i++) { //從右邊開始逐位取出字串 a、b 的字元值 tempA 和 tempB，如果長度不足，則用0替代
            int tempA = a.length() > i ? a.charAt(a.length() - i - 1) - '0' : 0;
            int tempB = b.length() > i ? b.charAt(b.length() - i - 1) - '0' : 0;
            sb.insert(0, (tempA + tempB + carry) % 2);  //在最左側插入相加結果
            carry = tempA + tempB + carry > 1 ? 1 : 0;  //得到進位
        }
        if (carry == 1) sb.insert(0, 1);  //如果最高位有進位，則最高位還要加一位 1
        return sb.toString();
    }
 

294 / 294 test cases passed. Runtime: 5 ms  Your runtime beats 30.64% of javasubmissions.

【思路2】：

先將兩個字串逐位從右到左相加的和與進位相加，放入字元陣列中。最後等到短的字串加完之後，留下較長的為加完畢字串和進位，用以補充字元陣列。當然這種解法比較麻煩：

public class Solution {
    public static String addBinary(String a, String b) {
        if(a.equals("")) return b;
        if(b.equals("")) return a;               //如果b為空，則返回a
        int al = a.length() - 1;                 //字串a的長度減1，剛好指向陣列的末尾
        int bl = b.length() - 1;  
        int t = Math.max(al, bl) + 1;    
        char[] arr = new char[t+1];             //設定要建立char陣列的長度
        int c = 0;
        /*char[] str1 = a.toCharArray();
        char[] str2 = b.toCharArray();*/  //註釋部分是將字串放入陣列中，這種方法以後再實現，如果讀者有興趣的話，可以自己嘗試實現。
        for(; al>=0 && bl>=0; al--, bl--, t--) {           //這裡實現a1與b1的位相加
            int s = a.charAt(al) + b.charAt(bl) + c - '0' - '0';
            if(s==2) {
            	c = 1;
            	s = 0;
            } else if(s == 3) {
            	c = 1;
            	s = 1;
            }
            else c = 0;
            arr[t] = (char)(s+'0');
        }
        while (al >= 0) {                      //若b字串長度小於a長度，則繼續求 a 和進位的和
        	if(a.charAt(al) - '0' + c > 1) {
        		arr[t] = 0 + '0';
        		c = 1;
        	} else {
        		arr[t] = (char) (a.charAt(al) + c);
        		c = 0;
        	}
            t--;
            al--;
        }
        while (bl >= 0) {
        	if(b.charAt(bl) - '0' + c > 1) {
        		arr[t] = 0 + '0';
        		c = 1;
        	} else {
        		arr[t] = (char) (b.charAt(bl) + c);
        		c = 0;
        	}
            t--;
            bl--;
        }
        if(c == 1) arr[0] = 1+'0';
        //將陣列轉化為字串輸出
        return new String(arr).trim();
    }
}
 

294 / 294 test cases passed. Runtime: 3 ms  Your runtime beats 91.41% of javasubmissions.

【思路3】：

麻煩之處在於字串有長短之分，如果不控制好，可能會造成空指標異常。那麼我們可以將最短的字串右端用0補齊，這時兩個字串就等長了，這樣就可以逐位相加，最後還有判斷是否有進位，如果有進位還得在最左端補上一位1：

public class Solution {
    public String addBinary(String a, String b) {
		int aLen = a.length();
		int bLen = b.length();
		if(aLen > bLen) {                    //字串 b 的長度較長
			int gap = aLen - bLen;
			while(gap-- > 0) b = 0 + b;  //用0補齊字串 b 至字串 a、b 等長
		}
		if(bLen > aLen) {
			int gap = bLen - aLen;
			while(gap-- > 0) a = 0 + a;
		}
		int maxLen = aLen > bLen ? aLen : bLen;
		int c = 0, sum = 0;
		String result = "";
		for(int i = --maxLen; i >= 0; i--) {
			sum = a.charAt(i) + b.charAt(i) + c - '0' * 2;
			if(sum > 1) {
				c = 1;
				sum -= 2;
			} else {
				c = 0;
			}
			result = sum + result;
		}
		if(c == 1) result = 1 + result;
		return result;
	}
}
 

294 / 294 test cases passed.   Runtime: 5 ms