leetcode-67-二进制求和-C语言

给你两个二进制字符串，返回它们的和（用二进制表示）。输入为 非空 字符串且只包含数字 1 和 0。
示例 1:
输入: a = “11”, b = “1”
输出: “100”
示例 2:
输入: a = “1010”, b = “1011”
输出: “10101”
提示：
每个字符串仅由字符 ‘0’ 或 ‘1’ 组成。
1 <= a.length, b.length <= 10^4
字符串如果不是 “0” ，就都不含前导零。

**思路：
步骤一：把两个字符串进行反转
步骤二：（1）length=min(lengtha,lengthb),flag=0;
（2）在0~length-1范围进行逐位相加，并加上flag;
（3）如果需要进位，将flag=1,否则flag=0;
步骤三：（1）length_max=max(lengtha,lengthb)；
（2）在length~length_max范围内进行逐位相加，方法同步骤2。
步骤四：将逐位相加的字符串进行逆序。

notice：

1. 字符串结束标志’\0’，不结束会出现乱码；
2. 声明新的指针需要分配内存，malloc函数调用时需在文件开头声明编译预处理的函数库stdlib.h；
3. 字符‘1’和字符‘0’不能直接用加法运算，因为他们对应的ascll值并不是1和0；**

代码如下：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int main()
{
    char * addBinary(char * a, char * b);
    //初始化字符串数组a,b
    char a[100]="100";
    char b[100]="110010";
    char *c=(char *)malloc(sizeof(char)*100);
    //声明一个指针c，用来指向函数返回值
    c=addBinary(a, b);
    puts(c);
    return 0;
}
//输入两个数组，返回二进制和
//输入: a = "11", b = "1"
//输出: "100"
char * addBinary(char * a, char * b){
    //lengtha用来记录数组a的长度，lengthb用来记录数组b的长度，length用来记录数组a,b的最短长度
    int lengtha,lengthb,length,i,j,k,flag;
    //c用来接收a反转数组，d用来接收b的反转数组
    char *c=(char *)malloc(sizeof(char)*10000);
    char *d=(char *)malloc(sizeof(char)*10000);
    //e用来接收接收c,d和，f用来接收e的反转数组
    char *e=(char *)malloc(sizeof(char)*10000);
    char *f=(char *)malloc(sizeof(char)*10000);
    //计算a的长度
    for(lengtha=0;*(a+lengtha)!='\0';lengtha++);
    //a反转
    for(i=lengtha-1,j=0;i>=0;i--,j++)
        *(c+j)=*(a+i);
    *(c+j)='\0';
    //计算b的长度
    for(lengthb=0;*(b+lengthb)!='\0';lengthb++);
    //b反转
    for(i=lengthb-1,j=0;i>=0;i--,j++)
        *(d+j)=*(b+i);
    *(d+j)='\0';
    //falg用来记录两个对应字符相加是否需要进位，如果需要进位就置为1
    flag=0;
    //用length来记录a,b长度的最短值
    length = lengtha < lengthb ? lengtha : lengthb;
    //对0~length-1的字符求和
    for(i=0;i<length;i++)
    {
        if(*(c+i)=='1'&&*(d+i)=='1')
        {
            if(flag==1)
                *(e+i)='1';
            else
                *(e+i)='0';
            flag=1;//两个1相加肯定需要进1

        }
        else if(*(c+i)=='0'&&*(d+i)=='0'){
            if(flag==1)
                *(e+i)='1';
            else
                *(e+i)='0';
            flag=0;//两个0相加肯定不需要进1
        }else{
            if(flag==0)
            {
                    *(e+i)='1';
                    flag=0;
            }
            else{
                *(e+i)='0';
                flag=1;//前面进1，加这里的一个1，需要往后进1
            }
        }
    }
    //当两个字符串相等时
    if(lengtha==lengthb)
    {
        if(flag==0)
        {
            *(e+length)='\0';

        }
        else{
            flag=0;
            *(e+length)='1';
            *(e+length+1)='\0';
            i++;

        }
         for(i=i-1,j=0;i>=0;i--,j++)
            *(f+j)=*(e+i);
        *(f+j)='\0';
        return f;
    }
     //当第二个字符串比第一个字符串长时，后面要考虑进位，不能完全照搬
    else if(lengtha<lengthb)
    {

        for(i=length; i<lengthb; i++)
        {
            //如果前面无进位，后面全部直接进行复制
            if(flag==0)
            {
                *(e+i)=*(d+i);

            }
            else
            {
                if(*(d+i)=='1')
                {
                    *(e+i)='0';
                    flag=1;
                }
                else
                {
                    *(e+i)='1';
                    flag=0;
                }

            }
        }
    }
    //当第一个字符串比第二个字符串长时，后面要考虑进位，不能完全照搬
    else
    {
        for(i=length; i<lengtha; i++)
        {
            if(flag==0)
            {
                *(e+i)=*(c+i);

            }
            else
            {
                if(*(c+i)=='1')
                {
                    *(e+i)='0';
                    flag=1;
                }
                else
                {
                    *(e+i)='1';
                    flag=0;
                }

            }
        }
    }
    //如果到最后max(lengtha,lengthb)-1那一位还需要进位，就需要把e长度+1
    if(flag==1)
    {
        *(e+i)='1';
        *(e+i+1)='\0';
        i++;
    }
    else
        *(e+i)='\0';
    //将字符串e逆置为f，注意以'\0'结束字符串，否则输出会出现乱码
    for(i=i-1,j=0; i>=0; i--,j++)
        *(f+j)=*(e+i);
    *(f+j)='\0';
    return f;

}