leetcode67——二进制求和

一.转换成十进制

//Integer.toBinaryString()：返回int变量的二进制表示的字符串
//Integer.parseInt(string, radix)：将字符串参数作为有符号的十进制整数进行解析

class Solution 
{
    public String addBinary(String a, String b) 
    {
        return Integer.toBinaryString(
            Integer.parseInt(a, 2) + Integer.parseInt(b, 2)  
        );
    }
}

二.逢二进一

思路一：

①根据测试👇，数组下标为0放的是二进制的最高位，如果要从低位开始计算，需要反转

②int型转为char型：直接在int变量后加上一个’0’；
                例如：
                 int a = 10;
                 printf(“%c\n”,a+’0’);

   char型转为int型：char型的变量减去一个‘0’；
                例如：
                char b = ‘5’;
                printf(“%d\n”,b-‘0’);

   字符串转为数字：用auoi，atol，atof函数，分别对应整型，long型，double型

               以整型为例：
               char str[]=“1234”;
               int a=atoi(str);

   数字转换成字符串：用sprintf函数。

                以整型为例：
                char str[10];
                int a=1234;
                sprintf(str,"%d",a);

void reserve(char* s)    //反转数组
{
    int len = strlen(s); //strlen()：计算字符串 str 的长度，直到空结束字符，但不包括空结束字符
    for (int i = 0; i < len / 2; i++) 
    {
        char t = s[i];
        s[i] = s[len - i - 1];
        s[len - i - 1] = t;
    }
}

char* addBinary(char* a, char* b) 
{
    reserve(a);
    reserve(b);

    int len_a = strlen(a), len_b = strlen(b);
    int n = fmax(len_a, len_b);      //fmax()：返回两个浮点参数中较大的一个
    int carry = 0, len = 0;          //carry：进位
    char* ans = (char*)malloc(sizeof(char) * (n + 2));   //+2是因为还要放'\0'

    for (int i = 0; i < n; ++i) 
    {
        carry += i < len_a ? (a[i] == '1') : 0;
        carry += i < len_b ? (b[i] == '1') : 0;
        ans[len++] = carry % 2 + '0';    //int转为char
        carry /= 2;
    }

    if (carry) 
    {
        ans[len++] = '1';
    }

    ans[len] = '\0';   //'\0'：字符串结束的标志
    reserve(ans);

    return ans;
}

思路二：字符串短的前面补0

class Solution 
{
public:
    string addBinary(string a, string b) 
    {
        int lenA = a.size();
        int lenB = b.size();

        //先让两个字符串等长
        while (lenA < lenB)
        {
            a = '0' + a;
            ++lenA;
        }
        while (lenA > lenB)
        {
            b = '0' + b;
            ++lenB;
        }

        //满2进1
        for (int i = lenA - 1; i > 0; --i)
        {
            a[i] = a[i] - '0' + b[i];
            if (a[i] >= '2')
            {
                a[i] = (a[i] - '0') % 2 + '0';
                a[i - 1] = a[i - 1] + 1;
            }
        }

        //判断首位
        a[0] = a[0] - '0' + b[0];

        if (a[0] >= '2')
        {
            a[0] = (a[0] - '0') % 2 + '0';
            a = '1' + a;
        }

        return a;
    }
};

思路三：直接正常数学逻辑(C++, Java)

class Solution
{
public:
    string addBinary(string a, string b)
    {   
        string ans;
        int carry = 0;
        int i = a.length() - 1, j = b.length() - 1;
        while(i >= 0 || j >= 0 || carry)
        {
            if(i >= 0) carry += a[i--] - '0';
            if(j >= 0) carry += b[j--] - '0';
            ans = to_string(carry % 2) + ans;
            carry /= 2;
        }

        return ans;
    }
};

class Solution 
{
    public String addBinary(String a, String b)
    {
        //根据加法运算法则，我们需要从后先前遍历相加，注意起始下标位置  
        int i = a.length() - 1, j = b.length() - 1, carry = 0;  
        StringBuilder sb = new StringBuilder();

        //如果a，b各个位置上两数和加起来不为零或者i，没有遍历到起始位置                            
        while(carry == 1 || i >= 0 || j >= e)
        {
            //只要为1就是有效相加位，记录下来
            if(i >= 0 && a.charAt(i--) == '1')
            {
                carry++;
            }

            if(j >= 0 && b.charAt(j--) == '1')
            {
                carry++;
            }
            //辗转相除法取余数反向输出即为结果
            sb.append(carry % 2);
            carry /= 2;
        }

        return sb.reverse().toString();
}