大数相乘、相加、相减、相除

  1 package com.bignumber.test;
  2 
  3 /**
  4  * 大数运算(+、-、*、/)
  5  * @author chen
  6  *
  7  */
  8 public class BigNumber {
  9 
 10     public static void main(String[] args) {
 11 
 12         String str1 = "123456789";//大数一
 13         String str2 = "9876543210";//大数二
 14         //得到大数的长度
 15         int len1 = str1.length();
 16         int len2 = str2.length();
 17         //高低位转化
 18         str1 = new StringBuffer(str1).reverse().toString();
 19         str2 = new StringBuffer(str2).reverse().toString();
 20         //将大数转换成数组
 21         char[] s1 = str1.toCharArray();
 22         char[] s2 = str2.toCharArray();
 23         
 24         //大数相乘
 25         multiply(s1, len1, s2, len2);
 26         //大数相加
 27         sum(s1, len1, s2, len2);
 28         
 29     }
 30     
 31     /**
 32      * 大数相乘
 33      * 
 34      *     原理：两数相乘的结果长度不会超过两个数的长度之和------例如：一个4位数和一个7位数相乘，结果长度一定不会超过
                    11(4+7)位
 35      *          两个数从个位开始从0存入数组，两个数分别存为a[i]、b[j]，则a[i]*a[j]相乘的结果一定在c[i+j]中。
 36      *          将所有i+j相等的数组乘积相加再加上进位即为该位的数值(大于9，取余数)
 37      *          eg.   78 * 96 = 7488 
 38      *          分析：  a[0] = 8    a[1] = 7;
 39      *                 b[0] = 6    b[1] = 9;   结果存入c[2 + 2],即c[4]
 40      *                 
 41      *                 a[0] * b[0] = c[0 + 0] = 48
 42      *                 a[1] * b[0] = c[0 + 1] = 42
 43      *                 a[0] * b[1] = c[0 + 1] = 72
 44      *                 a[1] * b[1] = c[1 + 1] = 63
 45      *              
 46      *          得：    c[0] = 48 >= 10 , 则 结果取余数8，进4，即[0] = 8
 47      *                 c[1] = 42 + 72 + 4(低位的进位) = 118 >= 10 , 结果取余8，进11，即c[1] = 8
 48      *                 c[2] = 63 + 11(低位的进位) = 74 >= 10 , 结果取余4，进7，即c[2] = 4
 49      *                 c[3] = 0 + 7(低位的进位) = 7 < 10 , 即c[3] = 7
 50      *       
 51      *       倒序输出结果： c[3]c[2]c[1]c[0] = 7488
 52      * 
 53      * @param s1
 54      *                     大数一
 55      * @param len1
 56      *                     大数一的长度
 57      * @param s2
 58      *                     大数二
 59      * @param len2
 60      *                     大数二的长度
 61      */
 62     private static void multiply(char[] s1, int len1, char[] s2, int len2){
 63         
 64         //得到结果的最大长度
 65         int len3 = len1 + len2;
 66         //开辟乘积数组，存储乘积结果
 67         int[] sum = new int[len3];
 68         //初始化，将每个位置的初始值都置为0
 69         for(int i = 0; i < len3; i++){
 70             sum[i] = 0;
 71         }
 72         //逐位相乘
 73         for(int i = 0; i < len1; i++){
 74             for(int j = 0; j < len2; j++){
 75                 sum[i + j] += (s1[i] - ‘0‘) * (s2[j] - ‘0‘);
 76             }
 77         }
 78         int temp = 0;//临时存储进位
 79         //进位处理
 80         for(int i = 0; i < len3; i++){
 81             sum[i] += temp;
 82             if(sum[i] >= 10){
 83                 temp = sum[i] / 10;
 84                 sum[i] %= 10;
 85             }else{
 86                 temp = 0;
 87             }
 88         }
 89         int mlen = len3;
 90         //找到最高位
 91         for(int i = len3 - 1; i >= 0; i--){
 92             if(sum[i] > 0){
 93                 break;
 94             }
 95             mlen--;
 96         }
 97         //倒序打印结果
 98         StringBuffer sb = new StringBuffer();
 99         for(int i = mlen - 1; i >= 0; i--){
100             sb.append(sum[i]);
101         }
102         System.out.println("大数相乘的结果为：" + sb.toString());
103         
104     }
105     
106     /**
107      * 大数相加
108      * 
109      *     原理：和大数相乘相似，不同在于相加后的结果长度不超过两数最大长度加一。
110      *          将两数相同位置的数相加即为该位置的结果，然后进行进位处理即可。
111      * 
112      * @param s1
113      *                     大数一
114      * @param len1
115      *                     大数一的长度
116      * @param s2
117      *                     大数二
118      * @param len2
119      *                     大数二的长度
120      */
121     private static void sum(char[] s1, int len1, char[] s2, int len2){
122         
123         //得到结果的最大长度
124         int len3 = len1 > len2 ? len1 : len2;
125         int[] sum = new int[len3];
126         //初始化，各位置0
127         for(int i = 0; i < len3; i++){
128             sum[i] = 0;
129         }
130         //逐位相加
131         for(int i = 0; i < len3; i++){
132             int a = i > len1 - 1 ? 0 : s1[i] - ‘0‘;
133             int b = i > len2 - 1 ? 0 : s2[i] - ‘0‘;
134             sum[i] = a + b;
135         }
136         int temp = 0;//存储临时进位
137         //进位处理
138         for(int  i = 0; i < len3; i++){
139             sum[i] += temp;
140             if(sum[i] >= 10){
141                 temp = sum[i] / 10;
142                 sum[i] %= 10;
143             }else{
144                 temp = 0;
145             }
146         }
147         //得到结果的最大长度
148         int mlen = len3;
149         for(int i = len3 - 1; i >= 0; i--){
150             if(sum[i] > 0){
151                 break;
152             }
153             mlen--;
154         }
155         //输出结果
156         StringBuffer sb = new StringBuffer();
157         for(int i = mlen - 1; i >= 0 ; i--){
158             sb.append(sum[i]);
159         }
160         System.out.println("两个大数相加的结果为：" + sb.toString());
161         
162     }
163     
164 }