二进制数字的乘法

这两天一直在自学离散数学，有一道题目，花了我3个小时终于做出来了。特拿出来和大家交流

// 做一个二进制乘法的程序，输入b(n),b(n-1),...,b(0)，b'(m),b'(m-1),...,b'(0)
// 输出c
/*
二进制的乘法表只有两种1×1=10,1×0=0,0×0=0
其中1×1=10是要进位的

利用和十进制相似的乘法原理，做出二进制的乘法，看例子
    111
×      11
----------
    111
   111
----------
  10101
*/
#include < iostream >
#include < cstring >
using   namespace  std;

// 首先归纳总结：对于a(n+1位),b(m+1位)的二进制数字相乘的结果不会大于n+m+2位
// 因为a <= 2^(n+1)-1 < 2^(n+1), b <= 2^(n+1)-1 < 2^(n+1)
// 所以a*b < 2^(n+m+2) (这个数字是n+m+3位的)
// 因此，a*b的位数<=n+m+2

// 以下的程序是根据输入的两数的排列是
// a(n),a(n-1),...,a(0)和b(m),b(m-1),...,b(0)来计算的
// 所以结果是倒过来的

/* 具体算法是这样的

                                                                               a(n),a(n-1)...a(0)
                                                                             × b(m),b(m-1)...b(0)
                                        ------------------------------------------------------
(1)                                                    b(0)a(n), b(0)a(n-1),...., b(0)a(1), b(0)a(0)
(2)                                        b(1)a(n), b(1)a(n-1), ...  , b(1)a(1), b(1)a(0)
                                            .
                                            .
                                            .
(m)                 b(m-1)a(n), b(m-1)a(n-1)
(m+1)  b(m)a(n), b(m)a(n-1)

结果放在一个c(m+n)...c(0)的数组中，这个数组中所有的值都初始化为0
步骤里面省略了carry的计算
[第一步]：
c(0)=c(0)+a(0)b(0)+carry
c(1)=c(1)+a(1)b(0)+carry
        ...
c(n)=c(n)+a(n)b(0)+carry
c(n+1)=c(n+1)+carry
carry=0(为了不让进位带入下一次的计算)

[第二步]:
c(1)=c(1)+a(0)b(1)+carry
c(2)=c(2)+a(1)b(1)+carry
        ...
c(n+1)=c(n+1)+a(n)b(1)+carry
c(n+2)=c(n+2)+carry
carry=0
        ...
[第m+1步]:
c(m)=c(m)+a(0)b(m)+carry
c(m+1)=c(m+1)+a(1)b(m)+carry
        ...
c(m+n)=c(m+n)+a(n)b(m)+carry
c(m+n+1)=c(m+n+1)+carry
carry=0

看清楚，实际上c(m+n+1)就是第m+n+2位
*/


/*   以下的程序是数字倒过来输入，结果也是倒过来输入的
int* binary_multiplication(int a[], int alen, int b[], int blen){
    int *c = new int[alen+blen];
    memset(c, 0, sizeof(int)*(alen+blen));//将结果的每一位都清0 
    int carry = 0;    //进位 
    int t;    //临时变量 
    for(int i = 0; i < blen; i++){
        for(int j = 0; j < alen; j++){
            //临时变量赋值为c[i+j] 
            t = c[i+j];
            //给c[i+j]赋值 
            c[i+j] = (c[i+j] + b[i]*a[j] + carry)%2;
            //存放进位 
            carry = (t + b[i]*a[j] + carry)/2;
        }
        c[i+alen]=carry;    //将当前最高位写上上一次加法中最后的进位
        carry=0;    //进位一定要在这里清零，不要带入到下一次的加法中去
    }
    return c;
}
*/

// 这个程序是数字是正过来输入，结果也是正过来输出的
int *  binary_multiplication( int  a[],  int  alen,  int  b[],  int  blen){
     int   * c  =   new   int [alen + blen];
    memset(c,  0 ,  sizeof ( int ) * (alen + blen));     // 将结果的每一位都清0 
     int  carry  =   0 ;     // 进位 
     int  t;             // 临时变量
     for ( int  i  =  blen - 1 ; i  >=   0 ; i -- ){
         for ( int  j  =  alen - 1 ; j  >=   0 ; j -- ){
            t  =  c[i + j + 1 ];         // 临时变量赋值为c[i+j+1] 
            c[i + j + 1 ]  =  (c[i + j + 1 ]  +  b[i] * a[j]  +  carry) % 2 ;     // 给c[i+j]赋值 
            carry  =  (t  +  b[i] * a[j]  +  carry) / 2 ;     // 存放进位 
        }
        c[i] = carry;     // 将当前最高位写上上一次加法中最后的进位
        carry = 0 ;     // 进位一定要在这里清零，不要带入到下一次的加法中去
    }
     return  c;
}


int  main() {
     int  a[] = { 1 , 1 , 1 , 0 , 0 , 0 , 0 };
     int  asize  =   sizeof (a) / sizeof ( int );
     int  b[] = { 1 , 1 , 1 , 0 , 1 , 1 };
     int  bsize  =   sizeof (b) / sizeof ( int );

     int   * result  =  binary_multiplication(a, asize, b, bsize);
    
     for ( int  i  =   0 ; i  <  asize + bsize; i ++ )
        cout  <<  result[i];
    
    cin. get (); 
}