微信公众号搜"智元新知"关注
微信扫一扫可直接关注哦!

大数相乘、大数相加、大数相减Java版本

题目:两个非常大的数字相乘(相加,相减)

       该题目在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(// 将大数翻转并转换成字符数组  
  18. char[] a = new StringBuffer(f).reverse().toString().tochararray();  
  19. char[] b = new StringBuffer(s).reverse().toString().tochararray();  
  20. int lenA = a.length;  
  21. int lenB = b.length;  
  22.         // 计算最终的最大长度  
  23. int len = lenA + lenB;  
  24. int[] result = new int[len];  
  25. // 计算结果集合  
  26. for (int i = 0; i < a.length; i++) {  
  27.             int j = 0; j < b.length; j++) {  
  28.                 result[i + j] += (int) (a[i] - '0') * (int) (b[j] - '0');  
  29.             }  
  30. // 处理结果集合,如果是大于10的就向前一位进位,本身进行除10取余  
  31. 0; i < result.length; i++) {  
  32. if (result[i] > 10) {  
  33.                 result[i + 1] += result[i] / 10;  
  34.                 result[i] %= 10;  
  35.         }  
  36.         StringBuffer sb = new StringBuffer();  
  37. // 该字段用于标识是否有前置0,如果是0就不需要打印或者存储下来  
  38. boolean flag = true;  
  39. int i = len - 1; i >= 0; i--) {  
  40. if (result[i] == 0 && flag) {  
  41.                 continue;  
  42.                 flag = false;  
  43.             sb.append(result[i]);  
  44. if (!sb.toString().equals("")) {  
  45. if (sign == '-') {  
  46.                 sb.insert(0, sign);  
  47.         } else {  
  48.             sb.append(// 返回最终结果  
  49.         System.out.println(sb.toString());  
  50.     }  

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

copy

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

copy

    static String bigNumberSub(String f,248)">         System.out.print("减法:" + f + "-" + s + "=");  
  1. // 将字符串翻转并转换成字符数组  
  2. // 找到最大长度  
  3. int len = lenA > lenB ? lenA : lenB;  
  4. // 表示结果的正负  
  5. // 判断最终结果的正负  
  6. if (lenA < lenB) {  
  7.             sign = '-';  
  8.         } else if (lenA == lenB) {  
  9. int i = lenA - 1;  
  10. while (i > 0 && a[i] == b[i]) {  
  11.                 i--;  
  12. if (a[i] < b[i]) {  
  13.                 sign = '-';  
  14. // 计算结果集,如果最终结果为正,那么就a-b否则的话就b-a  
  15. 0; i < len; i++) {  
  16. if (sign == '+') {  
  17.                 result[i] = aint - bint;  
  18.                 result[i] = bint - aint;  
  19. // 如果结果集合中的某一位小于零,那么就向前一位借一,然后将本位加上10。其实就相当于借位做减法  
  20. 0; i < result.length - if (result[i] < 0) {  
  21. 1] -= 1;  
  22.                 result[i] +=    
  23. // 如果最终结果为负值,就将负号放在最前面,正号则不需要  
  24. if (sign == '-') {  
  25.             sb.append('-');  
  26. // 判断是否有前置0  
  27. // 如果最终结果集合中没有值,就说明是两值相等,最终返回0  
  28. if (sb.toString().equals("")) {  
  29.             sb.append("0");  
  30. // 返回值  
  31.     }  

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


http://blog.csdn.net/lichong_87/article/details/6860329

版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 dio@foxmail.com 举报,一经查实,本站将立刻删除。

相关推荐