栈的应用—大数相加
package org.Stone6762.MStack.adopt;
import java.util.Scanner;
import org.Stone6762.MStack.imple.LinkStack;
/**
* @author_Stone6762
* @Description_大数相加
* */
public class BigAdd {
/**
* @Describe_将表示数字的字符串从高位到低位的形式压入栈_并去除其中的空格
* @param str
* @return
* @throws Exception
*/
public LinkStack numSplit(String str) throws Exception {
LinkStack s = new LinkStack();
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
if (' ' == c) {
continue;
}
if (c >= '0' && c <= '9') {
s.push(c + "");
} else {
throw new Exception("错误: 输入了非数字类型的字符! ");
}
}
return s;
}
/**
* @Describe_求两个大数的和_加数和被加数以字符串的形式给出_计算的结果也以字符串的形式返回
* @param a
* @param b
* @return
* @throws Exception
*/
public String add(String a, String b) throws Exception {
LinkStack sum = new LinkStack();
LinkStack sA = numSplit(a);
LinkStack sB = numSplit(b);
int tSum;// 表示两位的和
boolean isCarry = false;// 是否有进位
// 当两个栈都非空时,依次出栈,然后相加
while (!sA.isEmpty() && !sB.isEmpty()) {
tSum = Integer.valueOf((String) sA.pop())
+ Integer.valueOf((String) sB.pop());
if (isCarry) {
tSum++;
isCarry = false;// 将低位的进位状态消除掉,防止影响下次的使用
}
if (tSum >= 10) {
tSum -= 10;
isCarry = true;
}
sum.push(tSum);
}
LinkStack temp = !sA.isEmpty() ? sA : sB;
// 当其中一个为空时,对另一个非空的进行操作
while (!temp.isEmpty()) {
int t = Integer.valueOf((String) temp.pop());
if (isCarry) {// 第一个isCarry为上面的残留
t++;
if (t >= 10) {
t -= 10;
} else {
isCarry = false;// 只有当上一次是true,且这一次没有进位时,才需要对isCarry进行修改
}
}
sum.push(t);
}
// 对最后一次相加的十位的数字进行判断
if (isCarry) {
sum.push(1);
}
return stack2Str(sum);
}
/**
* @Describe_将一个栈中的数据从栈顶到栈底变成一个字符串
* @param sum
* @return
*/
public String stack2Str(LinkStack s) {
String str = "";
while (!s.isEmpty()) {
str += s.pop().toString();
}
return str;
}
public static void main(String[] args) throws Exception {
BigAdd s = new BigAdd();
Scanner scan = new Scanner(
System.in);
while (scan.hasNext()) {
String a = scan.next();
String b = scan.next();
System.out.println(s.add(a, b));
}
}
}
import java.util.Scanner;
import org.Stone6762.MStack.imple.LinkStack;
/**
* @author_Stone6762
* @Description_大数相加
* */
public class BigAdd {
/**
* @Describe_将表示数字的字符串从高位到低位的形式压入栈_并去除其中的空格
* @param str
* @return
* @throws Exception
*/
public LinkStack numSplit(String str) throws Exception {
LinkStack s = new LinkStack();
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
if (' ' == c) {
continue;
}
if (c >= '0' && c <= '9') {
s.push(c + "");
} else {
throw new Exception("错误: 输入了非数字类型的字符! ");
}
}
return s;
}
/**
* @Describe_求两个大数的和_加数和被加数以字符串的形式给出_计算的结果也以字符串的形式返回
* @param a
* @param b
* @return
* @throws Exception
*/
public String add(String a, String b) throws Exception {
LinkStack sum = new LinkStack();
LinkStack sA = numSplit(a);
LinkStack sB = numSplit(b);
int tSum;// 表示两位的和
boolean isCarry = false;// 是否有进位
// 当两个栈都非空时,依次出栈,然后相加
while (!sA.isEmpty() && !sB.isEmpty()) {
tSum = Integer.valueOf((String) sA.pop())
+ Integer.valueOf((String) sB.pop());
if (isCarry) {
tSum++;
isCarry = false;// 将低位的进位状态消除掉,防止影响下次的使用
}
if (tSum >= 10) {
tSum -= 10;
isCarry = true;
}
sum.push(tSum);
}
LinkStack temp = !sA.isEmpty() ? sA : sB;
// 当其中一个为空时,对另一个非空的进行操作
while (!temp.isEmpty()) {
int t = Integer.valueOf((String) temp.pop());
if (isCarry) {// 第一个isCarry为上面的残留
t++;
if (t >= 10) {
t -= 10;
} else {
isCarry = false;// 只有当上一次是true,且这一次没有进位时,才需要对isCarry进行修改
}
}
sum.push(t);
}
// 对最后一次相加的十位的数字进行判断
if (isCarry) {
sum.push(1);
}
return stack2Str(sum);
}
/**
* @Describe_将一个栈中的数据从栈顶到栈底变成一个字符串
* @param sum
* @return
*/
public String stack2Str(LinkStack s) {
String str = "";
while (!s.isEmpty()) {
str += s.pop().toString();
}
return str;
}
public static void main(String[] args) throws Exception {
BigAdd s = new BigAdd();
Scanner scan = new Scanner(
while (scan.hasNext()) {
String a = scan.next();
String b = scan.next();
System.out.println(s.add(a, b));
}
}
}
![](https://images2015.cnblogs.com/blog/1186951/201707/1186951-20170710180646243-188929222.png)
import java.util.Stack;
/**
* @ClassName_BigAdd大数相加
* @author_Stone6762
* @CreationTime_2016年10月22日17:36:45
* @Description_算法描述
* */
/*
* 算法描述 (1)将两个加数的相对应位从高位到低位依次压入栈,SA和SB
* (2)若两个栈都非空,则依次从栈中弹出栈顶数字相加,将结果的个位数添加到结果栈Sum中,结果的十位数与下次的和相加
* (3)若某个加数栈为空,则将非空栈的栈顶元素弹出与进位数相加,结果的个位数放到Sum中,若最高位有进位, 则最后将1压入栈
* (4)若两个栈均为空,则结果栈中保存的就是最后的结果,注意栈顶是结果中的最高位
*/
public class MyBigAdd {
/**
* @Describe_将表示数字的字符串从高位到低位的形式压入栈_并去除其中的空格
* @param str
* @return
* @throws Exception
*/
private static Stack<String> numSplit(String str) throws Exception {
Stack<String> s = new Stack<String>();
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
if (' ' == c) {
continue;
}
if (c >= '0' && c <= '9') {
s.push(c + "");
} else {
throw new Exception("错误: 输入了非数字类型的字符! ");
}
}
return s;
}
/**
* @Describe_求两个大数的和_加数和被加数以字符串的形式给出_计算的结果也以字符串的形式返回
* @param a
* @param b
* @return
* @throws Exception
*/
@SuppressWarnings("finally")
public static String add(String a, String b) {
Stack<String> sum = new Stack<String>();
try {
Stack<String> sA = numSplit(a);
Stack<String> sB = numSplit(b);
int tSum;// 表示两位的和
boolean isCarry = false;// 是否有进位
// 当两个栈都非空时,依次出栈,然后相加
while (!sA.isEmpty() && !sB.isEmpty()) {
tSum = Integer.valueOf((String) sA.pop())
+ Integer.valueOf((String) sB.pop());
if (isCarry) {
tSum++;
isCarry = false;// 将低位的进位状态消除掉,防止影响下次的使用
}
if (tSum >= 10) {
tSum -= 10;
isCarry = true;
}
sum.push("" + tSum);
}
Stack<String> temp = !sA.isEmpty() ? sA : sB;
// 当其中一个为空时,对另一个非空的进行操作
while (!temp.isEmpty()) {
int t = Integer.valueOf((String) temp.pop());
if (isCarry) {// 第一个isCarry为上面的残留
t++;
if (t >= 10) {
t -= 10;
} else {
isCarry = false;// 只有当上一次是true,且这一次没有进位时,才需要对isCarry进行修改
}
}
sum.push("" + t);
}
// 对最后一次相加的十位的数字进行判断
if (isCarry) {
sum.push("" + 1);
}
} catch (Exception e) {
e.printStackTrace();
}finally{
return stack2Str(sum);
}
}
/**
* @Describe_将一个栈中的数据从栈顶到栈底变成一个字符串
* @param sum
* @return
*/
private static String stack2Str(Stack<String> s) {
String str = "";
while (!s.isEmpty()) {
str += s.pop().toString();
}
return str;
}
}
/**
* @ClassName_BigAdd大数相加
* @author_Stone6762
* @CreationTime_2016年10月22日17:36:45
* @Description_算法描述
* */
/*
* 算法描述 (1)将两个加数的相对应位从高位到低位依次压入栈,SA和SB
* (2)若两个栈都非空,则依次从栈中弹出栈顶数字相加,将结果的个位数添加到结果栈Sum中,结果的十位数与下次的和相加
* (3)若某个加数栈为空,则将非空栈的栈顶元素弹出与进位数相加,结果的个位数放到Sum中,若最高位有进位, 则最后将1压入栈
* (4)若两个栈均为空,则结果栈中保存的就是最后的结果,注意栈顶是结果中的最高位
*/
public class MyBigAdd {
/**
* @Describe_将表示数字的字符串从高位到低位的形式压入栈_并去除其中的空格
* @param str
* @return
* @throws Exception
*/
private static Stack<String> numSplit(String str) throws Exception {
Stack<String> s = new Stack<String>();
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
if (' ' == c) {
continue;
}
if (c >= '0' && c <= '9') {
s.push(c + "");
} else {
throw new Exception("错误: 输入了非数字类型的字符! ");
}
}
return s;
}
/**
* @Describe_求两个大数的和_加数和被加数以字符串的形式给出_计算的结果也以字符串的形式返回
* @param a
* @param b
* @return
* @throws Exception
*/
@SuppressWarnings("finally")
public static String add(String a, String b) {
Stack<String> sum = new Stack<String>();
try {
Stack<String> sA = numSplit(a);
Stack<String> sB = numSplit(b);
int tSum;// 表示两位的和
boolean isCarry = false;// 是否有进位
// 当两个栈都非空时,依次出栈,然后相加
while (!sA.isEmpty() && !sB.isEmpty()) {
tSum = Integer.valueOf((String) sA.pop())
+ Integer.valueOf((String) sB.pop());
if (isCarry) {
tSum++;
isCarry = false;// 将低位的进位状态消除掉,防止影响下次的使用
}
if (tSum >= 10) {
tSum -= 10;
isCarry = true;
}
sum.push("" + tSum);
}
Stack<String> temp = !sA.isEmpty() ? sA : sB;
// 当其中一个为空时,对另一个非空的进行操作
while (!temp.isEmpty()) {
int t = Integer.valueOf((String) temp.pop());
if (isCarry) {// 第一个isCarry为上面的残留
t++;
if (t >= 10) {
t -= 10;
} else {
isCarry = false;// 只有当上一次是true,且这一次没有进位时,才需要对isCarry进行修改
}
}
sum.push("" + t);
}
// 对最后一次相加的十位的数字进行判断
if (isCarry) {
sum.push("" + 1);
}
} catch (Exception e) {
e.printStackTrace();
}finally{
return stack2Str(sum);
}
}
/**
* @Describe_将一个栈中的数据从栈顶到栈底变成一个字符串
* @param sum
* @return
*/
private static String stack2Str(Stack<String> s) {
String str = "";
while (!s.isEmpty()) {
str += s.pop().toString();
}
return str;
}
}
每一章内容都是心血,希望大家不要抄袭~