算法导论2.1-4 考虑n位二进制整数相加起来的问题

考虑把两个n位二进制整数加起来的问题，这两个整数分别存储在两个n元数组A和B中。这两个整数的和应按二进制形式存储在一个(n+1)元数组C中。

使用java代码实现；实现代码如下：

参数A和B为相同长度n的整形数组，该函数返回一个长度为n+1的数组

    private static int[] BinaryAdd(int[] A,int[] B)
    {
        int flag=0;
        int[] C=new int[A.length+1];
        int i=0;
        for(i=A.length-1;i>=0;i--)
        {
            if((A[i]+B[i]+flag)>1)
            {
                C[i+1]=(A[i]+B[i]+flag)%2;
                flag=1;
            }
            else
            {
                C[i+1]=A[i]+B[i]+flag;
                flag=0;
            }
        }
        C[0]=flag;
        return C;
    }

拓展：如何实现两个不限制长度的二进制数组相加并的出正确结果？？

实现代码如下，代码有待优化：

private static int[] BinaryMultiAdd(int[] A,int[] B)
    {
        //返回数组长度为A、B中长度较长的数组+1
        int[] C={};

        int flag=0;
        if(A.length>B.length)
        {
            C=new int[A.length+1];
            for(int i=A.length-1;i>=0;i--)
            {

                if(A.length-i<=B.length)
                {
                    if((A[i]+B[B.length-A.length+i]+flag)>1)
                    {
                        C[i+1]=(A[i]+B[B.length-A.length+i]+flag)%2;
                        flag=1;
                    }
                    else
                    {
                        C[i+1]=A[i]+B[B.length-A.length+i]+flag;
                        flag=0;
                    }
                }
                else
                {
                    if((A[i]+flag)>1)
                    {
                        C[i+1]=(A[i]+flag)%2;
                        flag=1;
                    }
                    else
                    {
                        C[i+1]=A[i]+flag;
                        flag=0;
                    }

                }
            }
            C[0]=flag;
        }
        else
        {
            C=new  int[B.length+1];
            for(int i=B.length-1;i>=0;i--)
            {
                if(B.length-i<=A.length)
                {
                    if((B[i]+A[A.length-B.length+i]+flag)>1)
                    {
                        C[i+1]=(B[i]+A[A.length-B.length+i]+flag)%2;
                        flag=1;
                    }
                    else
                    {
                        C[i+1]=B[i]+A[A.length-B.length+i]+flag;
                        flag=0;
                    }
                }
                else
                {
                    if((B[i]+flag)>1)
                    {
                        C[i+1]=(B[i]+flag)%2;
                        flag=1;
                    }
                    else
                    {
                        C[i+1]=B[i]+flag;
                        flag=0;
                    }
                }
            }
            C[0]=flag;
        }
        return C;
    }