大整数乘法——算法思想及java实现

参考了：

http://blog.csdn.net/oh_maxy/article/details/10903929

但是该博主的实现并没有考虑时间效率，在博主代码的基础上了做了一点点改进，提高了时间效率。（由原来的O(n2)提高到O(n1.59)）

感谢博主提供的代码。最后附上我改进的版本。

package algrithm.divideAndConquer;

import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 分治法例子：
 * 大整数乘法
 * @author tcj
 *
 */
public class TwoBigIntegerMiltiply {
		private final static int SIZE = 4;
		//进制，这里处理输入10进制的大整数（在减法函数里面用到）
		private final static int Dec = 10;
	
		//自己第一次写的，思路不清晰
/*		public static boolean IsInteger(Object obj){
			return (obj instanceof Integer);
		}
		
		public static int[] BigIntegerMlt(int[] a,int[] b,int beginA,int endA,int beginB,int endB){
			//如果输入为空
			if(a == null || b == null){
				return null;
			}
			//如果a,b或者元素为小数
			
			//如果a,b中有元素为负数
			int[] result = null;
			
			return result;
		}	*/	
		
		private static String BigIntegerMultiply(String X,String Y){
			//最终返回结果
			String  str = "";
			int len1 = X.length();
			int len2 = Y.length();
			int len = Math.max(len1, len2);
			//补齐X、Y,使之长度相同
			X = formatNum(X,len);
			Y = formatNum(Y,len);
			
			//少于4位数，可直接计算
			if(len <= SIZE){
				return "" + (Integer.parseInt(X) * Integer.parseInt(Y));
			}
			
			int len3 = len/2;
			int len4 = len - len3;
			
			//处理乘数，分块处理
			String A = X.substring(0,len3);
			String B = X.substring(len3);
			String C = Y.substring(0,len3);
			String D = Y.substring(len3);
			
			//递归求解分块
			int lenM = Math.max(len3, len4);
			String AC = BigIntegerMultiply(A,C);
			String BD = BigIntegerMultiply(B,D);
			//提高时间效率关键在这一步：
			//将AC+BD --> (A-B)(D-C)+AC+BD
			//这样仅需做3次n/2位整数的乘法，减少了一次
			//之前的总时间T(n) = 4T(n/2) +　O(n) --> O(n2)
			//现在的总时间T(n) = 3T(n/2) + O(n) --> O(n1.59)
			String AMinusB  = minus(A,B);
			String DMinusC = minus(D,C);
			String ABDC = BigIntegerMultiply(AMinusB,DMinusC);
			ABDC = addition(addition(ABDC,AC),BD);
			
			//处理BD,得到原位及进位
			String[] sBD = dealString(BD,len3);
			
			//加上BD的进位
			if(!"0".equals(sBD[1])){
				ABDC = addition(ABDC,sBD[1]);
			}
			
			//处理ABDC,得到原位及进位
			String[] sABDC = dealString(ABDC,len3);
			
			//AC加上ADBC的进位
			if(!"0".equals(sABDC[1])){
				AC = addition(AC,sABDC[1]);
			}
			

			//最终结果
			str = AC + sABDC[0] + sBD[0];	
			
			//之前写错了，下面是处理二进制大整数的算法
//			String temp1 = "" + (Integer.parseInt(AC) >> len);
//			String temp2 = "" + (Integer.parseInt(ABDC) >> len3);
//			String temp3 = "" + (Integer.parseInt(AC) >> len3) ;
//			String temp4 = "" + (Integer.parseInt(BD) >> len3) + BD;
//			String temp1 = BigIntegerMultiply(AC,expOfTwo(len));
//			String temp2 = BigIntegerMultiply(ABDC,expOfTwo(len3));
//			String temp3 = BigIntegerMultiply(AC,expOfTwo(len3));
//			String temp4 = BigIntegerMultiply(BD,expOfTwo(len3));
//			String temp5 = addition(temp1,temp2);
//			String temp6 = addition(temp3,temp4);
			//最终结果
//			str = addition(temp5,temp6);
			return str;
			
		}
		
		private static String