43. Multiply Strings

Given two non-negative integers num1 and num2 represented as strings, return the product of num1 and num2.

Note:

1. The length of both num1 and num2 is < 110.
2. Both num1 and num2 contains only digits 0-9.
3. Both num1 and num2 does not contain any leading zero.
4. You must not use any built-in BigInteger library or convert the inputs to integer directly.

题目含义：计算两个非负整数的乘法，并用string返回

思路：

num1[i] * num2[j]` will be placed at indices `[i + j`, `i + j + 1]` 

    public String multiply(String num1, String num2) {
        int m=num1.length(),n=num2.length();
        int[] result = new int[m+n];
        for (int i=m-1;i>=0;i--)
        {
            for (int j=n-1;j>=0;j--)
            {
                int mul = (num1.charAt(i)-'0') * (num2.charAt(j)-'0');
                int p1 = i+j;
                int p2 = i + j +1;
                int sum = mul + result[p2];
                result[p1] += sum/10;
                result[p2] = sum%10;
            }
        }
        StringBuilder sb = new StringBuilder();
        for (int p:result)
        {
            if(!(sb.length() == 0 && p == 0))
            {
                sb.append(p);
            }
        }
        return sb.length()==0?"0":sb.toString();        
    }

 方法二：

计算两个字符串表示的非负大整数的乘积，结果仍然用字符串表示。

我们都熟悉笔算的整数乘积，按照被乘数逐位与乘数求积，保存进位；当被乘数换位时，结果递增一个数量级，与先前结果求和。

如上例所示，当我们计算字符串“123”*“456”时，采取与笔算相同的思想，按照从个位—>高位的计算思想，现将字符串翻转，计算完成后，翻转结果，返回。

 string multiply(string num1, string num2) {
        //如果有其中一个乘数的字符串表示为空，则返回空字符串
        if (num1.empty() || num2.empty())
            return string();

        if (num1 == "0" || num2 == "0")
            return "0";

        //按照整数从低位到高位计算，翻转两个乘数字符串
        reverse(num1.begin(), num1.end());
        reverse(num2.begin(), num2.end());
        //求两个乘数字符串的长度
        int len1 = strlen(num1.c_str()), len2 = strlen(num2.c_str());

        //定义乘法结果字符串
        string ret = "";
        //保存进位
        int carry = 0; 

        for (int i = 0; i < len1; i++)
        {
            //乘数的处理起始位
            size_t pos = i;
            for (int j = 0; j < len2; j++)
            {
                int temp = (num1[i] - '0') * (num2[j] - '0') + carry;

                //向当前位加入结果
                if (pos < ret.length())
                {
                    temp = temp + (ret[pos] - '0');
                    ret[pos] = temp % 10 + '0';
                }//if
                else{
                    ret.append(1, temp % 10 + '0');
                }//else
                //计算下一个进位
                carry = temp / 10;
                //处理乘数的下一位
                pos++;
            }//for
            if (carry > 0)
                ret.append(1, carry + '0');
            carry = 0;
        }//for

        //翻转整个结果字符串
        reverse(ret.begin(), ret.end());
        return ret;

    }

 方法三：

我们以289*785为例

首先我们把每一位相乘，得到一个没有进位的临时结果，如图中中间的一行红色数字就是临时结果，然后把临时结果从低位起依次进位。对于一个m位整数乘以n位整数的结果，最多只有m+n位。

    String multiply(String num1, String num2) {
        int n1 = num1.length(), n2 = num2.length();
        int[] tmpres =  new int[n1+n2];
        int k = n1 + n2 - 2;
        for(int i = 0; i < n1; i++)
            for(int j = 0; j < n2; j++)
                tmpres[k-i-j] += (num1.charAt(i)-'0')*(num2.charAt(j)-'0');
        int carryBit = 0;
        for(int i = 0; i < n1+n2; i++)//处理进位
        {
            tmpres[i] += carryBit;
            carryBit = tmpres[i] / 10;
            tmpres[i] %= 10;
        }
        int i = k+1;
        while(tmpres[i] == 0)i--;//去掉乘积的前导0
        if(i < 0)return "0"; //注意乘积为0的特殊情况
        StringBuilder res = new StringBuilder();
        for(; i >= 0; i--)
            res.insert(0,tmpres[i]);
        return res.toString();
    }

附录：

String str1="111";  
String str2="222";  
BigDecimal num1 = new BigDecimal(str1);  
BigDecimal num2 = new BigDecimal(str2);  
然后通过BigDecimal的加减乘除方法，进行运算：  
加法：  
BigDecimal result = num1.add(num2);  
减法：  
result = num1.subtract(num2);  
除法：  
result = num1.divide(num2);  
乘法：  
result = num1.multiply(num2);