实验1 线性数据结构综合设计

使用链表实现高精度整数加减法运算

输入数据可以采用每三位整数一组（中间加逗号），也可以不加逗号（比如： 100000000）。

（1）0；0；+ ，输出“0”。

（2）100，100，100；100，100，100，+，输出：200，200，200

（3）自选数据

实验代码：

Big Integer类：

public class BigInteger implements BigInt {
	// 保存符号1为+，-1为-
	LinkedList<Byte> numbers = null;
	private int sign = 0;

	public BigInteger(String integer) {
		// TODO Auto-generated constructor stub
		sign = 0; // 保存符号1为+，-1为-
		numbers = new LinkedList<Byte>();
		if (integer.contains("-")) {
			sign = -1;
		} else if (integer.contains("+")) {
			sign = 1;
		} else {
			sign = 0;
		}
		if (sign == 1 || sign == -1) {
			for (int i = 1; i < integer.length(); i++) {
				Byte nums = (byte) integer.charAt(i);
				numbers.add((byte) (nums - 48));
			}
		} else {
			for (int i = 0; i < integer.length(); i++) {
				Byte nums = (byte) integer.charAt(i);
				numbers.add((byte) (nums - 48));
			}
		}
	}

	public BigInteger(Long integer) {
		// TODO Auto-generated constructor stub
		sign = 0; // 保存符号1为+，-1为-
		numbers = new LinkedList<Byte>();
		String num = String.valueOf(integer);// 负数带符号，正数如果带符号转换自动丢掉
		if (num.contains("-")) {
			sign = -1;
		} else {
			sign = 0;
		}
		if (sign == -1) {
			for (int i = 1; i < num.length(); i++) {
				Byte nums = (byte) num.charAt(i);
				numbers.add((byte) (nums - 48));
				// System.out.print(numbers);
			}
		} else {
			for (int i = 0; i < num.length(); i++) {
				Byte nums = (byte) num.charAt(i);
				numbers.add((byte) (nums - 48));
			}
		}
	}

	@Override
	public BigInt add(BigInt bInt) {
		BigInt results = null;// 结果保存
		// TODO Auto-generated method stub
		int flag = 0;// 进退位符
		LinkedList<Integer> result = new LinkedList<Integer>();
		LinkedList<Byte> reset = new LinkedList<Byte>(); // 复位numbers
		for (int i = 0; i < numbers.size(); i++) {
			reset.add(numbers.get(i));
			// System.out.println(reset);
		}
		// A+B,A>0,B>0(下同)
		if ((bInt.getSign() == 1 || bInt.getSign() == 0)
				&& (this.getSign() == 1 || this.getSign() == 0)) {
			while (bInt.getValue().length > numbers.size()) {
				numbers.addFirst((byte) 0); // 如果数组更长则链表对位
			}
			for (int i = bInt.getValue().length - 1; i >= 0; i--) { // 相同位数部分加减
				int res = 0;
				res = numbers.getLast() + bInt.getValue()[i] + flag;
				if (res >= 10) {
					flag = 1;
					res = res % 10;
					result.addFirst(res);// 插入头部
					numbers.removeLast();
				} else {
					flag = 0;
					result.addFirst(res);
					numbers.removeLast();
				}
			}
			while (numbers.size() != 0) {
				// 加入超出相同位数的数
				int r = 0;
				r = numbers.getLast() + flag;
				if (r >= 10) {
					flag = 1;
					r = r % 10;
					result.addFirst(r);// 插入头部
					numbers.removeLast();
				} else {
					flag = 0;
					result.addFirst(r);
					numbers.removeLast();
				}
			}
			if (flag == 1)
				result.addFirst(1);
			StringBuilder res = new StringBuilder();
			for (Integer integer : result)
				res.append(integer);
			String s = res.toString();
			results = new BigInteger(s);
			for (int i = 0; i < reset.size(); i++) {
				numbers.add(reset.get(i));
			}
		}
		// A+(-B)
		else if (bInt.getSign() == -1
				&& (this.getSign() == 0 || this.getSign() == 1)) {
			bInt.setSign(0);
			results = this.sub(bInt);
		}
		// -A+B=-(B-A)
		else if ((bInt.getSign() == 0 || bInt.getSign() == 1)
				&& this.getSign() == -1) {
			this.setSign(0);
			results = this.sub(bInt);
			if (results.getSign() == 0)
				results.setSign(-1);
			else
				results.setSign(0);
		}
		// -(A+B)
		else {
			bInt.setSign(0);
			this.setSign(0);
			results = this.add(bInt);
			results.setSign(-1);
		}
		return results;
	}

	@Override
	public BigInt sub(BigInt bInt) {
		// TODO Auto-generated method stub
		BigInt results = null;
		int flag = 0;
		LinkedList<Integer> result = new LinkedList<Integer>();
		LinkedList<Byte> reset = new LinkedList<Byte>(); // 复位numbers
		for (int i = 0; i < numbers.size(); i++) {
			reset.add(numbers.get(i));
		}
		// A-B,A>B
		if ((bInt.getSign() == 1 || bInt.getSign() == 0)
				&& (this.getSign() == 1 || this.getSign() == 0)) {
			if (numbers.size() > bInt.getValue().length) {
				for (int i = bInt.getValue().length - 1; i >= 0; i--) { // 相同位数部分加减
					int res = 0;
					res = numbers.getLast() - bInt.getValue()[i] - flag;
					if (res < 0) {
						flag = 1;
						res = res + 10;
						result.addFirst(res);
						numbers.removeLast();
					} else {
						flag = 0;
						result.addFirst(res);
						numbers.removeLast();
					}
				}
				// 多余部分
				while (numbers.size() != 0) {
					// 加入超出相同位数的数
					int r = 0;
					r = numbers.getLast() - flag;
					if (r < 0) {
						flag = 1;
						r = r + 10;
						result.addFirst(r);
						numbers.removeLast();
					} else {
						flag = 0;
						result.addFirst(r);
						numbers.removeLast();
					}
				}
				StringBuilder res = new StringBuilder();
				for (Integer integer : result)
					res.append(integer);
				String s = res.toString();
				results = new BigInteger(s);
				for (int i = 0; i < reset.size(); i++) {
					numbers.add(reset.get(i));
				}
			}
			// A-B,A<=B
			else {
				flag = 0;
				while (bInt.getValue().length > numbers.size()) {
					numbers.addFirst((byte) 0); // 如果数组更长则链表对位
				}
				if ((bInt.getSign() == 1 || bInt.getSign() == 0)
						&& (this.getSign() == 1 || this.getSign() == 0)) {
					for (int i = bInt.getValue().length - 1; i >= 0; i--) {
						int res = 0;
						res = bInt.getValue()[i] - numbers.getLast() - flag;// B-A
						if (res < 0) {
							flag = 1;
							res = res + 10;
							result.addFirst(res);
							numbers.removeLast();
						} else {
							flag = 0;
							result.addFirst(res);
							numbers.removeLast();
						}
					}
				}

				try {
					while (result.getFirst() == 0) {
						result.removeFirst();
					}
				}// 全0的话会报错
				catch (NoSuchElementException e) {
					result.add(0);
				}

				StringBuilder res = new StringBuilder();
				for (Integer integer : result)
					res.append(integer);
				String s = res.toString();
				results = new BigInteger(s);
				results.setSign(-1);
				for (int i = 0; i < reset.size(); i++) {
					numbers.add(reset.get(i));
				}
			}
		}
		// -A-B
		else if ((bInt.getSign() == 0 || bInt.getSign() == 1)
				&& this.getSign() == -1) {
			this.setSign(0);
			results = this.add(bInt);
			results.setSign(-1);
		}
		// A-(-B)
		// else if((this.getSign()==0||this.getSign()==1) &&
		// bInt.getSign()==-1){
		// bInt.setSign(0);
		// results=this.add(bInt);
		// }
		// A-(-B)
		else {
			bInt.setSign(0);
			results = this.add(bInt);
		}
		return results;
	}

	@Override
	public BigInt add(long bLong) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public BigInt sub(long bLong) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public BigInt add(int bInt) {
		// TODO Auto-generated method stub

		return null;
	}

	@Override
	public BigInt sub(int bInt) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public boolean isPositive() {
		// TODO Auto-generated method stub
		return false;
	}

	//
	// @Override
	// public Sign getSign() {
	// // TODO Auto-generated method stub
	// return null;
	// }
	//
	//
	// @Override
	// public void setSign(Sign sign) {
	// // TODO Auto-generated method stub
	// }

	@Override
	public Byte[] getValue() {
		// TODO Auto-generated method stub
		Byte[] bytes = new Byte[numbers.size()];
		for (int i = 0; i < numbers.size(); i++)
			bytes[i] = numbers.get(i);
		return bytes;
	}

	/**
	 * @return 返回 sign 属性的值
	 */
	public int getSign() {
		return sign;
	}

	/**
	 * @param sign
	 *            将属性sign的值设置为sign
	 */
	public void setSign(int sign) {
		this.sign = sign;
	}

	/**
	 * 重写 cn.edu.bistu.cs.BigInteger 中定义的 toString 方法
	 *
	 * @see java.lang.Object#toString()
	 * @return
	 */
	@Override
	public String toString() {
		String s = "";
		if (sign == -1) {
			s = "-"; // 负数带符号
		}
		for (int i = 0; i < numbers.size(); i++) {
			s += numbers.get(i);
		}
		if (s.length() > 3) {
			StringBuffer str = new StringBuffer(s);
			for (int i = str.length() - 3; i > 0; i = i - 3) {
				str.insert(i, ",");
			}
			String ss = str.toString();
			return ss;
		}
		return s;
	}
}

BigInt类：

public interface BigInt {
	
//	public enum Sign {
//		POSITIVE, NEGATIVE;
//	};
	/**
	 * 高精度整数加法，将整数bInt与当前整数相加，
	 * 并将结果作为一个新的BitInt类型整数返回，
	 * 方法不改变bInt整数以及当前整数的值
	 * @param bInt
	 * @return
	 */
	public BigInt add(BigInt bInt);
	
	/**
	 * 高精度整数减法，当前整数减去bInt，
	 * 并将结果作为一个新的BitInt类型整数返回
	 * 方法不改变bInt整数以及当前整数的值
	 * @param bInt
	 * @return
	 */
	public BigInt sub(BigInt bInt);

	/**
	 * 高精度整数加法，将长整形变量bLong与当前整数相加，
	 * 并将结果作为一个新的BitInt类型整数返回，
	 * 方法不改变bLong以及当前整数的值
	 * @param bLong
	 * @return
	 */
	public BigInt add(long bLong);
	
	/**
	 * 高精度整数减法，当前整数减去bLong，
	 * 并将结果作为一个新的BitInt类型整数返回
	 * 方法不改变bLong以及当前整数的值
	 * @param bLong
	 * @return
	 */
	public BigInt sub(long bLong);
	
	/**
	 * 高精度整数加法，将整形变量bInt与当前整数相加，
	 * 并将结果作为一个新的BitInt类型整数返回，
	 * 方法不改变bInt以及当前整数的值
	 * @param bInt
	 * @return
	 */
	public BigInt add(int bInt);
	
	/**
	 * 高精度整数减法，当前整数减去bInt，
	 * 并将结果作为一个新的BitInt类型整数返回
	 * 方法不改变bInt以及当前整数的值
	 * @param bInt
	 * @return
	 */
	public BigInt sub(int bInt);
	public boolean isPositive();
	public int getSign();
	public void setSign(int sign); 
//	public Sign getSign();
//	public void setSign(Sign sign);
	public Byte[] getValue();
	@Override
	/**
	 * 覆盖Object对象的toString方法，将超长整数值输出
	 * @return
	 */
	String toString();
}

TestMain类：

public class TestMain {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		BigInt bInt = new BigInteger(+999999999999999999L);// 18
		 BigInt bI = new BigInteger("54468877655");
		 BigInt res = bI.sub(new BigInteger("666588"));
		BigInt result = bInt.sub(new BigInteger("1000000000000000000"));// 19
		System.out.println(result);
		 System.out.println(res);

	}
}