Java实现大整数相加

最新推荐文章于 2024-07-13 03:00:19 发布
最新推荐文章于 2024-07-13 03:00:19 发布
阅读量1w 收藏 8
点赞数 3
分类专栏： 数据结构之算法面试题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huberjobs/article/details/51036505
版权

在不使用BigInteger这个类的情况下，如何自己去实现两个超级大的数相加呢？

首先我们来看一下加法的原则: 1.同号相加，把两数相加，结果符号位取任意一个数的符号  

                                                    2.异号相加，取较大的数减去较小的数，结果符号位取较大的数的符号位

由于是超级大数，我们使用String来存储。首先要判断这两个大数的符号位，以及正确性（不能是0开头的数，也不能含有其它字母和符号）

/**
	 * 大整数求和
	 * 
	 * @param num1
	 * @param num2
	 * @return
	 */
	public static String bigNumberSum(String num1, String num2) {
		// 最后的符号
		char sign = '+';

		char sign1 = num1.charAt(0);
		char sign2 = num2.charAt(0);

		String number1 = "";
		String number2 = "";

		// 去符号位操作
		if (sign1 == '-' || sign1 == '+') {
			number1 = num1.substring(1);
		} else {
			sign1 = '+';
			number1 = num1;
		}
		// 去符号位操作
		if (sign2 == '-' || sign2 == '+') {
			number2 = num2.substring(1);
		} else {
			sign2 = '+';
			number2 = num2;
		}

		boolean isDig1 = number1.matches("[1-9][0-9]*");
		boolean isDig2 = number2.matches("[1-9][0-9]*");
		if (!isDig1 || !isDig2) {
			throw new NumberFormatException("输入的数据不是正确的整数");
		}

		return "";
	}
首先要知道的是两个数相加，结果的最大长度是两数最长的长度+1。所以我们用一个int[len]数组来存储各位相加的结果。 

		int length1 = number1.length();
		int length2 = number2.length();
		// 两数相加结果最长为求最长的数的长度+1
		int len = length1 > length2 ? length1 + 1 : length2 + 1;
		int[] result = new int[len];
为了从个位开始，我们需要对字符进行反转 

	char[] chars1 = new StringBuffer(number1).reverse().toString().toCharArray();
	char[] chars2 = new StringBuffer(number2).reverse().toString().toCharArray();


接着开始讨论一些情况，首先是同号相加。如果两个数的长度不一致，应该先以长度最短的数开始遍历相加，接着就是最长的数组剩下的那部分的值，因为超出部分不用相加。同号相加时会有进位的情况，最后一步 便是处理进位了。比如说99+2，2比99的长度短，所以以2的长度为临界点。result[0] = 2+9=11; 2已经遍历完了，所有剩下就是直接取值于99中剩下的位数。result[1] = 9; reuslt[0] = 11>=10所以result[0] = 11%10=1; 将进位提交到下一位result[0+1] = result[0+1] +1;以此类推，result[1] = 0, result[2] = 1；所以最终结果为101,符号为正，不做处理。 
boolean longerIs1 = length1 > length2 ? true : false;

		// 同号则直接相加
		if (sign1 == sign2) {
			sign = sign1;
			if (longerIs1) {
				for (int i = 0; i < length2; i++) {
					result[i] = (chars1[i] - '0') + (chars2[i] - '0');
				}
				for (int j = length2; j < length1; j++) {
					result[j] = (chars1[j] - '0');
				}
			} else {
				for (int i = 0; i < length1; i++) {
					result[i] = (chars1[i] - '0') + (chars2[i] - '0');
				}
				for (int j = length1; j < length2; j++) {
					result[j] = (chars2[j] - '0');
				}
			}
			// 处理进位
			for (int i = 0; i < len; i++) {
				if (result[i] >= 10) {
					result[i + 1] += result[i] / 10;
					result[i] = result[i] % 10;
				}
			}

		}
接着来讨论一个整数一个负数相加的情况。长度不等，拿长的数减去短的数，便于处理借位的情况。如果长度相等，这拿较大的数减去较小的。比如说2233，2100。通过String的compareTo方法比较，获取哪个数较大。当然啦，这里是相减，所以会出现借位的情况。所有最后要对借位进行处理。 

else {// 异号相加,如果length1>length2,拿长的数减去小的数
			if (longerIs1) {
				sign = sign1;
				for (int i = 0; i < length2; i++) {
					result[i] = (chars1[i] - '0') - (chars2[i] - '0');
				}

				for (int j = length2; j < length1; j++) {
					result[j] = chars1[j] - '0';
				}
			} else {
				if (length1 == length2) {
					// 拿大的数减去小的数
					boolean lager = number1.compareTo(number2)>0 ? true : false;
					if (lager) {
						sign = sign1;
						for (int i = 0; i < length1; i++) {
							result[i] = (chars1[i] - '0') - (chars2[i] - '0');
						}
					} else {
						sign = sign2;
						for (int i = 0; i < length1; i++) {
							result[i] = (chars2[i] - '0') - (chars1[i] - '0');
						}
					}
				} else {// length1<length2
					sign = sign2;
					for (int i = 0; i < length1; i++) {
						result[i] = (chars2[i] - '0') - (chars1[i] - '0');
					}

					for (int j = length1; j < length2; j++) {
						result[j] = chars2[j] - '0';
					}

				}
			}
			// 处理借位
			for (int i = 0; i < len; i++) {
				if (result[i] < 0) {
					result[i] += 10;
					result[i + 1]--;
				}
			}

		}

剩下的就是处理结果result数组了。因为长度是len>length1和length2,所以会有最高位是0的情况。比如说88+2=90，但是result的长度是3,所以result得到的结果是090，这不是我们想要的，应该把0去掉。 

// 结果没有进位时的0处理
		boolean flag = true;
		StringBuffer resultStr = new StringBuffer();

		for (int i = result.length - 1; i >= 0; i--) {
			if (result[i] == 0 && flag) {
				continue;
			}
			flag = false;
			resultStr.append(result[i]);
		}

		// 符号处理
		if (sign == '-') {
			return "-" + resultStr.toString();
		} else {
			return resultStr.toString();
		}

完整代码如下 

/**
	 * 大整数求和
	 * @param num1
	 * @param num2
	 * @return
	 */
	public static String bigNumberSum(String num1, String num2) {
		// 最后的符号
		char sign = '+';

		char sign1 = num1.charAt(0);
		char sign2 = num2.charAt(0);

		String number1 = "";
		String number2 = "";

		// 去符号位操作
		if (sign1 == '-' || sign1 == '+') {
			number1 = num1.substring(1);
		} else {
			sign1 = '+';
			number1 = num1;
		}
		// 去符号位操作
		if (sign2 == '-' || sign2 == '+') {
			number2 = num2.substring(1);
		} else {
			sign2 = '+';
			number2 = num2;
		}

		boolean isDig1 = number1.matches("[1-9][0-9]*");
		boolean isDig2 = number2.matches("[1-9][0-9]*");
		if (!isDig1 || !isDig2) {
			throw new NumberFormatException("输入的数据不是正确的格式的整数");
		}

		char[] chars1 = new StringBuffer(number1).reverse().toString().toCharArray();
		char[] chars2 = new StringBuffer(number2).reverse().toString().toCharArray();

		int length1 = number1.length();
		int length2 = number2.length();
		// 两数相加结果最长为求最长的数的长度+1
		int len = length1 > length2 ? length1 + 1 : length2 + 1;
		int[] result = new int[len];

		boolean longerIs1 = length1 > length2 ? true : false;

		// 同号则直接相加
		if (sign1 == sign2) {
			sign = sign1;
			if (longerIs1) {
				for (int i = 0; i < length2; i++) {
					result[i] = (chars1[i] - '0') + (chars2[i] - '0');
				}
				for (int j = length2; j < length1; j++) {
					result[j] = (chars1[j] - '0');
				}
			} else {
				for (int i = 0; i < length1; i++) {
					result[i] = (chars1[i] - '0') + (chars2[i] - '0');
				}
				for (int j = length1; j < length2; j++) {
					result[j] = (chars2[j] - '0');
				}
			}
			// 处理进位
			for (int i = 0; i < len; i++) {
				if (result[i] >= 10) {
					result[i + 1] += result[i] / 10;
					result[i] = result[i] % 10;
				}
			}

		} else {// 异号相加,如果length1>length2,拿长的数减去小的数
			if (longerIs1) {
				sign = sign1;
				for (int i = 0; i < length2; i++) {
					result[i] = (chars1[i] - '0') - (chars2[i] - '0');
				}

				for (int j = length2; j < length1; j++) {
					result[j] = chars1[j] - '0';
				}
			} else {
				if (length1 == length2) {
					// 拿大的数减去小的数
					boolean lager = number1.compareTo(number2)>0 ? true : false;
					if (lager) {
						sign = sign1;
						for (int i = 0; i < length1; i++) {
							result[i] = (chars1[i] - '0') - (chars2[i] - '0');
						}
					} else {
						sign = sign2;
						for (int i = 0; i < length1; i++) {
							result[i] = (chars2[i] - '0') - (chars1[i] - '0');
						}
					}
				} else {// length1<length2
					sign = sign2;
					for (int i = 0; i < length1; i++) {
						result[i] = (chars2[i] - '0') - (chars1[i] - '0');
					}

					for (int j = length1; j < length2; j++) {
						result[j] = chars2[j] - '0';
					}

				}
			}
			// 处理借位
			for (int i = 0; i < len; i++) {
				if (result[i] < 0) {
					result[i] += 10;
					result[i + 1]--;
				}
			}

		}

		// 结果没有进位时的0处理
		boolean flag = true;
		StringBuffer resultStr = new StringBuffer();

		for (int i = result.length - 1; i >= 0; i--) {
			if (result[i] == 0 && flag) {
				continue;
			}
			flag = false;
			resultStr.append(result[i]);
		}

		// 符号处理
		if (sign == '-') {
			return "-" + resultStr.toString();
		} else {
			return resultStr.toString();
		}

	}
在我写完上面的代码时，回头去看瞬间懵比了。那么多的if else，要看好久才能看懂这些逻辑啊。要是面试官看到这些代码，估计机会都不给了。所以打算改进一下逻辑，让整体的代码结构更加清晰易懂。从头分析一遍，我们的思路，我们可以发现同号异号这两种情况是必然要判断的，我们的代码主要用在了什么方面呢。我猜你应该发现了吧，大量的代码用来处理两个数的长度不一致的情况了。我们可以看到当它们的长度相等的时候，只需要执行一个for循环即可。 

if (length1 == length2) {
<span style="white-space:pre">	</span>// 拿大的数减去小的数
	boolean lager = number1.compareTo(number2)>0 ? true : false;
	if (lager) {
		sign = sign1;
		for (int i = 0; i < length1; i++) {
		<span style="white-space:pre">	</span>result[i] = (chars1[i] - '0') - (chars2[i] - '0');
		}
	} else {
		sign = sign2;
		for (int i = 0; i < length1; i++) {
		<span style="white-space:pre">	</span>result[i] = (chars2[i] - '0') - (chars1[i] - '0');
		}
	}
}

加入相加的两个数"一开始"就是长度相等的，那么我们也不许要搞那么多的事情了，逻辑会更加清晰。所以一开始我们应该先对两个数进行预处理，让它们的长度一致。即往短的数前面补0，不存在的位置补上0。你百位上没有数字，没关系，我给你个0，然后我们再相加或者相减。改进的代码如下： 

/**
	 * 求超大整数的和
	 * @param num1
	 * @param num2
	 * @return 
	 */
	public static String bigNumberSumBetter(String num1, String num2) {
		char sign = '+';
		char sign1 = num1.charAt(0);
		char sign2 = num2.charAt(0);

		String number1 = "";
		String number2 = "";

		// 去符号位操作
		if (sign1 == '-' || sign1 == '+') {
			number1 = num1.substring(1);
		} else {
			sign1 = '+';
			number1 = num1;
		}
		// 去符号位操作
		if (sign2 == '-' || sign2 == '+') {
			number2 = num2.substring(1);
		} else {
			sign2 = '+';
			number2 = num2;
		}

		boolean isDig1 = number1.matches("[1-9][0-9]*");
		boolean isDig2 = number2.matches("[1-9][0-9]*");
		if (!isDig1 || !isDig2) {
			throw new NumberFormatException("输入的数据不是正确的格式的整数");
		}

		//两个数的长度
		int length1 = number1.length();
		int length2 = number2.length();
		int len = length1>=length2? length1+1:length2+1;
		
		StringBuffer number1Buffer = new StringBuffer();
		StringBuffer number2Buffer = new StringBuffer();
		//扩展数据的长度,使它们的长度一样
		if(length1>length2){
			for(int i=0; i<length1-length2; i++){
				number2Buffer.append("0");
			}
		}else if(length1<length2){
			for(int i=0; i<length2-length1; i++){
				number1Buffer.append("0");
			}
		}
		
		number1Buffer.append(number1);
		number2Buffer.append(number2);
		
		char[] chars1 = number1Buffer.reverse().toString().toCharArray(); 
		char[] chars2 = number2Buffer.reverse().toString().toCharArray(); 
		//存储每位相加的结果
		int[] result = new int[len];
		//同号相加
		if(sign1==sign2){
			sign = sign1;
			for(int i=0; i<len-1; i++){
				result[i] = (chars1[i]-'0')+(chars2[i]-'0');
			}
			
			// 处理进位
			for (int i = 0; i < len; i++) {
				if (result[i] >= 10) {
					result[i + 1] += result[i] / 10;
					result[i] = result[i] % 10;
				}
			}
		}else {
			// 拿大的数减去小的数
			boolean lager = number1.compareTo(number2)>0 ? true : false;
			if (lager) {
				sign = sign1;
				for (int i = 0; i < len-1; i++) {
					result[i] = (chars1[i] - '0') - (chars2[i] - '0');
				}
			} else {
				sign = sign2;
				for (int i = 0; i < len-1; i++) {
					result[i] = (chars2[i] - '0') - (chars1[i] - '0');
				}
			}
			
			// 处理借位
			for (int i = 0; i < len; i++) {
				if (result[i] < 0) {
					result[i] += 10;
					result[i + 1]--;
				}
			}
		}
		
		// 结果没有进位时的0处理
		boolean flag = true;
		StringBuffer resultStr = new StringBuffer();

		for (int i = result.length - 1; i >= 0; i--) {
			if (result[i] == 0 && flag) {
				continue;
			}
			flag = false;
			resultStr.append(result[i]);
		}

		// 符号处理
		if (sign == '-') {
			return "-" + resultStr.toString();
		} else {
			return resultStr.toString();
		}
	}
代码结构更清晰了，也更容易让人读懂。



SanisyMe
关注
  • 3
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java 大整数加法
The_citrus的博客
05-09 4183
描述 求两个不超过200位的非负整数的和。 输入 有两行，每行是一个不超过200位的非负整数，可能有多余的前导0。 输出 一行，即相加后的结果。结果里不能有多余的前导0，即如果结果是342，那么就不能输出为0342。 样例输入 22222222222222222222 33333333333333333333 样例输出 55555555555555555555 一：在讲思路前我要先讲一下样例输入存在的坑： 1.输入可能有很多个前导零 2.可能两行输入都是0 3.输入数据的长度可能不一致，相加时短的一方会越界
任意长度的高精度大整数加法
ajwh64482的博客
08-22 217
方法：这里用了数据结构栈，实际上栈更方便实现高精度加法。 步骤：1、第一个数据加数按输入顺序（高位到低位）入栈1。此时栈顶为最低位 2、‍第二个数据加数按输入顺序（高位到低位）入栈2。此时栈顶为最低位 3、将栈1、栈2均pop出栈顶做加法，并考虑进位，结果入栈3，这时栈3正好是低位入栈。 4、处理多余的栈1、...
javaint变量如何相加
最新发布
weixin_29416459的博客
07-13 28
项目方案：Java整数变量相加计算器 1. 项目说明 本项目旨在设计一个Java程序，实现两个整数变量的相加计算功能。用户可以输入两个整数，程序将计算它们的和并输出结果。 2. 实现方案 2.1 程序结构 我们将设计一个简单的Java类，包含一个主方法用于用户输入，以及一个用于计算相加的方法。具体结构如下： 登录后复制 ...
c++两个数组相加_算法：如何实现大正整数相加？
weixin_32048757的博客
01-22 3003
作者：Byte_Liu 来源：http://byteliu.com/categories/题目：在不使用BigInteger类的情况下，如何计算两个大正整数的和？程序不可能通过一条指令计算出两个大整数的和，但我们可以把一个大运算拆分成多个小运算, 像小学生一样列竖式进行按位运算。这里还有一个问题，我们都知道long类型的取值范围是: 最小值：Long.MIN_VALUE=-922337203685...
java实现大整数数相加_求助， 大整数相加程序！
weixin_39581845的博客
02-24 207
求助， 大整数相加程序！请大家帮我写下大整数相加程序。我刚学 不怎么会，，随机生成两个100位以内的大整数，将两个数相加。 并格式化输出，例如：每50位一行，5位一段。。在控制台下输出就行！！不要求界面！。我就写出了一点，剩下的不会了， 请大家帮忙！谢谢大家啦！！(我写的代码如下)程序代码：import java.util.Random;public class Xangjia{pub...
java中最大的整数用法分析
08-30
Java 中最大的整数用法分析 Java 中最大整数用法分析的主要内容是介绍 Java 中最大的整数用法，结合具体实例形式分析了 Java 计算类 java.math.BigInteger 的具体使用技巧。本文将详细介绍 Java 中最大整数的用法，...
java中超过long范围的超大整数相加算法详解(面试高频)
08-24
在 Java 中，对超过 long 范围的超大整数相加算法可以使用竖式运算的思想来实现，即逐位相加，并且对超过 9 的部分进行进位处理。该算法可以满足大多数的加法运算需求，并且可以在面试中作为一个常见的题目。
JAVA实验报告 处理大整数
01-24
在Java编程语言中，处理大整数是一项重要的任务，特别是在需要进行高精度计算或存储超出普通整型数据类型范围的数值时。实验标题"JAVA实验报告 处理大整数"涉及的核心知识点是使用`java.math.BigInteger`类来处理...
大整数相加，计算两个非负整数的和，可以精确计算2的100次方
06-29
大整数相加的实现通常涉及到以下技术点： 1. **大整数表示**：大整数通常用数组或链表等数据结构存储，每个元素代表一个数字位。例如，可以用一个数组存储2的100次方，该值有30个十进制位，远远超过了普通整型所能...
java编程实现两个大数相加代码示例
08-28
Java编程实现两个大数相加代码示例 在Java编程中，实现两个大数相加是一项常见的操作，特别是在高精度计算中。通常情况下，实现大数运算是通过BigInteger和BigDecimal两种方法。这两种方法分别表示不可变的任意精度...
java大数相加代码
11-29
java实现大数相加，在不使用BigInteger工具的前提下实现大数相加
大整数加法java_JAVA 大整数加法的实现
weixin_32639437的博客
02-18 575
/*** 整数加法** @param lv* 左值* @param rv* 右值* @param result* 相加的结果* @数值存放说明 数值的每一位作为栈的一项存放在栈中,从栈底到栈顶依次是数值的高位到低位* @算法描述 输入的加数倒序存放在栈中(即栈顶是数的最低位,栈底是数的最高位)。 计算的时候,依次弹出栈中的数据,对每...
Java实现整数相加
baiyanyong9761的博客
09-26 1659
一、设计思路 要在java中实现整数相加，难点就是将字符转化为数字。这里只要解决这个问题就可以很简单的完成整个实验。利用：Scannerinput=newSc(System.in);inta=input.nextInt();这两句代码就可以实现将输入的字符转化为整数。同时，因为要实现两个或多个整数相加，所以要动态申请数组。利用一个循环结构，就可以将程序实现。...
java 两个大数相加
bluewelkin的专栏
03-08 265
public class BigDecimalAdd { public static void main(String[] args) { System.out.println("----------"); // 341234325 String a = "34199939"; String b = "413299999"; System.out.println("计算结果：" + addLargeNumber(a,..
java过大的整数加L_超大整数相加java算法
weixin_39926540的博客
02-16 482
packagecom.test;importjava.sql.Timestamp;importjava.text.ParseException;public classBigMathAdd {public static void main(String[] args) throwsParseException{String addA="9999999999999999999999999999999...
java高精度加法_任意长度的高精度大整数加法
weixin_42363600的博客
02-13 438
方法：这里用了数据结构栈，实际上栈更方便实现高精度加法。步骤：1、第一个数据加数按输入顺序(高位到低位)入栈1。此时栈顶为最低位2、‍第二个数据加数按输入顺序(高位到低位)入栈2。此时栈顶为最低位3、将栈1、栈2均pop出栈顶做加法，并考虑进位，结果入栈3，这时栈3正好是低位入栈。4、处理多余的栈1、栈2。5、直接pop出栈3，即正好的从高位到低位的结果。完整的实现代码如下：#include "i...
java大数相加
shitianxiang的博客
04-21 293
我的想法是用字符串按位相加，超过10的进位。当然字符串长短不一的话需要补0； 下面是我的代码，有点小菜。 public static int[] sum(String a,String b) { if(a.length()>b.length()) { for(int i=0;i<a.length()-b.length();i++) { b="0"+b; } } ...
大数相加(Java)
qq_41591215的博客
02-23 2114
题目描述： 给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和并同样以字符串形式返回。 你不能使用任何內建的用于处理大整数的库（比如 BigInteger）， 也不能直接将输入的字符串转换为整数形式。 条件：至少有一个字符串长度大于10小于100，如10 <= num1.length() <= 100 解题思路： 本题我们只需要对两个大整数模拟「竖式加法」的过程。竖式加法就是我们平常学习生活中常用的对两个整数相加的方法，回想一下我们在纸上对两个整数相加的操作，是不是如下图将相同数
java用数组实现大整数相加
04-25
可以通过以下代码实现Java中用数组实现大整数相加： ``` public static int[] add(int[] a, int[] b) { int[] result = new int[Math.max(a.length, b.length)]; int carry = 0; for (int i = 0; i < result.length; i++) { int a_value = i < a.length ? a[a.length - 1 - i] : 0; int b_value = i < b.length ? b[b.length - 1 - i] : 0; int sum = a_value + b_value + carry; result[result.length - 1 - i] = sum % 10; carry = sum / 10; } if (carry > 0) { int[] new_result = new int[result.length + 1]; System.arraycopy(result, 0, new_result, 1, result.length); new_result[0] = carry; return new_result; } return result; } ``` 在这里，我们首先创建一个长度为两个数字长度的最大值的数组作为结果，然后从最后一位开始向前遍历数组，同时计算两个数字和一个进位的和。最后，如果存在进位，则需要将结果数组的长度加1。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值