[Java]模拟实现大整数类

最新推荐文章于 2022-05-20 11:19:33 发布
最新推荐文章于 2022-05-20 11:19:33 发布
阅读量3.2k 收藏 18
点赞数 9
分类专栏： Java 文章标签： 大整数 分治 高精度
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CristianoJason/article/details/51145572
版权

一、解决问题：


    实现长整数类BigInt, 支持任意精度的整数及其运算.


二、数据结构：


public class BigInt {
private int length;
         private boolean pn; //positiveor negative. + is true, - is false
         private String value;
}

         其中字符串value为该大整数的绝对值，length存储该绝对值的位数，pn记录该大整数的符号。这样有利于解决正负数问题，所有大整数在操作时可以直接对value进行，最后统一考虑得到结果的符号。


三、具体方法：


1.        无参数构造函数BigInt()


BigInt() {
		this.length = 1;
		this.pn = true;
		this.value = "0";
	}



2.        带有字符串的构造函数BigInt(String s)

a)        通过私有方法isLegal(s)对参数进行合法性判断；

b)        判断该字符串是否带有符号，设置其符号pn；

c)        通过私有方法findStartPos(s)寻找字符串真正有意义的最高位；

d)        将最高位之后的所有字符存入value中，并在length中记录该value的长度；

e)        对0做特殊处理。


BigInt(String s) {
		//assert isLegal(s);
		if (isLegal(s)) {
			if (s.charAt(0)=='+' || s.charAt(0)=='-') {
				this.pn = s.charAt(0)=='+' ? true:false;
			}
			else {
				this.length = s.length();
				this.pn = true;
			}
			int sp = findStartPos(s);
			this.value = s.substring(sp);
			this.length = s.length()-sp;
			if (this.value.charAt(0) == '0') {
				this.pn = true;
				this.length = 1;
				this.value = "0";
			}
		}
		else {
			System.out.println("This BigInt is not legal!");
		}
	}



3.        BigInt转字符串publicString toString()


由于数据结构中将符号位与数据位分离，所以在输出时只需要考虑在符号位pn==false时在value前加上负号即可。


public String toString() {
		if (pn == false) {
			return "-" + value;
		}
		return value;
	}


4.        大整数比较是否相等public boolean equals(BigInt x)


与toString()类似，比较两个大整数的符号位和数据位是否相等即可。需要注意的是在数据位比较时要用equals()，直接使用等号比较的是引用的值而非真实数据。


public boolean equals(BigInt x) {
		if (this.pn==x.pn && this.length==x.length && this.value.equals(x.value)) {
			return true;
		}
		return false;
	}



5.        大整数比较大小public int compare(BigInt x)

大于返回1，等于返回0，小于返回-1.

a)        直接通过符号位pn不同时比较两个数的大小；

b)        符号相同时，借助长度不同比较两个数的大小，正数长度大的大，负数长度小的大；

c)        符号长度都相同时，借助compareTo比较两个数的value，正数返回compareTo的结果对应点1和-1，负数返回compareTo结果的相反数的-1和1。


public int compare(BigInt x) {
		if (this.pn != x.pn) {
			return this.pn==true ? 1:-1;
		}
		if (this.length!=x.length) {
			if (this.pn) {
				return this.length>x.length ? 1:-1;
			}
			else {
				return this.length<x.length ? 1:-1;
			}
		}
		int tmp = this.value.compareTo(x.value);
		if (this.pn) {
			tmp *= -1;
		}
		if (tmp > 0) {
			return -1;
		}
		if (tmp < 0) {
			return 1;
		}
		return tmp;
	}



6.        大整数加法public BigInt add(BigInt x)

对于加法操作，只考虑符号位相同的情况，将符号位不同的情况丢给减法。


a)        对0做特殊处理，返回另一个数，注意是创建一个新的大整数进行返回，如new BigInt(this.toString())；

b)        如果两个数符号位不同，则创建x的备份xx，并使用私有方法changePN()改变xx的符号位，计算this-xx，将结果返回；

c)        创建两个字符串bigger和smaller，分别记录数据位较大的数据位和较小数的数据位；

d)        模拟加法操作：用bigger和smaller从最低位按位进行加法操作，借助私有方法charAdd()按位加，结果记录在字符串ans中；并通过carryValue来记录当前按位加结果是否得到进位，如果有进位，则在下一位加法操作时需要将carryValue加入按位加操作中，否则将其清零；

ans[i] =bigger[bigger.length-i]+smaller[smaller.length-i]+carryValue

e)        当smaller的最高位加完后，需要对bigger多出的高位继续与carryValue进行按位加；

f)         判断最高位是否产生进位，如果产生则补充一个最高位1；

g)        将ans进行反转操作，用其构造大整数，并将其符号位置为this的符号位。

	public BigInt add(BigInt x) {
		if (x.value.equals("0")) {
			return new BigInt(this.toString());
		}
		if (this.value.equals("0")) {
			return new BigInt(x.toString());
		}
		if (this.pn != x.pn) {
			BigInt xx = new BigInt(x.toString());
			xx.changePN();
			return this.substract(xx);
		}
		String bigger, smaller;
		if ((this.compare(x)>=0&&this.pn)||(this.compare(x)<0&&!this.pn)) {
			bigger = new String(this.value);
			smaller = new String(x.value);
		}
		else {
			bigger = new String(x.value);
			smaller = new String(this.value);
		}
		String tmpAns = new String();
		int carryValue = 0;
		for (int i = 1; i <= smaller.length(); i++) {
			int tmpAdd = charAdd(bigger.charAt(bigger.length()-i), smaller.charAt(smaller.length()-i)) + carryValue;
			carryValue = tmpAdd>=10 ? 1:0;
			tmpAns += String.valueOf(tmpAdd-carryValue*10);
		}
		int pos = bigger.length()-smaller.length()-1;
		while(carryValue!=0 && pos>=0) {
			int tmpAdd = charAdd(bigger.charAt(pos), '1');
			carryValue = tmpAdd>=10 ? 1:0;
			tmpAns += String.valueOf(tmpAdd-carryValue*10);
			pos--;
		}
		String ans = new String();
		tmpAns = reverse(tmpAns);
		if (carryValue == 0) {
			ans = bigger.substring(0, Math.max(pos+1, 0))+tmpAns;
		}
		else if (pos < 0) {
			ans = "1"+tmpAns;
		}
		if (!this.pn) {
			ans = "-"+ans;
		}
		return new BigInt(ans);
	}


7.        大整数减法操作public BigInt substract(BigInt x)

类似加法，只考虑符号位相同的情况，将符号位不同的情况丢给加法；接下来只介绍模拟减法的操作。

tmpSub= charSub(bigger[bigger.length()-i], smaller[smaller.length()-i], carryValue);


public BigInt substract(BigInt x) {
		if (x.value.equals("0")) {
			return new BigInt(this.toString());
		}
		else if (this.value.equals("0")) {
			BigInt ans = new BigInt(x.toString());
			ans.changePN();
			return ans;
		}
		if (this.pn != x.pn) {
			BigInt xx = new BigInt(x.toString());
			xx.changePN();
			return this.add(xx);
		}
		String bigger, smaller;
		boolean tag = this.compare(x)>=0 ? true:false;
		if ((this.compare(x)>=0&&this.pn)||(this.compare(x)<=0&&!this.pn)) {
			bigger = new String(this.value);
			smaller = new String(x.value);
		}
		else {
			bigger = new String(x.value);
			smaller = new String(this.value);
		}
		String tmpAns = new String();
		int carryValue = 0;
		for (int i = 1; i <= smaller.length(); i++) {
			int tmpAdd = charSub(bigger.charAt(bigger.length()-i), smaller.charAt(smaller.length()-i), carryValue);
			carryValue = tmpAdd<0 ? 1:0;
			if (tmpAdd == -100) {
				carryValue = 1;
				tmpAdd = 0;
			}
			tmpAns += String.valueOf(Math.abs(tmpAdd));
		}
		int pos = bigger.length()-smaller.length()-1;
		while(carryValue!=0 && pos>=0) {
			int tmpAdd = charSub(bigger.charAt(pos), '0', carryValue);
			carryValue = tmpAdd<0 ? 1:0;
			tmpAns += String.valueOf(Math.abs(tmpAdd));
			pos--;
		}
		String ansStr = new String();
		tmpAns = reverse(tmpAns);
		if (carryValue == 0) {
			ansStr = bigger.substring(0, Math.max(pos+1, 0))+tmpAns;
		}
		BigInt ans = new BigInt(ansStr);
		ans.pn = tag;
		return ans;		
	}

         其中私有方法charSub():

         

private int charSub(char x, char y, int c) {
		int ans = x + 10 - c - y;
		if (ans < 10) {
			if (ans == 0) {
				ans = 100;
			}
			return ans*(-1); // there is a negative zero problem
		}
		return ans-10;
	}

         为了解决参数为0, 9,1这样的负0问题，将该结果置为-100返回做特殊处理。


8.        大整数乘法操作public BigInt multiply(BigInt x)


采用分治的思想，设两个数分别为M1, M2，长度为均为l。可将其表示为：

M1 = AB，A为前l/2长度的数据位，B为后l-l/2长度的数据位；

M2 = CD，C为前l/2长度的数据位，D为后l-l/2长度的数据位；

于是M1*M2可表示为

M1*M2 = A*C*(10^((l-l/2)*2)) + B*D + ((A-B)*(D-C)+A*C+B*D) *(10^(l-l/2))

但是无法保证两个数数据位长度均为l，故需要将数据位短的前面补零补齐l位。之所以采取这样的方法是因为原本的乘法操作分解之后仍为四次乘法，而采取上式得乘法操作分解之后只需三次乘法操作，时间复杂度降为O(l^log(3))。


public BigInt multiply(BigInt x) {
		if (x.value.equals("0") || this.value.equals("0")) {
			return new BigInt();
		}
		boolean ansPN = !(this.pn ^ x.pn);
		if (x.length == 1 && this.length == 1) {
			int ians = Integer.parseInt(x.value)*Integer.parseInt(this.value);
			BigInt ans = new BigInt(String.valueOf(ians));
			ans.setPN(ansPN);
			return ans;
		}
		String a = this.value, b = x.value;
		/**********Unify Length**********/
		int len1 = Math.max(a.length(), b.length())-a.length();
		int len2 = Math.max(a.length(), b.length())-b.length();
		for (int i = 0; i < len1; i++) {
			a = "0" + a;
		}
		for (int i = 0; i < len2; i++) {
			b = "0" + b;
		}
		BigInt a1 = new BigInt(a.substring(0, a.length()/2));
		BigInt a2 = new BigInt(a.substring(a.length()/2));
		BigInt b1 = new BigInt(b.substring(0, b.length()/2));
		BigInt b2 = new BigInt(b.substring(b.length()/2));
		BigInt ans1 = a1.multiply(b1);//a1*b1
		BigInt ans2 = a2.multiply(b2);//a2*b2
		BigInt sub1 = a1.substract(a2);
		BigInt sub2 = b2.substract(b1);
		BigInt ans3 = sub1.multiply(sub2);//(a1-a2)(b2-b1)
		ans3 = ans3.add(ans1);
		ans3 = ans3.add(ans2);
		String tmp = ans1.value;
		for (int i = 0; i < (a.length()-a.length()/2)*2; i++) {
			tmp += "0";
		}
		ans1 = new BigInt(tmp);
		tmp = ans3.value;
		for (int i = 0; i < (a.length()-a.length()/2); i++) {
			tmp += "0";
		}
		if (!ans3.pn) {
			tmp = "-"+tmp;
		}
		ans3 = new BigInt(tmp);
		BigInt ans = ans1.add(ans3).add(ans2);
		ans.setPN(ansPN);
		return ans;
	}


9.        大整数除法操作public BigInt divide(BigInt x)（除数非0）


a)        判断除数的数据位是否大于被除数的数据位，如果大于，返回0；

b)        在x后补零，使得x变为不大于this的最大补零数，记补了cnt个0，为方便操作，相当于x*addZero，addZero=100…00，其中有cnt个0；

c)        初始化商quotient为0；

d)        LOOP1：循环cnt次；

e)        LOOP2：每次计算this-x，this = this-x，quotient = quotient+addZero，直到this<x；

f)         将addZero和x末尾去掉一个零，转LOOP1；

g)        将商的符号位置位为this和x的符号位的异或。


public BigInt divide(BigInt x) {
		boolean ansPN = !(this.pn ^ x.pn);
		if (x.toString().equals("0")) {
			System.out.println("The divider cannot be 0!");
			BigInt ans = new BigInt("1");
			ans.setPN(ansPN);
			return ans;
		}
		if (unsignedCompare(x) < 0) {
			return new BigInt("0");
		}
		String a = this.value, b = x.value, addZero = new String("1");
		int cnt = a.length()-b.length();
		for (int i = 0; i < cnt; i++) {
			b += "0";
			addZero += "0";
		}
		BigInt divA = new BigInt(a), divB = new BigInt(b);
		BigInt quotien = new BigInt("0");
		while(cnt >= 0) {
			BigInt addBI = new BigInt(addZero);
			while(divA.compare(divB) >= 0) {
				quotien = quotien.add(addBI);
				divA = divA.substract(divB);
			}
			divB = new BigInt(divB.value.substring(0, Math.max(1,divB.value.length()-1)));
			addZero = addZero.substring(0, Math.max(1,cnt));
			cnt--;
		}
		quotien.setPN(ansPN);
		return quotien;
	}

10.    大整数取余操作public BigInt mod(BigInt x)


a)        调用this.divid(x)得到商q；

b)        调用q.multiply(x)得到积tmp；

c)        返回this.substract(tmp).


public BigInt mod(BigInt x) {
		BigInt tmp = this.divide(x);
		tmp = tmp.multiply(x);
		return this.substract(tmp);
	}


11.    阶乘操作public static BigInt factorial(BigInt x)：


递归调用x.multiply(factorial(x.substract(ONE)))即可；


public BigInt factorial(BigInt x) {
		if (!x.equals(ZERO)) {
			return x.multiply(factorial(x.substract(ONE)));
		}
		return new BigInt("1");
	}


12.    指数函数public static BigInt expo(BigInt x)：


递归调用TWO.multiply(expo(x.substract(ONE)))即可；


public BigInt expo(BigInt x) {
		if (!x.equals(ZERO)) {
			return TWO.multiply(expo(x.substract(ONE)));
		}
		return new BigInt("1");
	}


四、私有方法和常量：


常量：

public static final BigInt ZERO = new BigInt();
public static final BigInt ONE = new BigInt("1");
public static final BigInt TWO = new BigInt("2");


私有方法： 


private int unsignedCompare(BigInt x) {//无符号比较
		BigInt a = new BigInt(this.value);
		BigInt b = new BigInt(x.value);
		return a.compare(b);
	}
	private String reverse(String s) {//字符串反转
		StringBuffer sb = new StringBuffer(s);
		return sb.reverse().toString();
	}
	private int charAdd(char x, char y) {//字符加
		return x + y - '0' - '0';
	}
	private int charSub(char x, char y, int c) {//字符减
		int ans = x + 10 - c - y;
		if (ans < 10) {
			if (ans == 0) {
				ans = 100;
			}
			return ans*(-1); // there is a negative zero problem
		}
		return ans-10;
	}
	private void changePN() {//符号位反转
		this.pn = this.pn==true ? false:true;
		if (this.value.charAt(0) == '0') {
			this.pn = true;
		}
	}
	private void setPN(boolean targetPN) {//设置符号位
		this.pn = targetPN;
	}
	private int findStartPos(String s) {//寻找字符串规范起始位置
		for (int i = 0; i < s.length(); i++) {
			if (Character.isDigit(s.charAt(i)) && s.charAt(i)!='0') {
				return i;
			}
		}
		return s.length()-1;//this is a zero!
	}
	private boolean isLegal(String s) {//构造函数中判断字符串是否合法
		if (s == null || ((s.length()==1)&&(!Character.isDigit(s.charAt(0)))) || ((s.length()>1)&&(s.charAt(0)!='+')&&(s.charAt(0)!='-')&&(!Character.isDigit(s.charAt(0))))) {
			return false;
		}
		for (int i = 1; i < s.length(); i++) {
			if (!Character.isDigit(s.charAt(i))) {
				return false;
			}
		}
		return true;
	}


CristianoJason
关注
  • 9
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
大二的java实验
zhang__liuchen的博客
05-16 7810
这里会附上我的仓库，进去下载我的 java实验_self,这个我写的实验，戳我到仓库地址java实验上到实验7，包括实验7，后边的没时间了，感觉还是有时间的话，自己学完吧，希望这些能帮到你！！！（我给出实验要求，一样的可以参考我的。）Java 上机实验指导上机实践1 初识Java.......................................................
Java大整数类的设计及其实现
kunlong0909的专栏
01-10 7048
1.1 概述 BigInteger类的开发者是Josh Bloch和Michael McCloskey。 Java大整数类BigInteger继承于Number类并实现了Comparable接口,完全按照面向对象思想构建，因为Java语言没有在C++中编程实现运算符重载的概念，所以Java的BigInteger类是通过提供函数来实现各种大整数运算的。 BigInteger类为所有的Java原
java大数计算
luoxutimberjack的博客
11-24 284
package c5; import java.util.Scanner; import java.lang.Math; public class DateTest { public static void main(String args[]){ Scanner cin = new Scanner(System.in); //以文件EOF结束\ BigInteger a,b; while (cin.hasNext()){
JAVA 大整数类
ninesun的博客
05-19 730
今天Java刚刚学习了大整数类，贴一篇非常简单的大整数类求阶乘的代码 package big; import java.math.BigInteger; public class factoria { public static void main(String[] args) { // TODO Auto-generated method stub BigIntege
大整数类C++实现（绝对可用）
06-30
大整数类C++实现（绝对可用）大整数类C++实现（绝对可用）大整数类C++实现（绝对可用）大整数类C++实现（绝对可用）大整数类C++实现（绝对可用）大整数类C++实现（绝对可用）大整数类C++实现（绝对可用）大整数类C++实现（绝对可用）
Java模拟计算机的整数乘积计算功能示例
08-29
"Java模拟计算机的整数乘积计算功能...通过本文，我们了解了Java模拟计算机的整数乘積计算功能的原理和实现方法，了解了计算机数值进制转换与通过位移进行乘积计算的原理。希望本文能够对大家java程序设计有所帮助。
Java实现蓝桥杯模拟正整数序列的数量
01-21
答案可能很大，请输出答案除以10000的余数。 样例输入 4 样例输出 7 样例说明 　以下是满足条件的序列： 　4 1 　4 1 1 　4 1 2 　4 2 　4 2 1 　4 3 　4 4 评测用例规模与约定 　对于 20% 的评测用例，1 <= n &...
Java蓝桥杯模拟正整数序列的数量
12-21
Java蓝桥杯模拟正整数序列的数量 问题描述 　小明想知道，满足以下条件的正整数序列的数量： 　1. 第一项为 n； 　2. 第二项不超过 n； 　3. 从第三项开始，每一项小于前两项的差的绝对值。 　请计算，对于给定的 n...
java源码包---java 源码 大量 实例
04-18
java模拟掷骰子2个 1个目标文件，输出演示。 java凭图游戏 一个目标文件，简单。 java求一个整数的因子 如题。 Java生成密钥的实例 1个目标文件 摘要:Java源码,算法相关,密钥 　Java生成密钥、保存密钥的实例源码...
java模拟掷骰子2个源码示例
05-16
本示例将深入探讨如何使用Java实现这一功能，同时也会涉及源码解析和软件开发的一些基础知识。 首先，Java中的`Random`类是生成随机数的核心工具。在模拟掷骰子时，我们通常会创建一个`Random`对象，然后调用其`...
java---自己实现超大整数的乘法
a823837282的博客
01-23 1135
今天看了一篇博客，它是先把每个位置加起来，最后再进行进位操作，数字够大后，存在溢出可能性。 链接如下：https://blog.csdn.net/baokx/article/details/39005159   注意： 计算较大的阶乘时，eclipse运行的话，前面的结果可以正常输出，后面较大的结果只会输出空白。我在命令行用javac编译运行，得到结果是正常的。   我在他的基础上改了...
java的整数类型_java整数类型
weixin_33400538的博客
03-02 1462
public class Test2_9 {public static void main(String args[]){//java有4种整数类型：byte,short,int,long//java的默认整数计算的结果是int类型//整数的字面量(即整形变量=号后面的那个值)是int类型//如果自面量超过Int型最大值，则字面量是long类型，后面要加l(不区分大小写)//输出int型的最大值-...
大整数运算包的实现（Java）(1) --加、减、乘、除、模取余、模加（考虑负数）
H_X_P_的博客
01-29 1575
大整数运算包的实现（Java）(1) --加、减、乘、除、模取余、模加（考虑负数）
JAVA大整数的使用
yo_bc的博客
05-02 3044
昨天做的博弈需要大精度整数，所以整理下BigDecimal的setScale方法用以处理小数点后的位数。 其实Java内置大数求精度具有超好的精确性(二分法求精度)。 setScale(1, BigDecimal.ROUND_DOWN) 直接删除多余的小数位，如1.23会变成1.2  setScale(1, BigDecimal.ROUND_UP) 存在多余的小数位就进位，1.23会
java 中如何处理大整数－java.BigInteger的使用
fengfeng043的专栏
04-15 4128
来源：http://blog.csdn.net/licongcong_0224/article/details/11137933当一个数字非常大时，则肯定无法用基本类型接收，所以最早碰到大数字时往往会使用String类进行接收，然后再采用String类进行接收，然后再采用拆分的方式进行计算，但操作非常麻烦，所以在Java中为了解决这样的难题提供了BigInteger类。BigInteger类表示大整
JAVA实现两个大数相加
静水流深
07-11 7783
public class BigIntAdd { private int[] array;//声明一个数组 //计算大数相加的函数 public static String bigAdd(BigIntAdd fisrtNum, BigIntAdd secondNum) { String result = ""; boolean falg = false;//判
Java大数类
lxzGood的博客
05-20 1569
Java大数类 如果基本的整数和浮点数不能够满足需求，那么就可以使用java.math包中很有用的两个类:BigInteger和BigDecimal。这两个类可以处理包含任意长度数字序列的数值。BigInteger类实现任意精度的整数运算，BigDecimal实现任意精度的浮点数的运算。 BigInteger BIgInteger add(BigInteger other) 加 BIgInteger substract(BigInteger other) 减 BIgInteger
Java实现大数操作
Akatsuki
07-22 1166
在ACM竞赛里难免会遇到一些大数（即超大数字！）的问题，但是对于ACMers来说，彼时还没有学过java，只会敲一手C/C++（比如我的大一），这篇博客就简单讲一下用java来实现大数的相关操作。 关于eclipse的使用，这里也捎带一提。 配置了jdk并安装好eclipse之后（什么？怎么配置jdk？当然要点这里了！（ubuntu系统）） 进入到eclipse界面 第一步：file-&g...
Java整数类型
Chen_006的博客
09-14 3792
Java整数类型：byte、short、int、long java 各整数类型有固定的表数范围和字段长度，不受具体 OS 的影响，以保证 Java 程序的可移植性。 java 的整型常量默认为 int 型，声明 long 型常量须加 ‘l’ 或 ‘L’ java 程序中变量通常声明为 int 型，除非不足以表达较大的数，才使用 long 类 型 占用存储空间 表数范围 byte...
java实验处理大整数的实验思路
最新发布
05-31
4. 如果需要进行高精度计算，可以使用Java中的BigInteger类，该类提供了大整数运算的各种方法，可以大大简化代码的实现。 5. 最后，可以通过编写测试用例来验证程序的正确性，比如验证加法、减法、乘法、除法的正确...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值