大整数的运算问题

[leversss]

有个算法问题还没解决
大整数的运算
今天老师要求我们一天解决 可是我写了两个多小时就写了一个加法
乘除发一点概念都还没有
望那为高手指点一下
leversss(328054944) 15:36:41
整数要求是512位以上
leversss(328054944) 15:37:53
乘法的结果是1024位
所以要做1024位的
leversss(328054944) 15:38:14
我刚刚写的加法
leversss(328054944) 15:38:16
public class BigNumber
{
String n1="1233332211111111111111112222222222222223333333333";
String n2="9222222222233949034949494112332211112222222229999";
int intn1[];
int intn2[];
int addResult[];
public void init()
{
int len1=n1.length();
int len2=n2.length();
intn1=new int[len1];
intn2=new int[len2];
for(int i=0;i<len1;i++)
intn1[i]=n1.charAt(i)-48;
for(int i=0;i<len2;i++)
intn2[i]=n2.charAt(i)-48;
}
public void add()
{
int len1=n1.length();
int len2=n2.length();
int len=len1>len2?len1:len2;
++len;
addResult=new int[len];
for(int i=0;i<len;i++)
addResult[i]=0;
int dis=len-len1;
for(int i=len1-1;i>=0;i--)
addResult[dis+i]+=intn1[i];
dis=len-len2;
for(int i=len2-1;i>=0;i--)
addResult[dis+i]+=intn2[i];
for(int i=len-1;i>0;i--)
if(addResult[i]>9)
{
addResult[i]-=10;
++addResult[i-1];
}
}
public int[] getRes()
{
return addResult;
}

public static void main(String args[])
{
BigNumber bn=new BigNumber();
bn.init();
bn.add();
int arr[]=bn.getRes();
for(int i=0;i<arr.length;i++)

System.out.print(arr[i]);
}

}

[hetty1006]

想了我1个小时了
写了这点
还缺点验证
好累啊
大整数的加减

乘法的话就需要从拆开作开始
比如 12*24 = 4*2 + 4*1*10(移1位与前相加) + 2*2*10(移1位与前相加) + 2*1*10*10(移2位与前相加) 这样了可以用

除法记得有个什么算法 忘了
下班啦 lz先看着

public class BigInteger implements Comparable {

private String bigInt = "";

private boolean positive = true;

private int[] ints;

public BigInteger(String bigInt) {
this.bigInt = bigInt;
this.positive = !bigInt.startsWith("-");
if (bigInt.startsWith("+") || bigInt.startsWith("-")) {
bigInt = bigInt.substring(1);
}
while(bigInt.startsWith("0"))
{
bigInt = bigInt.substring(1);
}
char[] chars = bigInt.toCharArray();
ints = new int[chars.length];
for (int i = chars.length; i > 0; i--) {
ints[chars.length - i] = Integer.parseInt("" + chars[i - 1]);
}
}

public BigInteger(int[] ints, boolean positive) {
this.ints = ints;
StringBuffer integer = new StringBuffer();
for (int i = ints.length; i > 0; i--) {
integer.append(ints[i - 1]);
}
this.bigInt = positive ? integer.toString() : "-" + integer.toString();
this.positive = positive;
}

public int compareTo(Object o) {
if(o instanceof BigInteger)
{
BigInteger bi = (BigInteger)o;
if(this.isPositive() && !bi.isPositive())
{
return 1;
}
else if (this.isPositive())
{
return compare(this.ints,bi.getInts());
}
else
{
return 0 - compare(this.ints,bi.getInts());
}
}
else
{
return 0;
}

}

private static int compare(int[] ints1, int[] ints2)
{
if(ints1.length != ints2.length)
{
return ints1.length - ints2.length;
}
else
{
int length = ints1.length;
for(int i=length;i>0;i--)
{
if(ints1[i-1] != ints2[i-1])
{
return ints1[i-1] - ints2[i-1];
}
}
return 0;
}
}

private static int[] add(int[] add1,int[] add2)
{
int maxLength = add1.length > add2.length ? add1.length : add2.length;
int[] results = new int[maxLength + 1];
int jinwei = 0;
int a1 = 0;
int a2 = 0;
for (int i = 0; i < maxLength; i++) {
a1 = (i < add1.length ? add1[i] : 0);
a2 = (i < add2.length ? add2[i] : 0);
results[i] = (jinwei + a1 + a2) % 10;
jinwei = (jinwei + a1 + a2) / 10;
}
if (jinwei > 0) {
results[maxLength] = jinwei;
}
return results;
}

private static int[] minus(int[] ints1, int[] ints2)
{
int maxLength = ints1.length > ints1.length ? ints1.length : ints1.length;
int[] results = new int[maxLength];
int jiewei = 0;
int beijie = 0;
int a1 = 0;
int a2 = 0;
for (int i = 0; i < maxLength; i++) {
a1 = (i < ints1.length ? ints1[i] : 0);
a2 = (i < ints2.length ? ints2[i] : 0);
jiewei = a1 > a2 ? 0 : 1;
results[i] = (a1 - beijie + jiewei * 10 - a2) % 10;
beijie = jiewei;
}
return results;
}

public static BigInteger add(BigInteger b1, BigInteger b2){
int[] add1 = b1.getInts();
int[] add2 = b2.getInts();

if((b1.isPositive() && b2.isPositive()) || (!b1.isPositive() && !b2.isPositive()))
{
return new BigInteger(BigInteger.add(add1,add2),b1.isPositive());
}
else
{
if(BigInteger.compare(add1,add2) > 0)
{
if(b1.isPositive())
{
return new BigInteger(BigInteger.minus(add1,add2), true);
}
else
{
return new BigInteger(BigInteger.minus(add1,add2), false);
}
}
else
{
if(b1.isPositive())
{
return new BigInteger(BigInteger.minus(add2,add1), false);
}
else
{
return new BigInteger(BigInteger.minus(add2,add1), true);
}
}
}
}

public static BigInteger minus(BigInteger b1, BigInteger b2) {
int[] add1 = b1.getInts();
int[] add2 = b2.getInts();

if(b1.isPositive() && !b2.isPositive())
{
return new BigInteger(BigInteger.add(add1,add2), true);
}
else if (!b1.isPositive() && b2.isPositive())
{
return new BigInteger(BigInteger.add(add1,add2), false);
}
else if(BigInteger.compare(add1,add2) > 0)
{
if(b1.isPositive())
{
return new BigInteger(BigInteger.minus(add1,add2), true);
}
else
{
return new BigInteger(BigInteger.minus(add1,add2), false);
}
}
else
{
if(b1.isPositive())
{
return new BigInteger(BigInteger.minus(add2,add1), false);
}
else
{
return new BigInteger(BigInteger.minus(add2,add1), true);
}
}
}

public String toString() {
return bigInt;
}

public String getBigInt() {
return bigInt;
}

public void setBigInt(String bigInt) {
this.bigInt = bigInt;
}


public boolean isPositive() {
return positive;
}

public void setPositive(boolean positive) {
this.positive = positive;
}

public int[] getInts() {
return ints;
}

public void setInts(int[] ints) {
this.ints = ints;
}

public static void main(String[] args) {
BigInteger b1 = new BigInteger(
"-1233332211111111111111112222222222222223333333333");
BigInteger b2 = new BigInteger(
"9222222222233949034949494112332211112222222229999");
System.out.println(b1);
System.out.println(b2);
System.out.println(BigInteger.minus(b1, b2));
System.out.println(BigInteger.add(b1, b2));
}
}

[syhan]

练算法的好东西

[leversss]

谢了