So. Willkommen zur Vorlesung. Algorithmen und Datenstrukturen. Wir beschäftigen
uns gerade mit dem Sortieren. Und das letzte Verfahren,
was wir uns in der letzten Vorlesung angeschaut haben,
wo wir eigentlich noch nicht so ganz mit durch sind,
aber fast, ist der Heep-Sort.
Die Grundidee beim Heep-Sort ist folgende Datenstruktur. Wir haben einen Baum,
der eine spezielle Eigenschaft hat, nämlich die Eigenschaft,
dass die Elemente, die hierrin gespeichert sind,
so aufgebaut sind,
dass der Wert in einem Vorgängerknoten immer größer ist
als der von den beiden Nachfolgern
Okay, das nennen wir einen Maxim. Diese Datenstruktur,
die bauen wir nicht wirklich, bezeigern, sondern wir nehmen das Array,
wo die Informationen sowieso drinsteht und speichern diesen Baum implizit,
indem wir einfach die mathematischen Operationen,
ganzzeitige Divisionen und Multiplikationen mit zwei nehmen,
um jeweils die entsprechenden Positionen in dem Array zu finden,
wo dann der Vorgänger oder der linke oder rechte Nachfolger stehen.
Also immer wenn wir durch zwei dividieren,
kommen wir in dem Array zum Vorgänger,
wenn wir mit zwei multiplizieren,
kommen wir zum linken Nachfolger und wenn wir mit
zwei multiplizieren und eins addieren zum rechten
Das ist hier nochmal dargestellt. Ganz wichtig für so einen Hieb ist,
dass dieser Baum links vollständig ist. Das heißt,
wir haben die Ebenen vollständig und hier sehen wir die letzte Ebene,
ist dann gegebenenfalls nicht mehr vollständig,
aber wenn dann da nur ein Teil der möglichen Werte stehen,
dann stehen die immer ganz auf der linken Seite.
So ist also der Hieb aufgebaut und dann haben wir
uns angeschaut, wie wir mit dem Hieb arbeiten können.
Der Heeb-Sort selber nimmt also immer das oberste Element aus dem
Hieb heraus.
Das ist schon
eine falsche Richtung
Der Heep-Source selber nimmt also das oberste Element aus dem Heep
heraus in dieser Schleife und rearrangiert den Hieb dann so,
dass danach das nächste verbleibende größte Element oben im Hieb drinsteht.
Das machen wir, indem wir den vorderen Teil des Arrays
als Heep interpretieren und in dem hinteren Teil speichern wir dann jeweils die größten Elemente,
die wir schon aus dem Hieb herausgenommen haben und nach hinten geschoben haben.
Um den Heep zu reparieren, haben wir die Max Hipify-Operation gesehen,
die macht Folgendes. Wenn wir eine Stelle haben,
wo der Heep defect ist,
in dem Beispiel ist es hier die Wurzel,
Dann nehmen wir diesen Knoten, vergleichen den mit seinen beiden Nachfolgern,
nehmen das Größte von diesen drei Elementen und schieben das in diesen Knoten rein und vertauschen damit die Werte.
Auf diese Art und Weise verschieben wir die Fehlstelle, also die Stelle,
wo der Hieb defekt ist, um eine Ebene nach unten.
Und das machen wir dann so weiter, bis wir an
einem Blatt sind und da können wir die Hieb-Eigenschaft nicht mehr verletzen.
Wenn wir ein Element aus dem Hieb entnehmen,
wenn wir ein Element aus dem Hieb entnehmen,
also zum Beispiel das Element 8,
das würden wir jetzt herausnehmen mit unserer entsprechenden Operation,
dann würde ja hier ein Element fehlen und wir hätten keinen
vollständigen Baum mehr
Was wir dann machen,
ist, wir nehmen das letzte Element in dem Array,
was noch zum Hieb gehört und schieben das an dieser Stelle an die Wurzel.
Dadurch ist der Baum wieder links vollständig.
Also hier ist dann die letzte Ebene dann abgebaut.
Aber hier oben an der obersten Stelle ist der Hieb-Eigenschaft verletzt.
Und wir nutzen dann die Hippiefy-Operation,
um den Hieb an dieser Stelle wieder zu reparieren,
schieben dann also die Sieben hier hoch und die Eins wandert
dann am Ende hier an diese Position
Okay, soweit waren wir und dann haben wir den Algorithmus
auch schon analysiert und wir haben uns überlegt, wie lange die Operationen dauern,
also insbesondere wie lange dauert diese Hipify-Operation und den Hieb zu reparieren.
Dazu haben wir uns den Baum hier angeschaut,
in so einer stilistischen Form und wir sehen,
der Baum, der zerfällt eigentlich in vier Teile,
der linke und der rechte Teilbaum,
sind das nur zwei Teile und innerhalb des linken und rechten Teilbaums können wir uns die Ebene der Blätter anschauen und die anderen Knoten.
Ja, und dann entstehen hier vier Felder, also linker Teilbaum,
andere Knoten, linker Teilbaumblätter, rechter Teilbaum, andere Knoten Rechteabteilbaumblätter.
Bei einem vollständigen Baum waren diese vier Felder alle in etwa gleich groß.
Die haben alle in etwa N-Viertel viele Knoten. Weil wir wissen,
dass der Baum nicht vollständig ist, sondern nur links vollständig,
kann im schlimmsten Fall dieser Bereich hier leer sein.
Und wenn das so ist, dann können wir ausrechnen,
relativ schnell, dass das Verhältnis zwischen dem linken und dem
rechten Teilbaum dann natürlich ein Verhältnis von 2 zu 1 hat.
Ist doch nicht so, ist nicht balanciert,
das haben wir gemacht. Und damit können wir auch zeigen,
dass die Laufzeit hier in der Rekurrenz so ist,
dass das Thiepify von Anne, die Laufzeit von Thihiepify von zwei Drittel N plus irgendeine Konstante hat.
Okay, mit den Master-Theorien konnten wir das auflösen,
haben wir auch schon gesehen in der letzten Vorlesung und dann kam da Login raus.
Das heißt, wir haben O von Login-Side zur Ausführung einer von diesen Max-Hipify-Operationen.
So, damit bleibt eigentlich nur noch eins zu tun bezüglich
des Heepstars. Wir müssen dem Heep am Anfang bauen.
Ja, wir müssen am Anfang aus der Datenstruktur,
also im unsortierten Array,
ein Heep konstruieren
Und das ist die Frage, wie wir das machen,
da benutzen wir dann einfach auch unsere Hipify-Operation und die Idee ist die Folgen,
wenn wir einfach mal das Array nehmen und haben jetzt erst mal irgendwelche Werte daran gespeichert,
das sieht dann also so aus.
Und wir betrachten mal für jeden Knoten immer nur den Baum nach unten.
Wir gehen mal davon aus, ich sage,
das ist jetzt einfach die Wurzel von einem kleinen Hieb.
Und dann können wir schauen und dann sehen wir,
okay, also alles, was schon blatt ist,
also wo nichts mehr da drunter kommt, wie der Knoten,
der, der, der, die erfüllen die Hieb-Eigenschaft,
also ein einzelner Knoten, wo nichts dranhängt,
erfüllt offensichtlich die Hieb-Eigenschaft, weil die Hieb-Eigenschaft ist ja nur eine Bedingung,
die zwischen den Knoten, also zwischen Vorgängern und Nachfolgern gilt.
So, das heißt, wir haben hier so eine Linie in unserem Baum und alles,
was hier unten ist, erfüllt die Hieb-Eigenschaften und alles,
was hier oben ist, erfüllt sie erstmal potenziell noch nicht.
Was wir jetzt machen ist,
wir gehen jetzt einfach in diesem Array von hinten nach vorne,
also wir fangen an mit diesem Element 4, 3,
2, 1,
gehen also wieder von hinten nach vorne und werden einfach die Hieb-Eigenschaft korrigieren mit unserer Hipify-Operation,
denn wenn wir hier einen Knoten weiterlaufen, dann hätten wir hier einen Hieb,
der hat gerade zwei Knoten, 1 und 3, Also der, wo Wert 1 und 3 dransteht.
Und der ist nur an einer Stelle defekt, weil für
seine Kinder gilt ja, dass die die Hieb-Eigenschaft erfüllen.
Also es ist dann nur an der Wurzel-Defekt. Also können
wir hier mit der Hipify-Operation auf diesem Knoten das reparieren.
Da würden wir die beiden Elemente vertauschen. Hier steht
die 3, hier steht die 1. Und unsere Linie,
die den korrekten Hieb von dem Teil trennt,
wo wir noch nicht die Hieb-Eigenschaft erfüllen,
wandert damit ein klein bisschen weiter nach oben.
Die ist dann an dieser Stelle. Im nächsten Durchlauf würden wir
jetzt den nächsten Knoten nehmen, das wäre der hier.
Also das wäre der letzte Knoten in dem Array,
wo die Hieb-Eigenschaft noch nicht gilt und würden hier die Hipify-Operation anwenden.
Wir würden also 7 mit 5 und 8 vergleichen,
8 wäre das Maximum, die 8 wandert nach oben,
die 7 wandert nach unten und dann wäre die Hip-Eigenschaft für diesen Knoten erfüllt.
Und unsere Linie geht wieder ein Stückchen weiter nach oben.
Das Gleiche machen wir dann für den Knoten 6.
Da müssen wir gar nichts machen,
der erfüllt schon die Hip-Eigenschaft und dann wären wir hier oben
bei dem Knoten 2 angekommen und dann würden wir hier wieder
mit der Hibify-Operation die Hip-Eigenschaft herstellen und dann hätten wir einen Hieb
Okay, das ist die Funktion, Bild Max Hieb,
die Idee ist also, wir beginnen mit dem unsortierten Array,
Ausgabe ist das gleiche Array, aber jetzt sind die Elemente so sortiert,
dass sie die Hieb-Eigenschaft erfüllen.
Algorithmus läuft wie folgt, wir gehen von der Hälfte der Hieb-Size,
also von der Hälfte des Aris plus eins,
gehen wir los bis zum ersten Knoten und rufen die Hippie-Five-Funktion auf, korrigieren die Hieb-Eigenschaft.
Sieht dann ungefähr so aus, Bild maxim, ah,
ist das Array, wir initialisieren die Heeb-Size mit der Länge des Arrays,
das ist am Anfang natürlich, Da ist ja noch kein Hieb drin,
aber das machen wir jetzt.
Und zwar mit dieser Vorschleife, wir gehen von Heep Size halbe,
nach unten abgerundet, runter bis eins,
das ist eine Schleife, die rückwärts zählt,
runter bis eins und rufen einfach unsere Heepify-Operation aus und die repariert das.
So, Laufzeit müssen wir davon analysieren von dem Algorithmus,
dass es eigentlich ganz einfach auf den ersten Blick mal,
und zwar Können wir gucken und sagen, okay,
hier haben wir eine Vorschleife.
Die Vorschleife, also diese Heep-Sizes ist N,
also Anzahl Elemente, in dem Array.
Also das geht von N halbe runter bis 1.
Das sind also N halbe Durchläufe, die diese Vorschleife macht.
Und in jedem Durchlauf rufen wir diese Maxi-Pify-Funktion auf.
Haben wir schon gesehen, kostet uns im schlimmsten Fall Lock-and-Zeit,
also Ophon-Log-and-Zeit, macht insgesamt halt O von N-Log-in.
Wäre die erste Abschätzung, das heißt O von N-Log-in für die BILD Max-Hieb-Operation.
Ja, das wäre die erste Betrachtung, die man machen könnte zur Laufzeit.
Und wenn wir in den Gesamtalgorithmus gucken,
ich blätter mal nochmal zurück zum Gesamtalgorithmus,
dann sehen wir Hier, dass das auch okay wäre,
weil hier würden wir N-Doc Endzeit brauchen für die Bild-Maxim-Operation.
Und dann haben wir hier diese Vorschleife, die hat
auch N-Durchläufe und hier würden wir jedes Mal Maxi-Bify aufrufen.
Das dauert Log-Endzeit. Das heißt, hier hinten haben wir
auch N-Log-Endzeit, die wir verbrauchen.
Und damit hätten wir eine Gesamtzeit von O von N-Log-End.
Also diese grobe Abschätzung unseres Algorithmus würde also durchaus reichen.
Gut. Trotzdem, ist wieder vorspulen, dann die richtige Stelle.
Trotzdem stellt sich natürlich die Frage, ob das tatsächlich jetzt
eine sehr grobe Schranke ist oder ob das wirklich die Laufzeit ist.
Also ob das Bild maximal wirklich genauso lange dauert,
wie nachher das wirkliche Sortieren durch das Entnehmen der Elemente.
Also O-Kalkül ist ja immer nur eine obere Schranke für die Laufzeit und es kann ja durchaus sein,
dass wir hier jetzt das einfach zu grob abgeschätzt haben,
dass der Algorithmus eigentlich viel schneller ist und wir haben einfach den so grob abgeschätzt,
dass der also N-Log-in-Zeit hätte.
Das müssen wir uns jetzt gleich nochmal anschauen
Die Korrektheit des Algorithmus, die ist hier nochmal zusammengefasst.
Eigentlich habe ich es Ihnen gerade schon genauso erklärt, warum das richtig funktioniert.
Wenn man es ein bisschen formaler aufschreiben würde, würde man sagen,
es gibt eine Schleifenin-Variante für diese Vorschleife hier. Und die besagt,
dass immer für alle Werte K im Intervall von iPlus 1 bis N,
also bis zum Ende des Arrays gilt,
dass A von K, also in dem Eingabe RAR,
ab der Position K eben ein Hieb enthalten ist.
Also das heißt, A von K ist die Wurzel eines
Max Hiebs. Ja, das wäre die In-Variante.
Und wir würden sehen, dass bei der Initialisierung,
da gilt das,
da ist I ja hier in
Und wir haben ja gesehen,
dass für den Bereich von N halbe bis N,
das sind ja die ganzen Blätter, ist diese Eigenschaft ja erfüllt.
Da sind die Knoten alle schon Wurzeln von so kleinen Hiebs mit einem Knoten.
Okay, dann kommt die Fortsetzung hier in der Vorschleife.
Also wir iterieren hier das IWIT immer größer. Und weil wir
das Maxi-Bify hier aufrufen, korrigieren wir die Hieb-Eigenschaft an der Position I.
Und wegen der Schleifeninnenvariante wissen wir schon, dass die Nachfolger von I,
die Kinder, Left und Wright schon Wurzeln von Max Hiebs sind.
Die stehen ja im Array weiter hinten und dadurch folgt automatisch,
dass nach dieser Iteration der Knoten-I auch die Wurzel eines Maxims darstellt.
Und wenn wir damit fertig sind, dann ist die Schleife durchgelaufen,
die läuft hier bis eins und nach der Schleife wäre I
gleich null und damit ist A.1 auch die Wurzel eines Max-Hiebs.
Okay, also der Algorithmus funktioniert. Er hat N-Log
and Laufzeit. Eigentlich werden wir jetzt fertig,
könnten uns zurücklehnen und sagen, toll,
hier haben wir ein Sortierverfahren, was inplay sortiert,
es braucht nur dieses RAR keine Zwischenspeicherung der Werte und
es hat eine O von N-Log and Laufzeit.
Ja, also alles prima
Trotzdem, wie gesagt, stellt sich die Frage,
ob das Bild Max Hieb nicht von der Laufzeit überschätzt wird.
Und das ist auch so, sonst würde ich es ja hier nicht so betonen.
Also die Laufzeit dieses Algorithmus ist tatsächlich kürzer als Annogin.
Das ist nur eine Abschätzung gewesen. Und wir werden jetzt
genau sehen, warum die kürzer ist.
Eigentlich kann man auch erst mal intuitiv darüber nachdenken,
ob das sein könnte oder nicht.
Und wenn man hier mal guckt, dann fällt einem schon auf,
dass die Abschätzung vielleicht zu groß war.
Weil für die Blätter machen wir nichts, das war okay.
Jetzt haben wir mit dem angefangen hier, haben die Hieb-Eigenschaft berechnet.
Und das Schlimmste, was uns ja passieren kann,
ist, dass der seinen Platz mit dem Nachfolger tauscht.
Diese Operation haben wir abgeschätzt mit Login
Also Log-in wäre korrekt für die Wurzel hier, aber für
den ja nicht. Der ist ja so weit unten,
der braucht ja viel weniger Zeit. Also um den hier,
um den Hieb hier an der Stelle zu korrigieren,
habe ich ja nur einen Schritt. So, das heißt,
wenn ich mir jetzt alle Knoten der Reihe nach angucke,
dann kann ich mir überlegen, wie lange dauert denn diese Maxi-Bify-Operation wirklich?
Also braucht die wirklich Log-in oder brauchst du sie weniger?
Offensichtlich brauchst du sie weniger, im Worst Case.
Wenn ich hier oben angekommen bin bei der Wurzel,
dann brauche ich tatsächlich Log-in-Schritte,
weil dann muss ich von hier potenziell bis zu einem Blatt laufen.
Aber hier muss ich das nicht unbedingt. So,
und das kann man nochmal etwas präzise aufsummieren und kriegt dann
auch eine exaktere Laufzeitschranke hin
Wie macht man das? Also man muss jetzt ein bisschen überlegen,
man kann jetzt nicht mehr so grob abschätzen,
dass man sagt, okay,
hier haben wir eine Schleife, eine halbe Durchläufe,
wie lange dauert das innerhalb der Schleife?
Wir müssen jetzt ein bisschen genauer hinschauen und wir müssten für
jeden Schleifendurchlauf überlegen, wie lange dauert denn dieser Schleifendurchlauf?
Und dann müssen wir das addieren. Ja,
dann kriegen wir eine präzisere Schranke heraus. Also,
die Laufzeit ist proportional zu der Laufzeit der Maxipifall-Operation.
Alles andere kostet eigentlich keine Zeit. Wir müssen nur gucken,
wie lange brauchen wir für diese ganzen Maxipify-Operationen
Die Operation wird immer ausgeführt auf einem Knoten und der hat irgendeine Höhe.
Die müssen dran denken. Die Höhe war der Weg,
den der Knoten hat bis zu einem Blatt.
Also der maximale Weg, den er zurücklegen kann,
bis er unten an einem Blatt angekommen ist.
Das entspricht exakt auch der Laufzeit. Also wenn der Knoten die Höhe hat,
dann braucht er maximal O von H viele Schritte,
weil er in jedem Schleifendurchlauf oder in jeder Rekursion eine Ebene nach unten wandert.
Und er kann natürlich nur so weit runter wandern,
bis er aber
ein Blatt angekommen ist
So, welche möglichen Werte haben die Höhen? Die Höhen
haben Werte irgendwo zwischen Null und Log-in. Also wir wissen,
wenn wir den einen Hieb anschauen, die Blätter hier,
die haben alle Höhe Null, die sind ja schon Blätter,
also der Weg bis zu einem Blatt ist die Länge Null.
Und die inneren Knoten, ja, der hier hat die Länge eins,
der hat dann die Länge zwei,
der hat ja auch eins und der hätte dann die Länge drei.
Und das Maximum, was uns passieren kann, ist eben Log-in.
Also Logarithmus, genau genommen zu Basis zwei,
spielt aber für uns nicht so eine große Rolle im Moment.
Okay, so, Wie viele Knoten gibt es jetzt mit einer speziellen Höhe?
Das können wir leicht ausrechnen, weil wir haben ja einen Vinärbaum.
Und da wissen wir, wie viele Knoten befinden sich denn auf welcher Ebene?
Denn der ist ja vollständig, also links vollständig,
bis auf die letzte Ebene. Und dann sehen wir,
die Anzahl der Knoten mit einer speziellen Höhe ist N durch 2OH plus 1.
Also wenn wir mal H gleich Null einsetzen,
das wären ja die, das wären ja die Blätter,
dann steht ja N halbe.
Das wissen sie, in halbe Blätter hatten ein binärer Baum in einer vollständig ist.
Und in der nächsten Ebene haben wir nur noch die Hälfte der Knoten.
Es halbiert sich ja von Ebene zu Ebene. Wenn wir dann Log-in einsetzen,
hätten wir hier zwei hoch Log-in, so ein bisschen runden,
das ist aber dann im Wesentlichen N und dann hatten wir N durch N,
das ist eins, das ist für die Wurzel.
Wir haben also einen Knoten der Höhe Haar, zwei Knoten der Höhe,
ja, dann H minus eins und dann vier Knoten,
die sind dann H minus zwei hoch und so weiter,
weil das von Ebene zu Ebene verdoppelt sich halt die Anzahl der Knoten,
wenn wir auch untergehen.
So, damit haben wir alles zusammen, jetzt können wir das ausrechnen.
Das geht jetzt also wie folgt, wir sagen,
okay, T von N, die Laufzeit,
irgendeine Konstante, wissen wir nicht, mal,
jetzt summieren wir hier nicht über die Schleifendurchläufe,
sondern wir summieren einfach über die verschiedenen Höhen
Und wir sagen, die Höhen nehmen Werte an von null
bis Log-in. Und wir betrachten jetzt die gesamte Zeit,
die alle Knoten brauchen, die in einer,
die die gleiche Höhe haben. So, wir wissen,
das sind jetzt N durch zwei Hochhaar plus 1. Viele,
nach oben aufgerundet, Knoten, die da drin sind,
die diese Höhe haben und welche Laufzeit benötigen die?
Ja, die benötigen O von H. Und das beschreiben wir,
indem wir sagen, okay, das ist irgendeine Konstante,
mal HC, mal Haar. C mal H,
das C haben wir vor die Summe schon gezogen.
Also das mal Haar, das ist die gesamte Laufzeit,
die wir haben. Okay, das machen wir im Okalkül,
da hätten wir also O von wem hier,
dadurch fällt die Konstante weg.
O von N mal die Summe,
Haar gleich null bis Log-in-H
durch zwei Hochhaar
Ja, und das ist O von N.
Und hier sehen sie, es ist tatsächlich schneller.
Also wir brauchen nicht die N-Log-End-Zeit, sondern die Schranke O
von N. Linearzeit reicht aus für das Bild Max Hieb.
Warum das hier jetzt O von N ist,
da muss man nur einmal irgendwie hingucken.
Das muss man ja irgendwie diese Summe ausrechnen oder abschätzen.
Das geht wie folgt. Also wir können das N hier
vor die Summe ziehen. Dann steht hier N,
mal die Summe, Hag gleich 0 bis Log-End,
2 hoch, also H durch 2 Hochhaar.
Und da müssen wir nur noch zeigen, dass diese Summe hier,
die hier hinten ist, dass die konstant ist.
Also dass die relativ klein ist, ist klar,
weil wir dividieren ja hier durch 2 Hochhaar.
Also wir haben hier irgendwie was mit Ein halb,
ein Viertel, ein Achtel und so weiter.
Das wird wohl keine sehr große Summe sein.
Was es genau ist, das muss man ausrechnen.
Und dafür gibt es eine, das kann man berechnen,
indem man die geometrische Reihe ableitet.
Das muss man nicht unbedingt wissen, aber man kann das halt nachgucken.
Und das im Kormen finden sie das auch,
wenn sie es nochmal sehen wollen.
Also die Summe von Haar gleich 0 bis unendlich Haar durch 2 Hochhaar.
Die kann man berechnen. Und das interpretiert man hier als
Haar mal ein halbhoch Haar. Und dafür gibt es
eine geschlossene Formel in der Mathematik. Und das ist eben
ein halb durch 1, minus 1,5 zum Quadrat.
Das gilt natürlich auch für andere Faktoren hier,
wenn es also nicht für alle,
aber wenn jetzt hier ein Viertel wäre oder so oder ein Nachtel oder ein Neuntel,
dann könnten sie das ja auch entsprechend einsetzen.
Okay, und das ist zwei. Das heißt,
diese Summe hier, die wird, selbst wenn die Summe
bis nach unendlich geht, wird die nicht größer als zwei.
Ja, das ist der Grenzwert dieser Summe. Und deswegen ist das
hier kleiner gleich zweimal N und dann ist das eben auch von N.
Dann haben wir die lineare Laufzeit. Das ist insofern ganz interessant,
wenn wir nochmal an den Algorithmus denkt, dann sieht man,
dass von dem Heep-Sort tatsächlich nur der hintere Teil,
also dass immer wieder das Entnehmen des Maximums und das entsprechende Korrigieren des Heebs, die N-Log-N-Laufzeit verursacht.
Der vordere Zahl hat nur Linearzeit, läuft also wesentlich schneller.
Wenn man also was optimieren will an dem Verfahren,
muss man immer unten gucken, also in der unteren Vorschleife.
Okay, ja, der Heebsort ist, wie gesagt,
unser erstes Verfahren mit N-Log-N-Laufzeit. Nee,
stimmt gar nicht, den Merch-Sort hatten wir auch schon,
aber es ist der erste In-Place-Verfahren mit N-Log in Laufzeit.
Der Heebsort ist aber deswegen so wichtig,
weil er diese Heeb-Datenstruktur motiviert und die wird eben intensiv für
alle möglichen Arten von Problemen
noch eingesetzt
Und umgangssprachlich heißt die dann in der Regel Privaritic Hue, also Prioritäts-Warteschlange.
Und so eine Datenstruktur wird eben immer dann gebraucht,
wenn wir dynamisch in einem Algorithmus Objekte haben, die wachsen,
da kommt was dazu und wird was entnommen.
Ja, und das Entnehmen funktioniert so,
dass wir immer das Maximum herausziehen möchten aus der Menge.
Ja, das machen Prioritäts-Warteschlangen. Oder das Minimum,
dann drehen sie einfach alle kleiner gleich durch größer, gleich durch.
So, hier sind die Operationen, die so eine Prioritäts-Warteschlange
typischerweise hat, da können sie dann ein Element einfügen.
Wenn sie ein neues Element haben, sagt,
es muss jetzt in diese Warteschlange hinein,
haben sie eine Heep-Insert-Funktion, dann haben sie die Heep-Extract-Max-Funktion,
also die entnimmt dann halt das Element mit maximaler Priorität,
mit maximalem Schlüsselwert
Und dann wollen sie gerne die Schlüsselwerte noch modifizieren können. Ja,
also sie haben vielleicht schon was in den Hieb eingetragen,
aber sie wissen dann, naja,
also dieses Element muss ich jetzt,
obwohl das schon an einer speziellen Stelle steht,
in der Priorität erhöhen oder erniedrigen.
Und dann wollen sie das anpassen. Das ist eine dynamische Warteschlange.
Sie können jederzeit die Objekte, die da gespeichert sind,
in dem Rang verändern. Dazu gibt es dann zwei Funktionen
. Da gibt es also Increase Key und D-Quiz Key.
Also mit Increase Key können sie den Wert von diesem Element
in der Warteschlange erhöhen. Sie müssen dann aber einen Wert
K angeben, der größer ist als das A von
Und mit D-Crease Key können sie den Wert verringern.
Weil die Crease Key wandert das Element weiter nach hinten in
die Warteschlange und bei Increase Key wandert das weiter nach vorne in die Warteschlange.
Ja, die Funktion haben wir im Prinzip schon alle gesehen,
also größtenteils. Also Heap Extract, Max ist die Operation,
die wir schon hatten. Im Heap Sort und Heap,
D-Crease Key ist eigentlich nichts weiter als unsere Hibify-Operation,
wenn wir einen Schlüssel im Wert verkleinern,
dann verletzen wir den Heap an dieser einen Position.
Und dann rufen wir die Hibify-Operation auf und die korrigiert
das wieder
Ja, also läuft dann also in Login-Zeit. Okay.
So, ja, was machen wir bei Increase Key?
Das ist die Operation, die wir noch nicht gesehen haben.
Also jetzt, wir wollen die Priorität erhöhen eines Elements.
Das sieht dann zum Beispiel so aus,
wir haben also hier unseren Hieb,
steht natürlich eigentlich in einem Array, aber hier wieder als Baum,
dann kann man das immer besser erkennen, was so passiert.
Und wir haben hier dieses Element, da stand jetzt vorher eine 4 drin.
Und während dieses Objekt schon im Hieb drinsteht, entscheiden wir,
nein, Das hat eigentlich eine viel höhere Priorität,
da ändern wir die Priorität von 4 nach 9,
schreiben wir das in 9 rein.
Jetzt ist der Hieb wieder verletzt an einer Stelle,
aber wir können die Hippiefy-Operation nicht verwenden,
weil die Hippiefy-Operation, die arbeitete so von oben runter.
Und jetzt haben wir die Verletzung des Hiebs hier unten.
Und was wir jetzt machen ist, wir schieben den Fehler nach oben,
weil wir haben ein relativ großes Element hier unten.
Das ist eigentlich zu groß für den. Also was wir machen ist,
wir vergleichen dann dieses Element mit dem darüberliegenden Knoten und dann sehen wir,
aha, der Knoten hier hat den kleineren Wert.
Also vertauschen wir die. Damit ist die Hieb-Eigenschaft an dieser Stelle
erstmal repariert, aber an dem Vorgängerknoten potenziell wieder verletzt.
Also machen wir das rekursiv, schauen uns dieses Element an,
vergleichen das mit dem Vorgänger. Da steht dann jetzt die neun,
vergleichen das mit dem Element und vertauschen die dann gegebenenfalls auch.
Das heißt, jetzt bei der Hibify-Operation haben wir den Fehler
nach unten transportiert und wenn wir ein Increase-Key machen,
wenn wir also den Wert vergrößern,
schieben wir das