0
Ich versuche, meine eigene BigInteger-Klasse zu implementieren, wo die BigInt eine Liste ist, in der jedes Element eine Ziffer in der Zahl ist. Ich versuche, die Methode plus() zu implementieren, um zwei BigInts durch Rekursion miteinander zu verknüpfen.Rekursive Ergänzung für benutzerdefinierte BigInteger-Klasse
Obwohl ich Probleme mit meinem add() habe und bin mir nicht sicher, wie man die get-Methoden für diesen Fall implementieren.
public BigInt plus(BigInt operand){
List<Integer> a = this.getDigit();
List<Integer> b = operand.getDigit();
List<Integer> sum = new ArrayList<>();
if(a.size() > b.size()){
sum = add(a,b,0,sum);
} else {
sum = add(b,a,0,sum);
}
return new BigInt(sum);
}
private List<Integer> add(List<Integer> x, List<Integer> y, final int carry, List<Integer> result){
int sum;
int c = carry;
//if block is base case?
if(y.size() == 1){
sum = getSum(x,y,carry);
c = getCarry(result, sum);
if(sum>=10){
sum = (x.get(x.size()-1) + c);
x.remove(x.size()-1);
x.add(sum);
}
for(int i = x.size()-1; i >= 0; i--){
result.add(0,x.get(i));
}
return result;
}
//recursive case?
sum = getSum(x,y,carry);
c = getCarry(result,sum);
return this.add(x,y,c,result);
}
public int getSum(List<Integer> x, List<Integer> y, final int carry){
return 0;//PLACEHOLDER
}
public int getCarry(List<Integer> result, int sum){
return 0;//PLACEHOLDER
}
und meine Konstrukteurs
private BigInt(List<Integer> b){
this.digit = new ArrayList<>();
this.digit.addAll(b);
}
private BigInt(String str){
this.digit = new ArrayList<>();
String[] s = str.split("");
List<String> list = new ArrayList<>(Arrays.asList(s));
for(int i = 0; i < list.size(); i++){
int b = Integer.valueOf(list.get(i));
this.digit.add(b);
}
}
Müssen Sie Rekursion verwenden? Dies scheint für die Implementierung eines "BigInteger" -Objekts sehr kompliziert zu sein. – Jared
@ Jared ist richtig. Sie machen dieses ziemlich einfache Problem zu etwas ziemlich Kompliziertem. Rufen Sie getThis und getThat nicht an. Verwenden Sie einfach zwei Schleifen: eine für das Überlappen der Arrays und eine für den Rest des längeren Arrays. Addieren Sie einfach zusammen, sagen wir 9 + 7 = 16, also speichern Sie 6 und tragen Sie 1. Sagen Sie als nächstes 3 + 8 (+1 für Übertrag) = 12, also speichern Sie 2 und tragen Sie 1 usw. Die zweite Schleife muss nur die hinzufügen Trage und errichte den neuen Übertrag, falls vorhanden. Was Sie tun, ist viel zu kompliziert und zu kompliziert. –
Danke @RudyVelthuis Ich werde das heute Abend testen. Ich denke, mein Mangel an Verständnis mit Rekursion ist, warum ich es zu kompliziert bin (und die Rekursion hier ist der Punkt des Projekts). Die Idee für getSum und getCarry bestand darin, den Code zur besseren Lesbarkeit ein wenig mehr zu modulieren. – Alkarin