大数处理之一（加法和乘法）

今天看了两个大数处理的程序，一个是用JAVA 写的，一个是用C写的，处理的确实是挺方便的，虽然现在还没有学JAVA，但看起来感觉很强大，下面把JAVA 代码贴出来，学习一下：

import java.math.BigInteger;
import java.util.Scanner;

class Main {
	public static void main(String args[]) {
		Scanner s = new Scanner(System.in);
		BigInteger zero = BigInteger.valueOf(0);
		BigInteger sum = BigInteger.valueOf(0);
		for(;;) {
			BigInteger b = s.nextBigInteger();
			if(b.equals(zero)) break;
			sum = sum.add(b);
		}
		System.out.println(sum.toString());
	}
}

 短短几行就把这个问题解决了；

下面介绍一下如何使用C来解决大数问题：

大数长度最长为 L ；

定义一个字符数组  s[ L ] ;

定义一个整形数组 a[ L ] ;

定义一个求和的数组　sum[ L ] ;

输入大数到 字符数组 S 中 ，从 S 的最后一个字符开始 把 S[ len - 1 ] - '0' 赋值给 a[ 0 ] ，这样循环下去，使得S中的字符变成整型，并倒续存入整型数组a中，让a中的每个数值与相应的sum中的每个字符相加，和存入sum中；

对sum进行处理，sum[k+1] += sum[k] / 10 ;    sum[k] = sum[k] % 10 ;

倒续输出sum中的数值（前序为0的除外）

详细代码如下：

#include<iostream>
#include<string>
#include<stdio.h>
#include<string.h>
using namespace std ;
int main()      {
        char s[100] ;
        int sum[101] = {0} ;
        while(cin >> s && strcmp(s,"0"))        {
                int a[101] = {0} ;
                int len = strlen(s) ;
                int t = 100 ;
                for(int i = len - 1 ; i >= 0 ; i--)
                        a[t--] = s[i] - '0' ;
                for(int j = 100 ; j >= 0 ; j--)
                        sum[j] += a[j] ;
                for(int k = 100 ; k>= 1; k--)   {
                        sum[k-1] += sum[k] / 10 ;
                        sum[k] = sum[k] % 10 ;
                }
        }
        int start = 0 ;
        while(start <= 99 && !sum[start])
                start++ ;
        while(start<=100)
                cout << sum[start++] ;
        cout << endl ;
        return 0 ;
}

 上面只是大数相加，如果存在大数相乘，该如何处理呢？能不能用相同的方法解决？

举个例子  123 * 12 我们应该怎样用上述方法实现呢？

123

* 12定义一个数组为 sum[5] ;

sum[4] = 2 * 3 ;

sum[3] = 2 * 2 ;

sum[2] = 2 * 1 ;

sum[1] = 0 ;

sum[0] = 0 ;

sum[4] = sum[4] + 1 * 3 ;

sum[3] = sum[3] + 1 * 2 ;

sum[2] = sum[2] + 1 * 1 ;

sum[1] = sum[1] + 0 ;

sum[0] = sum[0] + 0 ;

这样就把 sum 数组给确定了；

再运用上面的方法即可解决此题；

思维决定程序的效率 啊 ！！！

下面给出相应的代码 ：

#include<iostream>
#include<string>
#include<string.h>

using namespace std ;

int main()      {
        char s1[1000] , s2[1000] ;
        while(cin >> s1 >> s2)  {
        int sum[1001] = {0} ;
                int len1 = strlen(s1) ;
                int len2 = strlen(s2) ;
                for(int i = len2 - 1 ; i >= 0 ; i--)
                        for(int j = len1 - 1 , p = 1000 - (len2 - 1 - i) ; j >= 0 ; j--)
                                sum[p--] += ( (s2[i] - '0') * (s1[j] - '0') ) ;
                for(int k = 1000 ; k >= 0 ; k--)        {
                        sum[k-1] += sum[k] / 10 ;
                        sum[k] = sum[k] % 10 ;
                }
                int start = 0 ;
                while(start <= 999 && !sum[start])
                        start++ ;
                while(start <= 1000)
                        cout << sum[start++] ;
                cout << endl ;
        }
        return 0 ;
}

 同时可以用JAVA来实现，肯定是方便多了：

import java.util.Scanner;
import java.math.BigInteger;

class Main {
	public static void main(String args[]) {
		Scanner in = new Scanner(System.in);
		while(in.hasNext()) {
			BigInteger a = in.nextBigInteger();
			BigInteger b = in.nextBigInteger();
			System.out.println(a.multiply(b).toString());
		}
	}
}