大数相加相减相乘

题目：两个非常大的数字相乘（相加，相减）

       该题目在java中可以使用BigInteger类中的方法来实现。否则的话可以使用如下方式来实现。

       大数相乘：假设有A和B两个大数，位数分别为a和b。根据我们平常手动计算乘法的方式可以看出，最终的结果的位数c一定小于等于a+b，我们可以举一个简单的例子来说明，99*999=98901，最终结果是五位（a+b）。下面我们根据98*765 = 74970来看看结果中的每一位是怎么得来的，最后一位0是A的最后一位8和B的最后一位5的乘机除10取余得到的，结果的倒数第二位7是A的倒数第二位9和B的最后一位5的乘积45与A的最后一位8和B的倒数第二位6的乘积48之和93然后加上上一位的进位4得到97然后在除10取余得到的7……依次进行下去就可以得到最终结果。

        下面来总结一下规律：A中的第i位与B的第j位之积最终会存放到结果的第i+j位中（i和j都是从后往前数），所以我们可以先进行结果中每一位的计算，完成所有计算后在进行进位的计算。为了将i和j从0开始计算，我们先将字符串A和B进行逆转，然后在进行计算的时候就可以从0开始了。具体程序如下：

[java]  view plain copy

1. public static void bigNumberSimpleMulti(String f, String s) {  
2.         System.out.print("乘法：\n" + f + "*" + s + "=");  
3.         // 获取首字符，判断是否是符号位  
4.         char signA = f.charAt(0);  
5.         char signB = s.charAt(0);  
6.         char sign = '+';  
7.         if (signA == '+' || signA == '-') {  
8.             sign = signA;  
9.             f = f.substring(1);  
10.         }  
11.         if (signB == '+' || signB == '-') {  
12.             if (sign == signB) {  
13.                 sign = '+';  
14.             } else {  
15.                 sign = '-';  
16.             }  
17.             s = s.substring(1);  
18.         }  
19.         // 将大数翻转并转换成字符数组  
20.         char[] a = new StringBuffer(f).reverse().toString().toCharArray();  
21.         char[] b = new StringBuffer(s).reverse().toString().toCharArray();  
22.         int lenA = a.length;  
23.         int lenB = b.length;  
24.         // 计算最终的最大长度  
25.         int len = lenA + lenB;  
26.         int[] result = new int[len];  
27.         // 计算结果集合  
28.         for (int i = 0; i < a.length; i++) {  
29.             for (int j = 0; j < b.length; j++) {  
30.                 result[i + j] += (int) (a[i] - '0') * (int) (b[j] - '0');  
31.             }  
32.         }  
33.         // 处理结果集合，如果是大于10的就向前一位进位，本身进行除10取余  
34.         for (int i = 0; i < result.length; i++) {  
35.             if (result[i] > 10) {  
36.                 result[i + 1] += result[i] / 10;  
37.                 result[i] %= 10;  
38.             }  
39.         }  
40.         StringBuffer sb = new StringBuffer();  
41.         // 该字段用于标识是否有前置0，如果是0就不需要打印或者存储下来  
42.         boolean flag = true;  
43.         for (int i = len - 1; i >= 0; i--) {  
44.             if (result[i] == 0 && flag) {  
45.                 continue;  
46.             } else {  
47.                 flag = false;  
48.             }  
49.             sb.append(result[i]);  
50.         }  
51.         if (!sb.toString().equals("")) {  
52.             if (sign == '-') {  
53.                 sb.insert(0, sign);  
54.             }  
55.         } else {  
56.             sb.append(0);  
57.         }  
58.         // 返回最终结果  
59.         System.out.println(sb.toString());  
60.     }  

        大数相加:和相乘是类似的，不同的地方只是result结果集的长度，其值为较长字符串的长度加一。具体代码如下：

[java]  view plain copy

1. public String bigNumberAdd(String f, String s) {  
2.         //翻转两个字符串，并转换成数组  
3.         char[] a = new StringBuffer(f).reverse().toString().toCharArray();  
4.         char[] b = new StringBuffer(s).reverse().toString().toCharArray();  
5.         int lenA = a.length;  
6.         int lenB = b.length;  
7.         //计算两个长字符串中的较长字符串的长度  
8.         int len = lenA > lenB ? lenA : lenB;  
9.         int[] result = new int[len + 1];  
10.         for (int i = 0; i < len + 1; i++) {  
11.             //如果当前的i超过了其中的一个，就用0代替，和另一个字符数组中的数字相加  
12.             int aint = i < lenA ? (a[i] - '0') : 0;  
13.             int bint = i < lenB ? (b[i] - '0') : 0;  
14.             result[i] = aint + bint;  
15.         }  
16.         //处理结果集合，如果大于10的就向前一位进位，本身进行除10取余  
17.         for (int i = 0; i < result.length; i++) {  
18.             if (result[i] > 10) {  
19.                 result[i + 1] += result[i] / 10;  
20.                 result[i] %= 10;  
21.             }  
22.         }  
23.         StringBuffer sb = new StringBuffer();  
24.         //该字段用于标识是否有前置0，如果有就不要存储  
25.         boolean flag = true;  
26.         for (int i = len; i >= 0; i--) {  
27.             if (result[i] == 0 && flag) {  
28.                 continue;  
29.             } else {  
30.                 flag = false;  
31.             }  
32.             sb.append(result[i]);  
33.         }  
34.         return sb.toString();  
35.     }  

        大数相减： 大数相减和大数相加类似，只是需要判断正负

[java]  view plain copy

1. public static String bigNumberSub(String f, String s) {  
2.         System.out.print("减法:" + f + "-" + s + "=");  
3.         // 将字符串翻转并转换成字符数组  
4.         char[] a = new StringBuffer(f).reverse().toString().toCharArray();  
5.         char[] b = new StringBuffer(s).reverse().toString().toCharArray();  
6.         int lenA = a.length;  
7.         int lenB = b.length;  
8.         // 找到最大长度  
9.         int len = lenA > lenB ? lenA : lenB;  
10.         int[] result = new int[len];  
11.         // 表示结果的正负  
12.         char sign = '+';  
13.         // 判断最终结果的正负  
14.         if (lenA < lenB) {  
15.             sign = '-';  
16.         } else if (lenA == lenB) {  
17.             int i = lenA - 1;  
18.             while (i > 0 && a[i] == b[i]) {  
19.                 i--;  
20.             }  
21.             if (a[i] < b[i]) {  
22.                 sign = '-';  
23.             }  
24.         }  
25.         // 计算结果集，如果最终结果为正，那么就a-b否则的话就b-a  
26.         for (int i = 0; i < len; i++) {  
27.             int aint = i < lenA ? (a[i] - '0') : 0;  
28.             int bint = i < lenB ? (b[i] - '0') : 0;  
29.             if (sign == '+') {  
30.                 result[i] = aint - bint;  
31.             } else {  
32.                 result[i] = bint - aint;  
33.             }  
34.         }  
35.         // 如果结果集合中的某一位小于零，那么就向前一位借一，然后将本位加上10。其实就相当于借位做减法  
36.         for (int i = 0; i < result.length - 1; i++) {  
37.             if (result[i] < 0) {  
38.                 result[i + 1] -= 1;  
39.                 result[i] += 10;  
40.             }  
41.         }  
42.   
43.         StringBuffer sb = new StringBuffer();  
44.         // 如果最终结果为负值，就将负号放在最前面，正号则不需要  
45.         if (sign == '-') {  
46.             sb.append('-');  
47.         }  
48.         // 判断是否有前置0  
49.         boolean flag = true;  
50.         for (int i = len - 1; i >= 0; i--) {  
51.             if (result[i] == 0 && flag) {  
52.                 continue;  
53.             } else {  
54.                 flag = false;  
55.             }  
56.             sb.append(result[i]);  
57.         }  
58.         // 如果最终结果集合中没有值，就说明是两值相等，最终返回0  
59.         if (sb.toString().equals("")) {  
60.             sb.append("0");  
61.         }  
62.         // 返回值  
63.         System.out.println(sb.toString());  
64.         return sb.toString();  
65.     }  

        在上述的各中计算过程中有几点需要说明：大数相加的时候没有判断数字的正负，如果都是正数，那么就可以按照正数相加来计算，如果是一正一负可以转换成大整数相减，两个负数可以先保存符号，然后相加。