KIV-Dokumentation. Buchholz, Stefan und Winkler, Jörg 25. Februar 2005

Transkript

1 KIV-Dokumentation Buchholz, Stefan und Winkler, Jörg 25. Februar 2005 KIV-Dokumentation und Beschreibung des Projektes AVL-Baum zur Lehrveranstaltung Programmverifikation. 1

2 Inhaltsverzeichnis 1 Aufgabenstellung 3 2 Grundlagen Datenstrukturen Datenstruktur natürliche Zahlen Datenstruktur Binärbaum Datenstruktur AVL-Baum Eigenschaften, Funktionen und Algorithmen Eigenschaft Balancefaktor Eigenschaft Höhe Funktion Einfügen Algorithmus Rotation KIV-Spezifikationen Binärbaum Struktur Binbaum Erweiterung Binbaumhöhe Erweiterung Binbaumordnung Binbaumerweiterung AVLbaum-Spezifikation AVL-Basis AVL-Bedingung Rechtsrotation Linksrotation Überkreuz-Rechtsrotation Überkreuz-Linksrotation Doppelrotation-Basis Doppelrotation AVL-Baum Weitere KIV-Spezifikationen 23 2

3 1 Aufgabenstellung Die Aufgabenstellung, die wir uns stellen ist die Spezifikation eines AVL-Baumes, mit den im Folgen beschriebenen Schwerpunkten. Um die Schwerpunkte spezifizieren zu können muss vorher eine theoretische Betrachtung geschehen. Da dies nicht Gegenstand der Vorlesung Programmverifikation ist wird diese Betrachtung kurz umrissen. Schwerpunkte Datenstrukturen: Element (natürliche Zahlen) Binärbaum AVL-Baum Eigenschaften: AVL Ausgeglichen Ist-AVL-Baum Ist-leer Ist-geordnet Ist-enthalten Funktionen: einfügen Höhe Algorithmen: Rechtsrotation Linksrotation Überkreuzrechtsrotation Überkreuzlinksrotation Doppelrotation 3

4 2 Grundlagen 2.1 Datenstrukturen Da der AVL-Baum laut Definition ein Binärbaum ist und in diesen Elemente eingefügt werden teilen wir diese komplexe Struktur auf. Wir benötigen Spezifikationen für die Elemente (im speziellen natürliche Zahlen), sowie eine Spezifikation des Binärbaumes, welche wir dann mit Hinzunahme der AVL-Bedingung zu einem AVL-Baum erweitern können. Die Spezifikationen werden im Kapitel näher beschrieben. In diesem Kapitel werden die Definitionen der oben genannten Datenstrukturen festgelegt Datenstruktur natürliche Zahlen Nat (natürliche Zahlen) stellt eine einfache Datenstruktur dar, die in einen Binärbaum eingefügt werden kann. Da diese Struktur mit der Spezifikation in der KIV-Bibliothek identisch ist und keine weiteren Eigenschaften bzw. Funktionen hinzukommen, wird diese im weiteren Verlauf nicht weiter betrachtet. Jedoch eine wichtige Eigenschaften, der natürlichen Zahlen, die im Verlauf genutzt werden muss, ist die Ordnungrelation (Bibliothek: nat-min) Datenstruktur Binärbaum Um mit dem Begriff Binärbaum diskutieren zu können benötigt es einer vorherigen Definition des Begriffes Baum. Trotz dessen sei an dieser Stelle erwähnt, dass der Binärbaum kein Sonderfall eines Baumes ist. Definition Baum Ein Baum ist eine liche Menge B eines oder mehrerer Knoten derart, dass es ein ausgezeichnetes Element, Wurzel genannt, gibt die übrigen Knoten in m 0 disjunkte Mengen aufgeteilt sind und jede dieser Mengen (Teilbäume) ein Baum ist Bemerkung: Diese Definition ist rekursiv, jeder Knoten eines Baumes ist Wurzel eines Teilbaumes. Falls der Grad (Anzahl der Teilbäume) eines Knotens = 0, so nennt man den Knoten Blatt. Definition Binärbaum Ein Binärbaum B ist eine geordnete liche Menge von Knoten, die entweder leer ist oder aus 2 Binärbäumen {B 1, B 2 } besteht. Bemerkung: B1 heißt linker Teilbaum und B2 heißt rechter Teilbaum von B. Handelt es sich um eine leere Menge, sprechen wir von einem Blatt. Weiterhin stehen die Informationen im Binärbaum sowohl in den Knoten, als auch in den Blättern. Durch eine gegebene Ordnung stehen die Daten, die der Ordnung nach kleineren sind, als die im betrachteten Knoten, im linken Teilbaum. Die, die der Ordnung nach größer sind, als die im betrachteten Knoten, stehen im rechtem Teilbaum. 4

5 2.1.3 Datenstruktur AVL-Baum Definition der AVL-Bedingung Sei k ein beliebiger Knoten für einen Binärbaum. Der Knoten k erfüllt die AVL-Bedingung, wenn für seine beiden Teilbäume k.l (linker Teilbaum) und k.r (rechter Teilbaumbaum) gilt: (h(k.l) h(k.r)) { 1, 0, 1} Ein Knoten erfüllt die AVL-Bedingung also genau dann, wenn sich die Höhen seiner beiden Teilbäume höchstens um 1 unterscheiden. Definition AVL-Baum Ein AVL-Baum B ist ein Binärbaum, für den gilt: Alle Knoten des Baumes B erfüllen die AVL-Bedingung. 2.2 Eigenschaften, Funktionen und Algorithmen Eigenschaft Balancefaktor Diese Eigenschaft ist wichtig für die Einhaltung der AVL-Bedingung und ist wie folgt zu betrachten: bal(p) = Höhe des rechten Teilbaumes von p - Höhe des linken Teilbaumes von p Eigenschaft Höhe Ist die Länge eines Pfades von der Wurzel zu dem am weitesten entfernten Blattes des Baumes. Ein Blatt hat die Höhe Funktion Einfügen Diese Funktion ermöglicht es ein neues Element zum Baum hinzu zufügen. Das Einfügen erfolgt nach einer vorgegebenen Ordnung. Dabei kann es dazu kommen, dass die AVL-Bedingung verletzt wird. In diesem Fall muss nach Ausführung der Einfügeoperation eine Balancierung vorgenommen werden. Diesen Balancierungsalgorithmus betrachten wir weiter unten Algorithmus Rotation Einfache Rotation Einfache Rotationen verwet man, nachdem ein neues Element außen an einen AVL-Baum angehängt wurde und der Baum dadurch unbalanciert wird. Dabei unterscheiden wir zwei Richtungen der Rotation: Linksrotation, falls bal(p) des Knotens p < 1 ist (d.h. die Höhe des linken Teilbaums ist größer als die Höhe des rechten Teilbaumes und zwar so, dass die AVL-Bedingung des Knoten p verletzt wurde). Rechtsrotation, falls bal(p) des Knotens p > 1 ist. 5

6 Überkreuz-Zug Abbildung 1: Rechtsrotation - Knoten 7 verletzt die AVL-Bedingung Eine Komplikation könnte entstehen, wenn der rechte Unterknoten des Knotens, der die AVL-Bedingung verletzt, einen rechten und linken Teilbaum hat. In diesem Fall wird statt einer einfachen Rotation ein Überkreuz-Zug notwig. Abbildung 2: Überkreuz-Zug mit Rechtsrotation - Knoten 9 verletzt die AVL-Bedingung und Knoten 8 muss ebenfalls umgehängt werden 6

7 Doppelrotation Doppelrotation benötigt man, wenn ein neues Element in der Mitte an einem AVL-Baum angehängt wird, und der Baum dadurch die Balance verliert. Eine Doppelrotation besteht aus zwei Einzelrotationen: Der Knoten wird im rechten Teilbaumeingehängt Linksrotation, gefolgt von Rechtsrotation Der Knoten wird im linken Teilbaum eingehängt Rechtsrotation, gefolgt von Linksrotation Abbildung 3: Doppelrotation mit Links-/Rechtsrotation - Knoten 9 verletzt die AVL-Bedingung, nach Linksrotation verletzt dann der Knoten 8 die AVL-Bedingung Rechtsrotation 7

8 3 KIV-Spezifikationen In diesem Kapitel beschreiben wir unsere Gedankengänge und die Spezifikationen. Dabei gehen wir den Spezifikationsbaum von unten nach oben durch. 3.1 Binärbaum Im nachflogem wollen wir die Struktur des Binärbaumes behandeln und die wesentlichen Eigenschaften, die für den AVL-Baum relevant sind Struktur Binbaum Ausgeh von unserer Binärbaumdefinition kann ein solcher Baum aus einem leeren Baum (im Folgen bezeichnet), einem Blatt oder einem Knoten mit einem linken und rechten Teilbaum bestehen. Weiterhin haben wir in der Definition gefordert, dass Daten in den Blättern sowie in den Knoten stehen. Dies führt zu folgen Überlegungen: Der einfachste Fall ist der leere welcher keine Daten beinhaltet. Das Blatt wiederum beinhaltet nur ein Datenfeld. Ein Knoten besitzt ebenfalls ein Datenfeld. Zusätzlich beinhaltet er Verweise auf seine Teilbäume, die wiederum Binärbäume sind. Hiermit sind die Binärbäume benannt. Um einen Zugriff auf die Elemnete eines Binärbaumes zu erhalten benötigt man Selektoren welche jetzt erläutert werden: Mit dem Selektor.daten erhält man die Daten aus einem Knoten und einem Blatt. Die Selektoren.rechts und.links liefern den rechten bzw. linken Teilbaum eines Knotens. Diese Überlegungen führen zu nachfolger Spezifikation: binbaum = generic data specification parameter nat-min binbaum = binblatt (..daten : nat ;) binknoten (..links : binbaum ;..daten : nat ;..rechts : binbaum ; variables bb 3, bb 2, bb 1, bb: binbaum; generic data specification Generated axioms: binbaum freely generated binblatt, binknoten; disj : binblatt(m) binknoten(bb, m 0, bb 0 ); disj : disj : binknoten(bb, m, bb 0 sel : binknoten(bb, m, bb 0 ).rechts = bb 0 ; sel : binknoten(bb, m, bb 0 ).daten = m; sel : binknoten(bb, m, bb 0 ).links = bb; sel : binblatt(m).daten = m; inj : binknoten(bb, m, bb 0 ) = binknoten(bb 1, m 0, bb 2 ) bb = bb 1 m = m 0 bb 0 = bb 2 ; 8

9 inj : binblatt(m) = binblatt(m 0 ) m = m 0 ; case : bb = binblatt(bb.daten) bb = binknoten(bb.links, bb.daten, bb.rechts) bb Erweiterung Binbaumhöhe Der Hauptgedanke, welcher zur Erweiterung des Binärbaumes führte, ist die Notwigkeit eine Aussage über die Ausgeglichenheit von Bäumen zu treffen (dazu später mehr). Durch die Definition eines Binärbaumes ergeben sich diese und Blätter besitzten die Höhe 0. Die Höhe eines Knoten ergibt sich aus dem Maximum der Höhen seiner Kinder + 1. Durch diese Merkmale besteht die Möglichkeit einer rekursiven Funktion. Nachsteh nun die sich daraus ergeben Axiome: binbaum-hoehe = enrich binbaum with functions hoehe : binbaum nat ; axioms hoehe(@) = 0; hoehe(binblatt(n)) = 0; hoehe(binknoten(bb, n, bb 0 )) = max(hoehe(bb), hoehe(bb 0 )) + 1; enrich Erweiterung Binbaumordnung Aus der Überlegung über die Binbaumhöhe ergibt sich zwing eine weitere Erfordernis. Für die Beschreibung eines AVL-Baumes benötigen wir eine Erweiterung der Binärbäume, um eine Datenordnung. Diese Ordnung soll die Datenelemente in einer bestimmten Reihenfolge im Baum speichern. Wir legen uns auf diese Merkmale ist geordnet Ein Blatt ist geordnet, da nur ein Datenelement vorhanden ist. In einem Knoten mit einem Datenelement n, muss laut Definition der Ordnung die Daten n 0 des rechten Teilbaumes B 1, n 0 n sein. Dabei ist zwing erforderlich, dass B 1 nicht ist und dass B 1 und B 2 ebenfalls geordnet sind. Für die Daten n 1 des linken Teilbaumes B 2 eines Knoten gilt, dass n 1 > n ist und B 2 ist, sowie das B 1 und B 2 ebenfalls geordnet sind. Der Ausschluss ist damit zu begründen, keine Daten enthalten kann und somit keine Relation besteht. Ist ein Knoten geordnet, so sind auch seine Teilbäume geordnet. 9

10 Diese Merkmale spiegeln sich in diesen Axiomen wieder: binbaum-ordnung = enrich binbaum with predicates istgeordnet : binbaum; axioms istgeordnet(@); istgeordnet(binblatt(n)); istgeordnet(binknoten(bb, n, bb 0 )) istgeordnet(bb) istgeordnet(bb 0 ); istgeordnet(bb 0 ) istgeordnet(bb) binknoten(bb, n, bb 0 ).daten bb.daten istgeordnet(binknoten(bb, n, bb 0 )); enrich bb istgeordnet(bb) istgeordnet(bb 0 ) binknoten(bb, n, bb 0 ).daten < bb 0.daten istgeordnet(binknoten(bb, n, bb 0 )); Binbaumerweiterung Die soeben getroffenen Erweiterungen werden zu einer Union zusammengefasst, damit wir diese beiden Merkmale gemeinsam nutzen können. Diese Zusammenfassung wird jetzt beschrieben: binbaum-erweitert = binbaum-hoehe + binbaum-ordnung 3.2 AVLbaum-Spezifikation Da die für unsere Zwecke wesentlichen Merkmale des Binärbaumes beschrieben wurden sind, erfolgt nun die schrittweise Einführung des AVL-Baumes mit seinen Eigenschaften, Algorithmen und Funktionen AVL-Basis Hier werden die notwigen Umbenennungen vorgenommen, da wir ab jetzt nicht mehr von einem Binärbaum sprechen wollen. Hierzu gehören unter anderem die Umbenennung der Knoten und Blätter in AVL-Knoten und AVL-Blätter. avl-basis = rename binbaum-erweitert by morphism binknoten avlknoten; binblatt avlblatt;.daten.daten;.links.links;.rechts.rechts; hoehe hoehe; istgeordnet istgeordnet; bb avlb; bb 0 avlb 0 ; bb 1 avlb 1 ; bb 2 avlb 2 ; bb 3 avlb 3 rename 10

11 3.2.2 AVL-Bedingung Wir benötigen zur Feststellung der AVL-Bedingung, die wir oben definiert haben, ein Prädikat welches uns bei der Erstellung eines AVL-Baumes unterstützt und uns somit sagt, dass dieses wichtige Merkmal erfüllt ist. Die Erfüllung der Definition führt zu diesen ist ausgeglichen, da er keine Kinder besitzt, die die Balance gefährden. Das Blatt ist aus selben Gründen ausgeglichen. Ein AVL-Knoten ist ausgeglichen, wenn für ihn gilt: B 1 und B 2 = AVLBlatt, da dass AVLBlatt die Höhe 0 besitzen und somit die Balance nicht gefährden Dasselbe gilt, wenn die Kinder vertauscht sind Jetzt muss der Fall betrachtet werden, wo die beiden Teilbäume eines Knoten sind. Dabei ist für B 1 und B 2 gefordert, dass diese die AVL-Bedingung erfüllen. Weiterhin muss gelten, dass die Funktion bal(p) eingehalten wird. Bei der Gestaltung der Axiome muss darauf geachtet werden, dass die Ergebnisse der Subtraktion den Wertebereich der nat-spezifikation nicht verlassen, welches durch eine Falluntersceidung geschieht. avl-bedingung = enrich avl-basis with predicates avl ausgeglichen : avlbaum; axioms avl ausgeglichen(@); avl ausgeglichen(avlblatt(n)); avl ausgeglichen(avlknoten(@, n, avlblatt(n 0 ))); avl ausgeglichen(avlknoten(avlblatt(n 0 ), enrich avlb avl ausgeglichen(avlb) avl ausgeglichen(avlb 0 ) hoehe(avlb) hoehe(avlb 0 ) hoehe(avlb 0 ) - hoehe(avlb) 1 avl ausgeglichen(avlknoten(avlb, n, avlb 0 )); avlb avl ausgeglichen(avlb) avl ausgeglichen(avlb 0 ) hoehe(avlb) > hoehe(avlb 0 ) hoehe(avlb) - hoehe(avlb 0 ) 1 avl ausgeglichen(avlknoten(avlb, n, avlb 0 )); 11

12 3.2.3 Rechtsrotation Die nächsten Abschnitte beschreiben die Rotationen, die den AVL-Baum im wesentlichen mit Charakteresieren. Wir haben uns entschieden die jeweiligen Rotationen einzeln zu betrachen. Angefangen in diesem Abschnitt mit der Rechtsrotation. Diese Aufteilung soll nach dem Teile und Herrsche - Prinzip die Implementation vereinfachen. Folge Eigenschaften liegen der Rechtsrotation zugrunde: Ein geordneter AVL-Baum ist nach Ausführung einer Rechtsrotation weiterhin geordnet. Ebenfalls gilt anderes herum, dass der Ausgangsbaum eines rechts-rotierten AVL-Baumes ebensfalls geordnet ist. Dies begründet sich darin, dass die Rechtsrotation die Ordnung nicht verändert. Die Rechtsrotaion liefert in zwei Fällen garantiert einen AVL-Baum, der die AVL-Bedingung erfüllt. Diese Fälle sind oben schon beschrieben. Die Spezifikation der Rechtsrotation ist als Erstes abgebildet, gefolgt von der Implementation des Rechtsrotation-Modules. avl-rechtsrotation = enrich avl-bedingung with functions rechtsrotation : avlbaum avlbaum ; axioms avl ausgeglichen(rechtsrotation(avlknoten(avlknoten(avlblatt(n), n n avl ausgeglichen(rechtsrotation(avlknoten(avlknoten(avlblatt(n), n n 1, avlblatt(m)))); istgeordnet(avlb) istgeordnet(rechtsrotation(avlb)); enrich avl-rechtsrotation = module export avl-rechtsrotation refinement representation of operations rechtsr# implements rechtsrotation; implementation import avl-bedingung declaration rechtsr#(avlb; var avlb 0 ) var avlb 1 in if avlb = avlknoten(avlknoten(avlblatt(avlb.links.links.daten), avlb.daten, avlb.rechts) then if then if avlb.rechts = avlblatt(avlb.rechts.daten) then avlb 1 := avlknoten(@, avlb.daten, avlblatt(avlb.rechts.daten)) 12

13 avlb 1 := avlblatt(avlb.daten); avlb 0 := avlknoten(avlb.links.links, avlb.links.daten, avlb 1 ) uniform restriction declarations: rechtsr#(avlb; var avlb 0 ) var avlb 1 in if avlb = avlknoten(avlknoten(avlblatt(avlb.links.links.daten), avlb.daten, avlb.rechts) then if then if avlb.rechts = avlblatt(avlb.rechts.daten) then avlb 1 := avlknoten(@, avlb.daten, avlblatt(avlb.rechts.daten)) avlb 1 := avlblatt(avlb.daten); avlb 0 := avlknoten(avlb.links.links, avlb.links.daten, avlb 1 ) Linksrotation Dies ist die seitenverkehrte Betrachtung der Rechtsrotation und beinhaltet die gleichen Merkmale. avl-linksrotation = enrich avl-bedingung with functions linksrotation : avlbaum avlbaum ; axioms istgeordnet(avlb) istgeordnet(linksrotation(avlb)); avl ausgeglichen(linksrotation(avlknoten(@, n 1, avlknoten(@, n 0, avlblatt(n))))); avl ausgeglichen(linksrotation(avlknoten(avlblatt(m), n 1, avlknoten(@, n 0, avlblatt(n))))); enrich avl-linksrotation = module export avl-linksrotation refinement 13

14 representation of operations linksr# implements linksrotation; implementation import avl-bedingung declaration linksr#(avlb; var avlb 0 ) var avlb 1 in if avlb = avlknoten(avlb.links, avlb.daten, avlknoten(@, avlb.rechts.daten, avlblatt(avlb.rechts.rechts.daten))) then if then if avlb.links = avlblatt(avlb.links.daten) then avlb 1 := avlknoten(avlblatt(avlb.links.daten), avlb 1 := avlblatt(avlb.daten); avlb 0 := avlknoten(avlb 1, avlb.rechts.daten, avlb.rechts.rechts) uniform restriction declarations: linksr#(avlb; var avlb 0 ) var avlb 1 in if avlb = avlknoten(avlb.links, avlb.daten, avlknoten(@, avlb.rechts.daten, avlblatt(avlb.rechts.rechts.daten))) then if then if avlb.links = avlblatt(avlb.links.daten) then avlb 1 := avlknoten(avlblatt(avlb.links.daten), avlb 1 := avlblatt(avlb.daten); avlb 0 := avlknoten(avlb 1, avlb.rechts.daten, avlb.rechts.rechts) 14

15 3.2.5 Überkreuz-Rechtsrotation Bei dieser Rotation handelt es sich wie schon beschrieben um einen Spezialfall der Rechtsrotation. Hier werden die gleichen Merkmale gefordert wie bei den vorangegangenen Rotationen. Der wesentliche Unterschied begründet sich auf die Einmaligkeit des zu rotieren AVL-Baumes. Die Abbildung 2 zeigt diesen Spezialfall. avl-rechts-ueberkreuz = enrich avl-bedingung with functions ueberkreuzrechtsrotation : avlbaum avlbaum ; variables n 5, n 4, n 3, n 2 : nat; axioms istgeordnet(ueberkreuzrechtsrotation(avlb)) istgeordnet(avlb); avl ausgeglichen(ueberkreuzrechtsrotation(avlknoten(avlknoten(avlknoten(avlblatt(n 4 ), n n 3, avlblatt(n 2 )), n, avlblatt(n 1 )))); enrich avl-rechts-ueberkreuz = module export avl-rechts-ueberkreuz refinement representation of operations ueberrechtsr# implements ueberkreuzrechtsrotation; implementation import avl-bedingung declaration ueberrechtsr#(avlb; var avlb 0 ) var avlb 1 avlb 2 in if avlb = avlknoten(avlknoten(avlknoten(avlblatt(avlb.links.links.links.daten), avlb.links.daten, avlblatt(avlb.links.rechts.daten)), avlb.daten, avlblatt(avlb.rechts.daten)) then avlb 1 := avlblatt(avlb.links.rechts.daten); avlb 2 := avlknoten(avlb 1, avlb.daten, avlb.rechts); avlb 0 := avlknoten(avlb.links.links, avlb.links.daten, avlb 2 ) uniform restriction declarations: ueberrechtsr#(avlb; var avlb 0 ) var avlb 1 avlb 2 in if avlb = avlknoten(avlknoten(avlknoten(avlblatt(avlb.links.links.links.daten), avlb.links.daten, avlblatt(avlb.links.rechts.daten)), avlb.daten, avlblatt(avlb.rechts.daten)) 15

16 then avlb 1 := avlblatt(avlb.links.rechts.daten); avlb 2 := avlknoten(avlb 1, avlb.daten, avlb.rechts); avlb 0 := avlknoten(avlb.links.links, avlb.links.daten, avlb 2 ) Überkreuz-Linksrotation Bei diesem Fall der Rotation betrachten wir, analog zur Linksrotation, den seitenverkehrten Fall der Überkreuz-Rechtsrotation. Die Merkmale bleiben erhalten. avl-links-ueberkreuz = enrich avl-bedingung with functions ueberkreuzlinksrotation : avlbaum avlbaum ; variables n 5, n 4, n 3, n 2 : nat; axioms istgeordnet(avlb) istgeordnet(ueberkreuzlinksrotation(avlb)); avl ausgeglichen(ueberkreuzlinksrotation(avlknoten(avlblatt(n), n 1, avlknoten(avlblatt(n 3 ), n 2, avlknoten(@, n 4, avlblatt(n 5 )))))); enrich avl-links-ueberkreuz = module export avl-links-ueberkreuz refinement representation of operations ueberlinksr# implements ueberkreuzlinksrotation; implementation import avl-bedingung declaration ueberlinksr#(avlb; var avlb 0 ) var avlb 1 avlb 2 in if avlb = avlknoten(avlblatt(avlb.links.daten), avlb.daten, avlknoten(avlblatt(avlb.rechts.links.daten), avlb.rechts.daten, avlknoten(@, avlb.rechts.rechts.daten, avlblatt(avlb.rechts.rechts.rechts.daten)))) then avlb 1 := avlblatt(avlb.rechts.links.daten); avlb 2 := avlknoten(avlb.links, avlb.daten, avlb 1 ); avlb 0 := avlknoten(avlb 2, avlb.rechts.daten, avlb.rechts.rechts) 16

17 uniform restriction declarations: ueberlinksr#(avlb; var avlb 0 ) var avlb 1 avlb 2 in if avlb = avlknoten(avlblatt(avlb.links.daten), avlb.daten, avlknoten(avlblatt(avlb.rechts.links.daten), avlb.rechts.daten, avlknoten(@, avlb.rechts.rechts.daten, avlblatt(avlb.rechts.rechts.rechts.daten)))) then avlb 1 := avlblatt(avlb.rechts.links.daten); avlb 2 := avlknoten(avlb.links, avlb.daten, avlb 1 ); avlb 0 := avlknoten(avlb 2, avlb.rechts.daten, avlb.rechts.rechts) Doppelrotation-Basis Für die Doppelrotation wird eine Kombination aus Rechts- und Linksrotation sowie den beiden Überkreuz-Rotationen benötigt. Aus diesem Grund muss eine Zusammenführung stattfinden. avl-doppelrotation-basis = avl-rechtsrotation + avl-linksrotation + avl-rechts-ueberkreuz + avl-links-ueberkreuz Doppelrotation Die Doppelrotation kommt in allen anderen Fällen in Betrachtung, die nicht durch die zuvor spezifizierten und implementierten Rotationen abgedeckt wurden. Dies sind laut der oben genannten Definition alle AVL-Bäume, die nach Einfügen eines Elementes in der Mitte die AVL-Bedingung nicht mehr erfüllen. Wie schon oben betrachtet, verändert die Doppelrotation die Ordnung des AVL-Baumes nicht. avl-doppelrotation = enrich avl-doppelrotation-basis with functions doppelrotation : avlbaum avlbaum ; axioms istgeordnet(avlb) istgeordnet(doppelrotation(avlb)); enrich avl-doppelrotation = module export avl-doppelrotation refinement representation of operations doppelr# implements doppelrotation; 17

18 implementation import avl-doppelrotation-basis declaration doppelr#(avlb; var avlb 0 ) var avlb 1 = avlb, avlb 2 = avlb in if hoehe(avlb.links) > hoehe(avlb.rechts) then if then avlb 1 := linksrotation(avlb.links); avlb 2 := avlknoten(avlb 1, avlb.daten, avlb.rechts); avlb 0 := ueberkreuzrechtsrotation(avlb 2 ) avlb 1 := ueberkreuzlinksrotation(avlb.links); avlb 2 := avlknoten(avlb 1, avlb.daten, avlb.rechts); avlb 0 := rechtsrotation(avlb 2 ) if then avlb 1 := rechtsrotation(avlb.rechts); avlb 2 := avlknoten(avlb.links, avlb.daten, avlb 1 ); avlb 0 := ueberkreuzlinksrotation(avlb 2 ) avlb 1 := ueberkreuzrechtsrotation(avlb.rechts); avlb 2 := avlknoten(avlb.links, avlb.daten, avlb 1 ); avlb 0 := linksrotation(avlb 2 ) uniform restriction declarations: doppelr#(avlb; var avlb 0 ) var avlb 1 = avlb, avlb 2 = avlb in if hoehe(avlb.links) > hoehe(avlb.rechts) then if then avlb 1 := linksrotation(avlb.links); avlb 2 := avlknoten(avlb 1, avlb.daten, avlb.rechts); avlb 0 := ueberkreuzrechtsrotation(avlb 2 ) avlb 1 := ueberkreuzlinksrotation(avlb.links); avlb 2 := avlknoten(avlb 1, avlb.daten, avlb.rechts); avlb 0 := rechtsrotation(avlb 2 ) if then 18

19 avlb 1 := rechtsrotation(avlb.rechts); avlb 2 := avlknoten(avlb.links, avlb.daten, avlb 1 ); avlb 0 := ueberkreuzlinksrotation(avlb 2 ) avlb 1 := ueberkreuzrechtsrotation(avlb.rechts); avlb 2 := avlknoten(avlb.links, avlb.daten, avlb 1 ); avlb 0 := linksrotation(avlb 2 ) AVL-Baum In dieser Spezifikation werden die vorher definierten Eigenschaften und Funktionen zur AVL-Baum-Spezifikation zusammen geführt. Die Rotationsfunktionen unterstützen die Einfüge-Funktion des AVL-Baumes. Sie gewährleisten die Einhaltung der AVL-Bedingung und der Datenordnung, bei Einfügen eines Daten-Elementes in einen bestehen AVL-Baumes. Der wesentliche Unterschied zu den vorher betrachten Modulen ist, dass der Ausgangsbaum, ein AVL-Baum, die AVL-Bedingung bereits besitzt. Des weiteren möchten wir einige Prädikate nutzen, welche den Funktionsumfang des AVL-Baumes erweitern. Dabei betrachten wir die Prädikate istenthalten, dieses überprüft das vorhanden sein eines Elementes im AVL-Baum, istleer, zum testen ob der Baum ist und Istavlbaum welches die Eigenschaften der Spezifikation zusammenfasst. Diese Gedanken müssen dabei beachtet werden: Bildet das Prädikatik istleer einen AVL-Baum nach wahr ab, so impliziert das, dass ist, da nur leer ist. Das Prädkat istenthalten sucht rekursiv einen AVL-Baum von der Wurzel zum Blatt durch. Dabei muss es die Ordnungsrelation beachten und unter diesen Bedingungen muss der Algorithmus den Baum von Kind zu Kind entlanggehen. Wenn es dabei auf ein Element trifft das gleich dem zu Suchen Element ist, wird das Prädikatt true. Wenn die Suche in einem Blatt et und das Datenelement des Blattes ungleich dem zu Suchen, ist das Prädikat false. Trifft die Suche so ergibt sich ebenfalls false. Bei istavlbaum fasst die Eigenschaften istgeordnet und avlausgeglichen zusammen. avlbaum = enrich avl-basis2 with functions einfuegen : avlbaum nat avlbaum ; predicates istenthalten : avlbaum nat; istleer : avlbaum; istavlbaum : avlbaum; axioms istavlbaum(avlb) avl ausgeglichen(avlb) istgeordnet(avlb); istavlbaum(avlb) istavlbaum(einfuegen(avlb, n)); istavlbaum(avlblatt(n)); istgeordnet(einfuegen(avlb, n)) istgeordnet(avlb); istleer(avlb) avlb istenthalten(einfuegen(avlb, n), n); 19

20 enrich avl-funktion = module export avlbaum refinement representation of operations einfuegen# implements einfuegen; istleer# implements istleer; istavlbaum# implements istavlbaum; istenthalten# implements istenthalten; implementation import avl-basis2 variables e: bool; declaration istleer#(avlb; var e) if avlb then e := true e := false ; istavlbaum#(avlb; var e) if avl ausgeglichen(avlb) istgeordnet(avlb) then e := true e := false; istenthalten#(avlb, n; var e) if avlb then e := false if avlb.daten = n then e := true if avlb = avlblatt(avlb.daten) then e := false if avlb.daten n then istenthalten#(avlb.links, n; e) istenthalten#(avlb.rechts, n; e); einfuegen#(avlb, n; var avlb 0 ) var avlb 1 in if avlb then latt(n) if avlb = avlblatt(avlb.daten) then if avlb.daten n then avlb 0 := avlknoten(avlblatt(n), avlb 0 := avlknoten(@, avlb.daten, avlblatt(n)) if avlb.daten n then einfuegen#(avlb.links, n; avlb 1 ); avlb 0 := avlknoten(avlb 1, avlb.daten, avlb.rechts) einfuegen#(avlb.rechts, n; avlb 1 ); avlb 0 := avlknoten(avlb.links, avlb.daten, avlb 1 ) ; if avl ausgeglichen(avlb 0 ) then if hoehe(avlb 0.links) = 1 avlb then if avlb 0.links.rechts then avlb 0 := rechtsrotation(avlb 0 ) 20

21 avlb 0 := doppelrotation(avlb 0 ) if hoehe(avlb 0.rechts) = 1 avlb then if avlb 0.rechts.links then avlb 0 := linksrotation(avlb 0 ) avlb 0 := doppelrotation(avlb 0 ) if hoehe(avlb 0.links) = 2 then if hoehe(avlb 0.links.links) = 1 avlb then avlb 0 := ueberkreuzrechtsrotation(avlb 0 ) avlb 0 := doppelrotation(avlb 0 ) if hoehe(avlb 0.rechts.rechts) = 1 avlb then avlb 0 := ueberkreuzlinksrotation(avlb 0 ) avlb 0 := doppelrotation(avlb 0 ) skip uniform restriction declarations: istleer#(avlb; var e) if avlb then e := true e := false ; istavlbaum#(avlb; var e) if avl ausgeglichen(avlb) istgeordnet(avlb) then e := true e := false; istenthalten#(avlb, n; var e) if avlb then e := false if avlb.daten = n then e := true if avlb = avlblatt(avlb.daten) then e := false if avlb.daten n then istenthalten#(avlb.links, n; e) istenthalten#(avlb.rechts, n; e); einfuegen#(avlb, n; var avlb 0 ) var avlb 1 in if avlb then latt(n) if avlb = avlblatt(avlb.daten) then if avlb.daten n then avlb 0 := avlknoten(avlblatt(n), avlb 0 := avlknoten(@, avlb.daten, avlblatt(n)) if avlb.daten n then einfuegen#(avlb.links, n; avlb 1 ); avlb 0 := avlknoten(avlb 1, avlb.daten, avlb.rechts) einfuegen#(avlb.rechts, n; avlb 1 ); avlb 0 := avlknoten(avlb.links, avlb.daten, avlb 1 ) ; if avl ausgeglichen(avlb 0 ) then if hoehe(avlb 0.links) = 1 avlb then 21

22 if avlb 0.links.rechts then avlb 0 := rechtsrotation(avlb 0 ) avlb 0 := doppelrotation(avlb 0 ) if hoehe(avlb 0.rechts) = 1 avlb then if avlb 0.rechts.links then avlb 0 := linksrotation(avlb 0 ) avlb 0 := doppelrotation(avlb 0 ) if hoehe(avlb 0.links) = 2 then if hoehe(avlb 0.links.links) = 1 avlb then avlb 0 := ueberkreuzrechtsrotation(avlb 0 ) avlb 0 := doppelrotation(avlb 0 ) if hoehe(avlb 0.rechts.rechts) = 1 avlb then avlb 0 := ueberkreuzlinksrotation(avlb 0 ) avlb 0 := doppelrotation(avlb 0 ) skip 22

23 4 Weitere KIV-Spezifikationen Im Laufe der Bearbeitung des Projektes benötigten wir ein Paar von nat-zahlen. Daraus beruhen die folgen Spezifikationen. Diese sind jedoch für die AVL-Baumspezifikation nicht mehr von Belang. Sie dokumentieren jedoch den Umgang mit dem KIV-Programm. nat1 = rename nat by morphism nat nat1; 0 0; 1 1; 2 2; +1 +1; -1-1; + +; - -; < <; ; > >; ; m n1m; n n1n; n 0 n1n 0 ; n 1 n1n 1 rename nat2 = rename nat by morphism nat nat2; 0 0; 1 1; 2 2; +1 +1; -1-1; + +; - -; < <; ; > >; ; m n2m; n n2n; n 0 n2n 0 ; n 1 n2n 1 rename nat12 = nat1 + nat2 nat-paar = actualize pair with nat12 by morphism elem1 nat1; elem2 nat2; ;.1.1;.2.2; e1a n1m; e1a 0 n1n; e1b n1n 0 ; e1c n1n 1 ; e2a n2m; e2a 0 n2n; e2b n2n 0 ; e2c n2n 1 actualize avl-basis2 = avl-doppelrotation + nat-paar 23