Die Grundlagen und die rekursive Lösung habe ich ja bereits beschrieben. Der Vollständigkeit halber, hier noch die iterativen Lösungen:
Die alte Variante funktioniert wie folgt:
fun ggt(a: Int, b: Int): Int {
var x = a
var y = b
if (a == 0) return b
while (y != 0) {
if (x > y) x -= y
else y -= x
}
return x
}
a und b müssen in separate, mutable Variablen überführt werden – also Felder, die veränderbar sind. Anschließend wird so lange eine Zahl von der anderen abgezogen, bis y = 0 ist.
Der moderne Algorithmus verwendet auch in der iterativen Implementierung den modulo Operator.
fun ggt(a: Int, b: Int): Int {
var x = a
var y = b
while (y != 0) {
val z = x.mod(y)
x = y
y = z
}
return x
}
Auch hier müssen die Parameter erst mutabel gemacht werden. Anschließend wird gerechnet. Das Ergebnis der Division mit Rest wird im Beispiel in dem Feld z zwischen gespeichert. Dieses kann immutable (unveränderbar) sein, da in jedem Schritt neu angelegt und nicht verändert wird. Natürlich ist auch eine Lösung möglich, die nur mutable Felder nutzt:
fun ggt(a: Int, b: Int): Int {
var x = a
var y = b
var z: Int
while (y != 0) {
z = x.mod(y)
x = y
y = z
}
return x
}
Wie so oft sind die iterativen Implementierungen mehr Code als die rekursiven Lösungen. Dafür sind sie in der Regel einfacher lesbar bzw. nachvollziehbar, wenn der Algorithmus komplexer wird.
Der Artikel Größter gemeinsamer Teiler (iterativ) erschien zuerst auf icancode.de.