So. Heute, neue Datenstruktur oder, alte Datenstrukturen und neue Datenstrukturen.
Und möglicherweise besseres Sortieren mit dann diesen neuen Datenstrukturen.
Bisher hatten wir irgendwie mit Arrays die ganze Zeit gearbeitet,
beiden Sortieren. Und heute genau,
wollen wir uns alte Datenstrukturen angucken und dann eben neue Datenstrukturen,
mit denen das hoffentlich besser geht, das zu sortieren.
Und der Ablauf sieht so aus, elementar und strukturierte Datentypen,
da sage ich nur ganz kurz was zu,
dann diese ganze Liste von Datenstrukturen da
Also ein Stapel, also Stack, eine Q-Listen-Bäumegrafen und dann kommen eben
Heeps und mit den Heeps kann man dann eben Heeps haut machen.
Hoffentlich gut und schnell. Jetzt war das ja letztes Mal so,
ich hatte kurz gefragt, wer die ganzen Datenstrukturen schon kennt und
bis auf eine ganz kleine Gruppe kanntet ihr die schon alle.
Deswegen habe ich gedacht,
ich maustelle das ein bisschen um und mache das jetzt wie folgt,
wir springen einfach direkt in die Heeps,
machen vorher einmal ganz kurz Bäume,
weil die braucht man dafür
Dann können wir uns die anderthalb Stunden schön mit Heeps und Heepsort und sowas
beschäftigen. Und dann können die, die sagen,
die ganzen Datenstrukturen kenne ich schon aus SE1, SE2 oder so,
die können dann gehen und sich irgendwie den Foliensitz einmal kurz zu Hause angucken.
Also da passiert jetzt auch nichts großartig,
außer dass die Sachen definiert werden. Und die,
die jetzt eben sagen, die kenne ich noch nicht,
die können dann halt hier bleiben und dann mache ich mit denen irgendwie eine gemütliche Mini-Session.
Also ihr könnt natürlich alle hier bleiben,
aber ich dachte, ich baue das mal so um.
Einwände. Richtig rumgefragt, hätte ich gefragt, hat jemand,
wer findet das okay, dann ist anders ausgesehen.
Gut, dann machen wir das so.
Das führt jetzt leider ein bisschen dazu,
dass ich zwei, dreimal ein bisschen springen muss in
den Folien
Deswegen habe ich mir extra aufgeschrieben, wohin.
Weil diese Baumgeschichten, die brauchen wir halt. Weil wir werden
dann nachher sehen, dass Heeps eben auch Bäume sind.
Und das ist ein Baum gefüllt mit irgendwelchen Werten.
Dass da oben werden wir die Wurzeln nennen.
Die hier unten die Knoten, das werden die Blätter.
Man ist das hier, das sind alles die inneren Knoten,
die Wurzel streng, die machen innerer Knoten.
Und die Pfeile deuten an, was eben die Kinder eines Knotens sind.
Also die Acht hat als Kind irgendwie die Knoten 1 und
Genau, die Zehn hat als Kind sieben und acht und so weiter.
Und das ist ein Baum. Da sind nochmal die ganzen Begriffe.
Knoten ist einfach irgendein Element in dem Baum. Also nicht die Kanten,
sondern halt die runden Dinger hier mit der Zahl drin.
Das sind die Knoten. Vorgänger ist der direkte Vorgänger,
das direkte vorherige Element im Baum.
Nennt man auch Vater oder Elternteil. Man sieht hier,
jeder Knoten hat genau einen Vater.
Nicht mehr. Nachfolger, direkt nachfolgendes Element im Baum.
Nennt man auch Sohn oder Kind.
Da kann man sehen, da kann man irgendwie mehrere
von haben
Ein Vorfahre, halt nicht der direkte Vorgänger, sondern irgendeinen Vorfahre,
das ist ein Knoten auf dem Weg von mir zur Wurzel.
Also wenn ich hier die 5 nehme,
dann sind Vorfahren der 5 eben 7, 10 und 14.
Und Nachfahren, genau, andersrum, Knoten auf dem Weg zu einem Blatt.
Also wenn ich hier die 10 nehme, sind Nachfahren all die Knoten,
die danach kommen. Wurzel ist der Knoten ohne Vorgänger,
also der Knoten ganz oben, Blätter sind die Knoten ohne Nachfolger,
also die Knoten ganz unten, innere Knoten sind halt die,
die nicht die Blätter sind,
also die Knoten mit Nachfolger und ein Pfad ist einfach eine Folge von Knoten,
so eine Folge von Knoten, die irgendwie durch Kanten verbunden ist,
also zum Beispiel 14,
10,
8,1 ist eben Fahrt durch den Baum
Und was ist ein sehr charakteristisches Merkmal ist von den Dingern,
ist eben, dass da keine Kreise gibt.
Also wenn es jetzt sowas gäbe, hier wie 14,
10, 7, 5, 10 oder sowas,
dann hätte man da so einen Kreis drin, 10,
7, 15, 10 und gerade das hat man bei Boym eben nicht.
Und dass die Kanten da gerichtet sind, das ist nur so
eine Darstellungsweise, sodass ihr Pfeile an den Kanten sind,
üblicherweise sind die nicht gerichtet. Das ist jetzt nur,
dass man das irgendwie einmal sehen kann,
so mit Vorgängern, Nachfolger und so,
dass es mit Kanten irgendwie schneller zu sehen,
aber üblicherweise braucht man die nicht
gerichtet machen
Da nochmal einfach als Beispiel, was man da als Knut,
ein Vorgänger, Nachfolger, Vorfahrer und Nachfahre hat,
oder so haben kann da als Beispiele.
Der Vorgänger von sieben bis zehn der Vorgänger von acht ist
auch zehn Nachfolger von zehn ist sieben und acht Vorfahren.
Vorfahre von acht bis zehn und 14 und Nachfolger noch andersrum.
Das sind die Begriffe, dass die anderen Wurzel ist die 14,
Blatt sieben, acht und 13 innere Knoten,
genau die, die keine Blätter sind, also der,
da ist kein innerer Knoten, das steht da falsch.
Also innere Knoten sind nur 14 und 10. 13, nicht 13, ist ja blatt.
Und Fahrt von 14 zu 7 ist eben zum Beispiel 14,
10, 7. Genau so, jetzt kann man noch sagen,
das sind Binärbäume, das kann man jetzt noch verallgemeinern,
dass ein Knoten eben nicht zwei Kinder hat.
Successor und Pri-Dingsbums, wie heißt das gleich?
Danke,
sag's laut
Priester, Stones, sagst du. Genau,
so Genährbäume, jetzt kann man auch irgendwie,
ein Knoten kann auch mehrere Kinder haben als ein oder zwei,
wenn er jetzt drei, vier, fünf Kinder hat,
dann ist eben kein Binärbaum mehr.
Genau, das kann man doch verallgemeinern. Wir brauchen heute
nur Binärbäume. Und dann kann man noch Höhe und Tiefe
definieren. Da geht es im Grunde genommen darum,
so etwas auszusagen über die Anzahl der Ebenen, die der Baum hat.
Also das hier, nennen wir nachher immer eine Ebene,
das ist jetzt eben eine Null, das ist eben eine Eins,
das ist eben eine Zwei und die letzte hier unten ist Ebene Drei.
Und jetzt will man eben was aussagen darüber,
in welcher Höhe die einzelnen Knoten sind oder in welcher Tiefe
Kann man dann rekursiv definieren und sagen, ein Blatt,
also ein Knoten ohne Kinder, hat Tiefe beziehungsweise Höhe Null.
Und ein innerer Knoten, der zwei Kinder hat,
der hat dann eben das Maximum der Tiefe von einem der beiden Knoten plus eins.
Also wenn man... Day hat tiefe Null,
die vier, na die sechs, tiefe eins,
die 13 Tiefe zwei und die 14 Tiefe 3.
Oder Höhe. Was ist bei uns
zwei Ärzte unterschiedliche Tiefen an dem bei euch
Maximum. Frage war, was passiert, wenn zwei,
was unterschiedliches sagen? Hier steht explatt das Maximum. Also
ich gucke mir da den linken und den rechten Teilbaum an,
gucke, wer von beiden hat das Maximum bezüglich Tiefe oder Höhe
und da addiere ich dann eins dazu.
Im Grunde genommen geht es darum, irgendwie die Anzahl der Knoten
auf einem Pfad zu zählen von einem Knoten zu einem Blatt,
den längsten Pfater zu nehmen und die Anzahl Elemente zu ziehen.
Genau, und andersrum kann man es genauso machen,
da kann man von Ebenen reden und sagt man,
die Wurzelsebene null, danach ist eben eine Eins und so weiter.
Und dann kann man solche Formeln hier aufstellen
Dass ich sage, die Näherbombe ist vollständig, wenn jeder Knoten genau zwei Kinder hat,
bis auf die Blätter natürlich, die haben ja gar keine Kinder.
Und dann kann ich irgendwie ganz gut zählen,
dann kann ich sagen, wenn ich ein vollständig bin,
ja, warum der Höhe Haar habe,
dann sind auf der Ebene I genau zwei Hoch-I-Knoten,
also auf der Nulten, wo nur die Wurzel ist,
2 hoch 0 ist 1,
das ist genau ein Knoten.
Auf der nächsten, der zwei Kinder sind da zwei Knoten,
dann hat jeder von den zweien wieder zwei Kinder,
zweimal zwei ist vier und so weiter.
Also kriege ich irgendwie auf jeder Ebene I,
habe ich genau zwei Hoch-I-Knoten.
Wenn das ein vollständiger Binäherbaum, der Höhe Haar ist,
dann sind ganz unten gerade
zwei Hochhaarfiele Knoten
Also Blätter. Und die Anzahl aller Knoten kann ich dann
irgendwie über diese Summe hier mir schnell überlegen.
2 hoch 0, plus 2 hoch 1,
plus 2 auf 2, plus 2 auf 3 und so weiter.
Und dann kann man sich noch überlegen,
wenn ich jetzt Tee-Knoten speichern will,
dann brauche ich hier Tee gleich 2 hoch haarplus 1 minus einzubringen,
ich das 1 auf die andere Seite, ziehe den Logarithmus.
Und dann weiß ich, wie viel Knoten ich da brauche.
Welche Höchburg? Also ungefähr Lugarithmus von Tee-Fiele.
Jo, das war es eigentlich zu den Bäumen.
Fragen dazu
Also wenn ihr diese bildhafte Vorstellung hier habt,
so die, das reicht eigentlich für heute.
Alles andere werden wir dann irgendwie zwischendurch immer nochmal explizit machen.
Fragen zum ersten, zum zweiten. Ja. Schieß los
. Ich wundere mich, wenn man die Jahrzehnte,
die Tiefe immer von den Blättern wurden, ja.
Und das heißt, von dem wir mal ein Hypotheser haben,
wo wir dann sagen, wir hätten einen Ast,
der hält ein Blatt und drei Äste nach unten noch ein weiteres Blatt.
Dann würde ja im Prinzip die Tiefe dieses linken Assis haben,
wo ganz anders Platten, ja.
Also sagen wir mal so,
jetzt in der WB4. Und an der anderen Seite hätte der
dann ein Platt von der Tiefe Null
Aus der Sicht des Blattes her, wusste es jetzt nicht,
dass es alleine ein Askonitiver Kianud ist.
Tut es ja auch nicht, das andere.
Das andere tut es ja auch nicht. Ich meine nur,
wie es guckt, man redet mal einen kleinen Baum vom Stamm auf,
runtergehen, das heißt, dass man einfach jedem Blatt sagt,
dass es die längere von dem Element, was es hält, hat für seins.
Kommt ja auch nichts anderes raus. Naja, dann wirst du
null. Eins, zwei, drei. Jetzt weiß der
hier auch nicht, dass es hier bis drei geht.
Er weiß auch noch, dass es bis eins geht.
Also das meine ich, dass ihm das auch nicht hilft
Ja. Aber also das kriegst du ja mit Ebene raus.
Dass der Knoten weiß, auf welcher Ebene er liegt.
Also wenn er es weiß. Ja,
also wenn du das so wie eben machen,
so wie du es gesagt hast, machen würdest,
mit Höhe so definieren, dann ist Höhe und Ebene das Gleiche.
So wie es da definiert, ist da Tiefe und Höhe
das Gleiche und Ebene das quasi das, was du haben wolltest.
Ja, ich muss so ein kurzes. Genau,
so wie es da definiert ist,
weißt du halt quasi, wenn ein Knoten sagt,
er ist Tiefe 2,
dann weiß er auf seinem längsten Weg zum Blatt,
muss er
Kanten entlang gehen. Gibt es einen Grund,
warum wir den Betrag von denen haben?
Hier? Tee, vielleicht jetzt die Menge der Knoten.
Ja, genau. Sonst noch Fragen. Habe ich gerade
vielleicht gesagt, also Tee hat die Menge der Knoten.
Nein, was
Nee, wenn du nichts über den Bau weißt,
kannst du es nie machen. Also ich, wahrscheinlich verstehe ich
die Frage gerade nicht. Ja. Ich weiß nicht,
irgendwas scheint euch gerade zu verwirren bei der Tiefe oder so viel.
Das ist das Wort oder so. Also bei Ebene sage ich
halt eben eine Null, Ebene 1, Ebene 2, Ebene 3.
Und bei sowas wie Tiefe fange ich halt unten an zu zählen.
Da sage ich halt, der Knoten, der Blatter,
das ist halt tiefe Null.
Und das, was dann da drüber ist,
ist das tiefer 1, Tiefe 2 und so weiter.
Aber wir definieren das Ganze noch fantasy, stimmt.
Das heißt, ein Stamm fragt im Prinzip nur beide seine
Blätter und fragt, Welcher von beiden hat maximale Tiefe?
Das heißt, es kann immer noch passieren,
dass ein Blatt zum Beispiel sich da ist,
rekursiv wie am Anfang alles, als null definiert, als tiefer.
Ist es ja auch. Wenn es ein Blatt ist,
ist es tiefe null. Ihr wollt irgendwie,
also euer Ziel scheint gerade zu sein, dass ihr sagen könnt,
mit der Tiefe, auf welcher Ebene er ist.
Aber das weiß ich ja schon über die Ebene.
Ja, genau. Also ihr wollt gerade immer an die
Info ran. Ich brauche aber auch die andere Info.
Wenn ich nämlich nur diese Info hätte von der Ebene,
also was du ja auch meintest,
wenn ich nur diese Info von der Ebene hätte,
dann wüsste ich zum Beispiel nicht,
dass es ein Blatt ist
Das weiß ich aber, wenn ich weiß, das ist tiefe Null.
So eine Frage aus dem rechten Feld vielleicht.
Aus dem rechten Feld? Braucht man dann die tiefe Fleische
für Worst Cases? Also allgemein brauchst du,
das ist ja einfach nur irgendwie eine Definition,
mit der ich was sagen kann,
über wo der Knoten sich irgendwie befindet oder ich kann
eine Induktion darüber machen oder all so ein Kram,
dafür brauche ich das nachher.
Also heute wahrscheinlich nicht, aber so normalerweise brauchst du irgendeinen Begriff,
damit du sagen kannst, das ist ein Blatt und jetzt passiert da irgendwas.
Dafür. Ich glaube, das ist auch nicht so spektakulär,
man ist das auch einfach irgendwie als Inversus von der Ebene
definieren können oder irgendwie sowas,
dann hört sich wahrscheinlich gar keiner aufgeregt
Ich glaube, das ist eigentlich ganz klar strukturiert,
weil es halt immer nur ein Elternteil gibt,
aber bei der Tiefe kann es halt sozusagen mehrere Kinder gehen,
wie das heißt.
Das war platt, weiß man, die haben die Tiefe null,
aber bei dem drüber, der Kathi von ihm bleibt auch,
das war einfach, die werden nicht behalten.
Das heißt, man bleibt halt auch eingeladen. Okay,
aber dann, ja, aber sonst beißt euch nicht so
in den Begriff Tiefe, sondern nehmt den Begriff Höhe.
Da ist irgendwie klarer, ein Blatt hat die Höhe null
So, weil der Baum hat die Höhe null.
Wenn da jetzt noch ein Knoten drüber ist, hat er
die Höhe eins, weil der Baum die Höhe eins hat.
Und der macht das auch Sinn mit der Maximumsbestimmung.
Aber wenn ihr hier ein Zweikampf,
wo nur ein Blatt dran ist und hier habt ihr eins,
zwei, drei Kanten noch kommen,
hat der Baum eben nicht die Höhe von dem Kleinsten,
sondern die von dem Größten.
Ja. Ja, gut. Sonst noch Fragen.
Geht nicht. Hast du einen Kreis?
Wollen wir nicht
Bitte? Nee, also ein Kreis, Kreise wollen wir nicht.
Das ist kein Baum mehr. Kropfen, oder? Das heißt,
man könnte den Stamm als Blatt auf einen anderen Fußball dran transferieren, oder?
Man kann bitte was? Ich mag keinen Tropfen. Fropfen.
Ja, das ist ein Therm aus der Erbauung sofort.
Da nimmt man sich prinzipiell Großlast von einem Baum.
Okay. Hackt keinen anderen Ast von einem anderen Baum ab.
Stoppt den ran, macht Therdruck und dann lässt man die
beiden zusammenwachsen, nennt sie Fropfen. Und das heißt,
man kann im Prinzip den Stamm von einem Baum nehmen und
ihn als Blatt an einen anderen Randwänden selber bekommen.
Kommt später. Ja, das kann man machen
Mittlerweile sind wir also tief bei der Baumverpflanzung angekommen.
Habt ihr noch technische Fragen zum Baum? Aber ja,
das kann man machen. Okay, bildlich, klar.
Ich will ja nicht zu diesen Heeps kommen.
Dann springen wir da einmal raus. Gehen da rein.
Ein Hieb. Wer kennt Teeps
Wir sind da schon eins, zwei, drei oder so
eine Anfolge. Binärer Hieb. Auch wieder eine Datenstruktur.
Die soll nachher dahin führen, dass wir schnell sortieren können.
Aber erstmal ist das einfach nur eine gewisse Art,
Daten anzuordnen. Also die Idee meiner Datenstruktur war ja,
Daten irgendwie auf eine gewisse Art anzuordnen,
sprich dem Struktur zu geben und der irgendwie Methoden zur Verfügung zu stellen,
um zuzugreifen.
Und eine ganz einfache Datenstruktur war ein Array,
wo ich alle Daten einfach linear anordne.
Und Hieb ist jetzt was anderes. Das ist so ein
binärer Baum, der fast vollständig ist.
Werden wir gleich sehen, was das fast an der Stelle bedeutet.
Und zusätzlich hat er noch die spezielle Hieb-Eigenschaft
So, und jetzt sieht das so aus, hier unten ist die Hip-Eigenschaft.
Wenn ich einen Knoten im Baum habe und P ist sein Vater,
dann gilt bei so einem Maxib und die werden wir primär uns angucken,
dass der Wert des Vaters größer ist oder mindestens,
magst du mal gleich, wie der des Kindes.
Sprich, wenn ihr euch irgendeinen Knoten rausnehmt, ist alles,
was der als Kinder hat, vom Wert her kleiner.
Weil er ist der Vater, also muss ja einen größeren Wert haben,
als ein linkes Kind und sein rechtes Kind.
Und die haben wieder größere Werte als ihre linken Kinder und rechten Kindern.
Das heißt, der Wurzelknoten hat den höchsten Wert oder wenn
ihr irgendwo einen Knoten einen Baum nehmt,
hat den höheren Wert als alle Kinder,
alle Nachfahren,
die so kommen
Das ist diese Hieb-Eigenschaft. Und bei Min-Hiebe ist es genau andersrum,
dass quasi die Wurzel den kleinsten Wert, aber das brauchen wir heute nicht.
Maxi brauchen wir. Das ist die Hieb-Eigenschaft,
sehen wir auch gleich ein Bild. Das andere ist,
dass der Baum auf allen Ebenen vollständig gefüllt ist, außer möglicherweise auf der letzten. Das heißt,
es gibt eine Wurzel, da hat die Wurzel genau zwei Kinder,
die haben auch wieder alle genau zwei Kinder und so weiter,
so ebenenweise ist das Ding komplett voll,
außer vielleicht auf der letzten Ebene,
da fülle ich von links nach rechts,
bis es ich keine Knoten mehr habe.
Da höre ich dann irgendwann auf, möglicherweise.
Und meistens wird das in einem Arry gespeichert
Genau, und länger A ist die Anzahl der Elemente im Feld.
Das kann manchmal größer sein als der Hieb und Hiebgröße A
ist die Anzahl der Elemente im Hieb. Das nur,
weil wir die beiden Begriffe gleich so im Pseudocode irgendwie brauchen.
So, wie sieht das also aus? So. Hier könnt
ihr sehen irgendwie, das ist ein binärer Baum.
Jeder Knoten hat zwei Kinder, außer hier der letzte,
weil das jetzt ebenenweise jeweils komplett gefüllt ist,
außer bei der letzten Ebene,
da gehe ich von links nach rechts durch und irgendwann höre ich halt auf.
Also es wird auch nicht so sein,
dass hier zum Beispiel jetzt die 1 und die 2 fehlen oder so,
dass man da eine Lücke hat,
sondern die letzte Ebene wird von links
nach rechts gefüllt
Und im Arry wird das dann auch ebenenweise und von links nach rechts abgelegt.
Also wenn ihr euch das anguckt, 16 ist im Arrygans links,
dann kommt 12 und 15, also die zweite Ebene in dem Baum,
dann kommt 11, 8, 7, 13,
also die nächste Ebene in dem Baum und so weiter.
Der Vorteil, wenn man das so ablegt, ist,
dass man an Väter und Kinder durch eine einfache Operation kommt,
also wenn ihr die Kinder von der 8 wissen wollt,
also ihr wisst, die 8 ist hier im Arry,
mit Index 5,
dann ist 1 und 2 gerade an zweimal diesem Indie-C oder
zweimal diesem Indie-C
8 hat den Index 5,
dann ist das linke Kind bald an der Stelle 2 mal 5.
Also hier bei der 10 kann man gucken, ist die 1.
Bei der 11, 2 mal 5 plus 1 ist
die 2. Und genauso kann man halt durch zwei teilen,
wenn man von einem Knoten an den Vater kommen will.
Also wenn ich hier bei der 8 bin, teile ich durch zwei,
5 durchs Weiß, 2 halbe, 2,5 und abrunden
ist man ja bei der 2 und dann hat man hier die 12.
Da steht das nochmal, hat man ein Array,
so werden die Elemente von links nach rechts gelesen und der
binnen ihre Baum von oben nach unten und von links nach rechts Ebene für Ebene aufgebaut.
Also ich fange bei der Ebene 0 an, fülle die Ebene 1,
fülle die eben in zwei Fülle und so weiter.
Und wenn ich einen Baum habe und ich will gucken,
wie das Array aussieht, dann meint das eben genauso,
dann lese ich den von oben nach unten und von links
nach rechts und schreibe die Elemente des Baumes in meinen Array
So, und wenn ich das so mache,
dann sind eben die Operationen da möglich, dass ich sagen kann,
wenn ich ein Element mit dem Index i habe,
dann ist der Vater von ihr eben gerade an der Position ihr halbe,
das linke Kind ist eine Position 2i,
das rechte Kind ist an der Position 2i plus 1. Und dann kann ich die Maxi-Eigenschaft so wieder unten ausdrücken,
dass ich sagen kann, egal welchen Index ihe ich mir angucke,
also in diesem Arry, der Vater hat immer einen Wert,
der mindestens so groß ist.
Also üblicherweise größer, wir betrachten hier, glaube ich,
in den Beispielen, wenn ich das richtig erinnere,
sind in den Beispielen überall nur Heeps,
wo alle Werte unterschiedlich sind.
Da würde dann dieses Gleiche wegfallen,
aber man kann das auch mit dem Gleiche machen
Äh, Abrundung, Floor-Abrunden. Bei dem Beispiel von eben hier,
wo ich gesagt hatte, bei der Acht,
die ist am Index 5,
5 durch zwei Teilen und dann soll da eben zwei rauskommen,
damit wir hier bei der Zwölf sind.
Das war ja auch umgekehrt, hier, Left E.,
da wird es genau multipliziert und Right East 2 e plus
1 und damit du von dem wieder auf das E kommen kannst,
musst du halt durch zwei Teilen und abrunden.
Ja, da ist er nochmal,
da sieht man jetzt Vater und Kind,
zwölf ist hier
Hat den Index 2 mit 2 multiliziert, ist 4,
also Star, das linke Kind und dann das rechte Kind. Anderes Beispiel. Genau,
und das ist jetzt gleich die Frage,
wenn ich jetzt, ich will ja nachher damit sortieren,
also es ist die Idee, ich kriege irgendwie die Zahlen,
ob ich die nun im Arry kriege oder ob ich die einfach so sequentuell kriege,
ist dafür nicht wichtig,
aber ich kriege halt diese Zahlen aus dem Arry und es ist die Frage, wie stelle ich damit überhaupt einen Hieb her?
Wenn das Arry nicht so schon in dieser Hieb-Eigenschaft aufgebaut,
also so aufgebaut ist, dass es die Hieb-Eigenschaft erfüllt,
dann kriege ich jetzt irgendwie Zahlen, wenn ich jetzt irgendwie 1,
2, 3, 4, 5, 6,
7 kriege und ich mache das so,
dass ich den Baum dann Ebene für Ebene und von links nach rechts aufbaue,
dann ist halt kein Hieb
Also ich kriege jetzt quasi eine Menge von Zahlen und ich will damit einen Hieb herstellen.
Jetzt die Frage, wie mache ich das?
Und auch, wie mache ich das möglich schnell?
Weil wenn ich dafür jetzt irgendwie, keine Ahnung,
Endquadrat viele Schritte brauche, dann wird das bestimmt kein schnelles Sortierverfahren.
Dann brauche ich schon bei der Hieberstellung viel Zeit.
Das ist irgendwie doof. Also ich will das möglichst schnell
machen. Also im schlimmsten Fall in N-Mar-Login,
damit ich noch so eine Chance habe,
mindestens so schnell zu sein wie Merch Sword.
Das war ja bisher das Schnellste, was wir so gesehen hatten.
Hieb, bis dahin klar. Hieb Eigenschaft, klar.
Also ihr nehmt einen Knoten und alles,
was als Kinder kommt,
ist kleiner vom Wert
Knoten, denen ihr euch betrachtet, der ist immer größer
als alle seine Kinder. Genau, dann das andere so,
dass man an die Kinder rankommt und an den Vater rankommt,
das ist so ein bisschen Spielereien.
Da muss man jetzt nicht genau wissen, dass das
zweimal ihr ist oder so für den Rest der Vorlesung.
Später sollte man das wissen, aber jetzt so nur,
dass man weiß, okay, man kommt da ran.
Gut, wenn ihr das verstanden habt, Ideen,
wie stellt man schnell einen Hieb her? Oder überhaupt? Einmal versuchen,
den Baum von oben da runterzukonzieren mit so einer Art Selection,
wo wir was durchfinden, das jeweils immer größere Menschen zu drücken.
Genau, dann sind wir aber fast bei Maxsort.
Also die Idee war gerade, Wir bauen den,
wir bauen den Baum von oben nach unten auf und fangen irgendwie mit dem größten Element an.
Und er meinte auch, so wie bei so einem Selection,
dass wir das größte Element nehmen, das ist dann die Wurzeln,
indem wir das zweite oder drittgrößte Element,
das sind dann die Kinder, das funktioniert,
aber dann bist du halt so ähnlich wie bei diesem Selectionshot oder halt mit Max-Shot,
was wir hatten,
dass du dann für die Baumkonstruktion ORN-Quadrat brauchst.
Funktioniert, aber kriegt man vielleicht noch irgendwie anders hin
Warte kurz, du fängst von unten an?
Also quasi ganz weg. Ah ja, okay.
Guck mal, wenn einer der Kinderkurven größer ist,
dann tauscht er sich mit dem Vater aus.
Genau. Das kann man machen. Das funktioniert auch.
Sonst noch Ideen? Das ist auch das,
was gleich kommt. Andere Ideen? Andere andere? Das
ist garantiert rekrutiert
Zu seinen Freiheiten, zu seinen tiefen, wieder in die Frage zu setzen.
Er meinte, Rico, rekursiv und immer mit drei Elementen quasi arbeiten.
Ich bin gerade überlegen, ob es das schneller macht. Genau,
wenn du drei Elemente macht mit denen hieb, so,
jetzt kommen die nächsten drei Elemente, jetzt könnte es vielleicht passieren,
dass die die Hieb-Eigenschaft von dem verletzen,
also muss man nochmal irgendwie rumtweeten.
Ansonsten, vielleicht macht es das irgendwie sogar schneller,
dass man sagen kann, ich nehme mir immer drei.
Man könnte es wie eine Art Kiesel aufmachen,
wo man im Prinzip alle Limite nacheinander auf einem Haufen
wird und es die großen Elemente oben bleiben
Und die kleineren Elemente runterkurzeln, ein bisschen nicht mehr
weiter passen. Auch sehr schön. Was? Ja,
das kriegen wir, glaube ich, hin, ne?
Also die Idee war gerade, wir machen das wie beim
Kieselhaufen, wir schmeißen das mal alles hin.
Und die großen Elemente lassen wir nach unten wandern.
Ja, das... Bitte? Ja, bin ich mir
gerade gar nicht gesehen. Ja,
also... Seine Idee war ja quasi von unten anzufangen und
die Kiese quasi nach oben laufen zu lassen.
Also die Kleinen drücken sich nach oben, warum auch immer.
Und die Idee ist jetzt quasi, die Kleinen durchwandern zu lassen,
ne? Bei ihm drücken sich die Großen nach unten,
die Kleinen
Klappt, glaube ich, auch. Also klappt auch.
Ich bin mir gerade nicht ganz sicher, genau,
was er meinte, ob das nicht so in Richtung Bubbleshot geht.
Da müsste man auf jeden Fall bei der Analyse ziemlich genau aufpassen.
Ansonsten auch coole Idee. Die brauchen wir nachher,
wenn es darum geht, mit dem Hieb Warteschlacken zu machen.
Dann braucht man das. Also was ist wichtig? Stell es
dir jetzt mal so vor, wie es im Cormen steht.
Die anderen Ideen hier waren auch cool.
Wichtige Routine ist dieses Maxipify, sehen wir gleich als Subroutine.
Und die macht Folgendes. Die geht davon aus,
dass die Bäume, also ich bin bei einem Knoten
mit dem Index I und jetzt gehe ich davon aus,
Left E und Right E sind bereits Maxips
Ich habe irgendwie links einen Maxi Brechts, einen Maxi und mein alles Eles-Element darüber,
dass es vielleicht noch nicht größer als die beiden, also verletzt es die Maxi-Eigenschaft.
Und jetzt mache ich genau das, was er eben meinte links.
Max verletzt es und die Routine lässt jetzt dieses AI absinken.
Ich mache jetzt nämlich Folgendes, ich gucke immer,
ist links oder rechts ein größeres Element und falls ja,
tausche ich die beiden. Und dann lasse ich dieses Element,
von dem ich noch nicht weiß, ob es die Maxi,
von dem ich jetzt weiß, es verletzt die Maxi-Eigenschaft,
dass ich eine Ebene sinken und jetzt gucke ich wieder,
verletze die Maxi-Eigenschaften, falls ja,
lasse ich es weiter runter sinken.
Und die eine Sache, auf die ich jetzt aufpassen muss,
ist, ich muss mit beiden gucken,
ich muss mir das linke und das rechte Kind angucken
Und dann muss ich mit dem Maximum von beiden tauschen.
Weil wenn ich einfach nur gucke,
ist das linke größer, uff, hals, ja,
tausche ich, dann könnte es ja sein,
dass das linke Element nicht größer ist als das rechte Element.
Und dann würde das auch die Hip-Eigenschaft verletzen. Beispiel,
hier Link, also das ist das markierte Element,
das wollen wir jetzt betrachten. Hier links haben wir schon
Maxib. Und hier rechts haben wir auch schon Maxib.
Und die drei verletzt offensichtlich die Maxi-Eigenschaft. Also wir gucken nach,
ist das irgendwie größer als linkes und rechtes Kind, ist es nicht.
Also verletzt ist die Maxi-Eigenschaft. Und was man jetzt macht,
ist, man guckt nicht einfach nur bei einem Element,
das größer ist und tauscht,
weil wenn ich jetzt hier mit der 8 tauschen würde,
werde ich da oben die 8 stehen,
da die 3 und dann verletzt plötzlich die 8 die Maxi-Eigenschaft.
Das ist doof. Sondern ich nehme von den beiden Elementen
hier das Größere
Und mit dem tausche ich dann. Und dann weiß ich,
dass der hier, der verletzt auf jeden Fall die Maxi-Eigenschaft nicht,
weil wenn der hier, da weiß ich schon,
der ist größer als alle, die,
die nach ihm kommen und wenn er größer ist als der,
als die Acht und die Acht ist ja größer als alles,
was nach ihr kommt,
dann ist die Elf auch größer als alles,
was nach der Acht kommt.
Also das ist okay, so rumzutauschen. Ups. Der Tausch ist okay.
Und jetzt kommt das, was er meinte mit der Rekursivität.
Ich höre jetzt nämlich nicht auf, sondern es könnte ja sein,
dass der hier jetzt weiterhin die Maxi-Eigenschaft verletzt.
In dem Beispiel ist es ja auch so,
nehme ich mir wieder das Größere von den beiden und tausch
mit denen
In dem Fall des Blattes ist es nicht ganz so schlimm,
wenn ich nicht das größte nehme, aber man will ja
vielleicht später mit dem Baum noch irgendwie andere Dinge tun.
Genau. Anderes Beispiel, 10, 11, 8,
jetzt wäre das so, dass die 10 größer ist als
die 8. Also da ist die Maxi-Eigenschaft gar nicht verletzt,
aber es ist eben nicht größer als beide und es müsste ja größer als beide sein.
Also nehme ich mir von 11 und 8 wieder das größte Element,
in dem Fall die 11 wieder und tausche.
Und jetzt gucke ich wieder, ist es größer als 7 und 6,
ja ist es, also höre ich auf.
Ich muss nicht bis zu den Blättern durchwandern,
sondern nur bis dahin, bis die Maxi-Eigenschaft nicht mehr
verletzt ist
Genau,
also ich vergleiche AI mit deinem linken und rechten Kind,
wenn AI schon am größten ist, höre ich auf,
sonst nenne ich Max jetzt mal den Index des größten Elements,
also entweder das Left E oder das Ride E und dann tausche ich eben AI und A Max aus,
das heißt AI wird mit dem größten Kind ausgetauscht und dann fahre ich mit A Max Ford,
also an der Stelle A,
Max ist ja jetzt das eben getauschte Element AI und mit dem wann fahre ich dann fort.
Und dieser wertvolle AI,
der wandert jetzt im Baum schön nach unten.
Laufzeit, Laufzeit, Laufzeit, wenn ihr an die Formel denkt,
vorhin, da war doch dieser eine Formel mit,
wenn ich Tee viele Knoten habe,
dann ist die Höhe des Baumes so und so.
Naja, das kann man hier benutzen.
Ich wandere ja maximal dem Pfad runter.
Und ein Pfad hat maximal die Länge.
Genau,
die ist was
Genau, luggerithmisch, ne? Wenn ich einen Baum habe mit N-Fielen Knoten,
dann ist die maximale Länge eines Vaters von der Wurzel
bis zu einem Blatt luggerithmisch in der Anzahl dieser Knoten.
Also Login irgendwie. Genau, ist korrekt,
hat so eine Laufzeit von O-Login oder Teter-Login.
Und genau, das hier müsste man noch zeigen,
dass das korrekt ist. Da kann man sich wieder irgendwie
eine schleifenden Variante überlegen und mit der eben das machen.
Oder in dem Fall vielleicht einfach mit einer Induktion,
dass man einfach sagt,
ich habe ja schon einen richtigen Hieb und jetzt kommt mein neues Element,
er tauscht da eventuell die Worte.
Ja, die Routine kann nun benutzt werden,
um Schritt für Schritt einen korrekten Maxhieb aufzubauen.
Naja, jetzt hat er ja auch schon gesagt,
wir gehen jetzt quasi den Baum von ganz rechts unten durch.
Die Blätter sind eigentlich egal, weil bei den Blättern,
wenn ich da eine Maxipify-Eigenschaft ausführe, das führt zu nix.
Und sobald ich dann beim Knoten bin, dass kein Blatt ist,
da führe ich dann die Maxi-Eigenschaft aus und das mache ich immer weiter.
Und dann erzeuge ich Schritt für Schritt nur Maxhiebs,
bis die Wurzel eben auch einer ist. Da als Beispiel,
das ist jetzt irgendwie völlig Kraut und Rüben,
Und jetzt gehe ich halt durch und bei denen hier ist im Grunde genommen nichts zu tun.
Deswegen fängt man bei denen eigentlich nachher auch nicht an,
aber streng genommen, ich gehe Ebene für Ebene von unten nach oben durch und von rechts nach links.
3 zu 9, 11, 8, 1,
7, 5, das sind alles schon Max-Hips,
das heißt die Max-Hipify-Eigenschaft führt dazu nichts.
Dann bei der 14, und jetzt geht es halt los
, ab da beginnt das Spannende. Also quasi ab Anzahl
der Knoten halbe beginnt der spannende Teil. Wird geguckt,
14 verletzt, dass die Maxibify-Eigenschaft, nö, tut's nicht,
also passiert da nichts. 12 verletzt das die Eigenschaft,
wird wieder geguckt, ist zwölf größer als seine beiden Kinder.
Ja, ist es, passiert also nichts
Jetzt das erste Spannende bei der 3, wird geguckt,
größer als beide Kinder, ist es nicht.
Und dann tausche ich mit dem größten Element,
also tausche ich irgendwie mit der 8. Dann hier bei der 10,
da ist auch wieder nichts zu tun und dann mache ich halt immer weiter.
Also da passiert das erste Mal, was 3 und 8 werden getauscht.
Bei der 10 passiert wieder nichts und bei der 6 jetzt wieder,
die ist nicht größer als ihre beiden Kinder,
also tausche ich mit dem größten, das heißt mit der 14.
Und dann die Maxibify-Operation lässt dieses eine Element ja im Fahrt
so lange nach unten laufen, bis es nicht mehr geht.
Da ist jetzt wieder die Maxibify-Eigenschaft verletzt, also tausche ich auch noch.
Dann bei der 2 wieder das größte Element nehmen,
die 10 und die
Herrlich. Und bei der Vier, ne? 14 ist das größte Kind,
also tausche ich mit dem, dann ist weiterhin die Maxi-Bifor-Eigenschaft ersetzt,
also tausche ich mit der 13 weiterhin verletzt, also tausche ich noch mit der Sechs.
Also da geht es dann einmal runter. So, und
jetzt habe ich einen Maxi. Sieht gut aus. Laufzeit? Genau, ne? Würde man jetzt annehmen,
dass das Ende mal Login ist,
weil ich ja quasi für alle Endknoten dieses Verfahren starte,
was Login dauert, also bin ich in N-My Login,
Nein, jetzt kann man hier so ein bisschen sparen,
dass man sagt, die N-halb Millionen gucke ich mir gar nicht an,
sondern ich fange jetzt bei N-halbe an,
dann bin ich bei N-halbe mal lockern,
das ist immer noch nicht so cool.
Und jetzt kann man sich aber noch überlegen,
wenn man jetzt die Analyse ganz genau macht, einen Großteil,
nämlich die N-Viertelknoten hier unten, die brauchen ja maximal einen Schritt.
Und die nur noch N-Achtelknoten da drüber,
die brauchen maximal zwei Schritte und so weiter.
Und dann kannst du noch so mit Summen und Reihen arbeiten und dann kann man zeigen,
dass das Ding tatsächlich in ON-Leute und nicht nur in ON-Malogin.
Also das macht die Aussage nicht falsch, das ist einfach
eine Schranke angegeben, die ein bisschen weiter oben ist,
die ja auch als erste Näherung total richtig ist.
Und wenn man jetzt noch viel rumrechnen kann,
kann man sein,
dass das
sogar in ON geht
Ups. Steht da auch gleich nochmal. Da jetzt nochmal
Pseudo-Code für dieses Bildmaxip. So sieht es dann aus.
Die Hiebgröße von A ist die Länge dieses Arrays.
Und dann fange ich hier nämlich auch bei der Hälfte
erst an, weil ich die untere Hälfte nicht brauche.
Und dann wandere ich die eben bis eins nach oben,
also bis zur Wurzel und für immer diese Maxi-Bify-Operation aus.
Genau. Ja, da kommt sogar nochmal,
aber ich glaube,
das habt ihr verstanden
Genau, und wenn man da jetzt als korrekt nachweisen will, kann man die schleifenden Variante da benutzen?
Zu Beginn jeder Iteration der Vorschleife ist jeder Knoten,
I plus 1 bis N, die Wurzel eines Max-Hiebs.
Das kann man sehr schnell zeigen, wenn man schon gezeigt hat,
dass Maxibify korrekt ist. Und wenn man dann zeigt,
dass das Ding terminiert, was auch ziemlich offensichtlich ist,
dann weiß man halt, die Vorschleife bricht ab,
wenn I gleich null ist und das bedeutet dann,
die schleifen wir ja, die geht ja weiterhin,
das bedeutet dann null plus 1,
also 1 ist die Wurzel deines Max-Hiebs,
also die Wurzel des Baums ist Wurzel eines Max-Siebs und dann folgt daraus eben die Korrektheit.
Doch, passt. Kannst du dir mal überlegen,
dass ja quasi, wenn da unten ganz viel fehlt,
also je mehr hier fehlt,
desto mehr kannst du ja hier auch weiter links anfangen.
Guck mal, wenn die, wenn hier 11,
9 und 4 auch fehlt,
dann brauchst du die sechs ja auch nicht mehr betrachten und
die zwölf auch nicht.
Deswegen klappt das immer mit dem Halbieren
Ja, genau, also man müsste jetzt als erstes zeigen,
dass Maxibify korrekt ist, das geht relativ schnell,
weil da nicht so viel passiert,
dann benutzt man die Schleifen in Variante, zeigt halt,
dass die bei der Initialisierung gilt, zeigt,
dass die bei der Iteration gilt, zeigt,
dass das Ding terminiert und dann kann man das benutzen,
um zu zeigen, das Bild Maxib korrekt ist.
Und da steht es nochmal,
lauft es durch ON mal Login beschränkt,
weil halt Maxibify durch Login beschränkt ist und wenn man das jetzt genauer analysiert,
dann sieht man sogar, dass das in ON beschränkt ist.
Mit dem eben beschriebenen.
So, genau
Jetzt wollen wir das machen. Und dann,
jetzt stellen wir, jetzt kriegen wir ein Arry von Zahlen,
wollen das sortieren. Jetzt stellen wir diesen Hieb her,
das geht ja in O von Ende, das ist schön.
O von Ende ist sowieso immer gut,
weil vielleicht gehe ich auch einmal über das Air rüber,
um zu gucken, ob es überhaupt schon sortiert ist oder so.
Da brauche ich auch O von N viele Schritte.
Jetzt habe ich diesen Hieb und jetzt?
Was kann ich jetzt machen? Jetzt kommt eine Kiesel.
Jetzt kannst du gleich mit deinen Kieseln arbeiten.
Wo ist denn
das maximale Element
Ganz oben, ne? Das maximale Element nehmen wir und
packen das in unsere Ausgabe Arry so. Und wo kommt
jetzt der Kiesel her? Weil jetzt ist ja doof,
jetzt habe ich hier ein Maxib und hier ein Maxib.
Und oben fehlt was. Was mache ich? Was könntest du machen,
aber dann hast du, da musst du so alles nach oben ziehen,
dann kriegst du vielleicht einen Baum mit zu vielen Kindern,
dann ist er vielleicht nicht mehr weniger.
Aber wo ist denn so ein kleiner Kiesel?
Wo sind die kleinen Elemente? Ganz unten. Also nimmst
du eins,
tust nach oben
Ist durchwand. Also ich habe ja ein Maxib.
Das oberste Element ist das Größte. Das nehme ich,
tue es ganz nach rechts in meinen Ausgabe, Arry.
So, jetzt habe ich das Problem, dass ich hier ein Maxi-Papieren,
Maxib habe und in der Mitte das Element ist irgendwie leer.
Ich weiß aber, ganz unten sind ja die ganzen kleinen Elemente.
Jetzt nehme ich mir von der untersten Ebene das Element ganz rechts.
Warum nehme ich mir das? Weil das in Arry auch
ganz rechts ist. Das nehme ich mir,
tue es nach oben und lasse es dann in den Baum,
so ähnlich wie bei dieser Maxi-Bify-Operation, nur quasi andersrum.
Ich lasse das jetzt, nee, genauso. Ich lasse das
jetzt nach unten wandern, bis es wieder ein maxib ist.
Also wenn ich mir unten ein kleines Element nehme,
die vier oder irgendwie sowas packe die noch um,
dann gucke ich wieder, dass ich mit Maxi-Bify die hieb,
den Hieb wiederherstelle
Und er ist gut. Laufzeit? Genau. And my Lock-in, ne?
Weil endviele Knoten, ich nehme ja immer das Maximum raus.
Und wenn ich den dann nach oben setze,
jetzt brauche ich auch wirklich Lock-in-Schritte, weil der Baum ja so groß ist.
Und dann bin ich in N-My Lock-in. Also Idee,
ups, bei dem Ding hier, ne?
Ich würde jetzt die 14 nehmen. Das ist ja
das größte Element, das ist ja ein Maxi.
Und die packe ich mir in meine Ausgabe, Erry.
Da nehme ich mir hier unten das kleinste,
also das Element ist ja nicht das Kleinste,
aber das ist halt ganz rechts.
Das ist auf jeden Fall kleiner als alle,
die hier auf dem Pfad kommen. Das nehme ich mir,
packe es ganz nach oben und führe halt die Maxi-Bify-Operation aus.
Das heißt, das wandert jetzt irgendwie hier 13,
12,
11 dahin
Und dann ist hier die 13 ganz oben, nämlich das größte Element.
Da nehme ich mir die und packe wieder das Element,
was jetzt hier ganz recht steht,
nach oben für die Maxipify-Operation aus und immer so weiter, Frage.
Das scheint allerdings ein bisschen sehr rundständig zu sein,
weil wir wissen ja praktisch schon, dass die untersten Momente die kleinsten sind.
Das heißt, dass sie den größten Teil des Decks wieder runterfallen.
Das heißt, wir setzen sie jedes Mal neu oben ran,
nur um zu warten, dass sie fast definitiv wieder bescannen haben.
Ja, aber guck mal, zum Beispiel hier bei dem zweiten Beispiel,
du nimmst die 14 raus, die 4 geht nach oben.
Also die Anmerkung gerade war für den,
für das Netz und so, für das Video,
dass das ein bisschen umständlich ist,
weil wir ja schon wissen,
dass unten
die kleinsten Elemente irgendwie sind
Genau, dadurch, dass wir wissen,
dass er die keinste Elemente sind, ist die Vermutung,
dass wir immer, wenn wir die noch umtun,
die sehr weit wieder nach unten fallen.
Und das ist jetzt aber gar nicht unbedingt so.
Wenn du dir das hier anguckst, hier ist die Eins
und hier ist sogar sowas wie die Elf.
Also die Elf wird wahrscheinlich gar nicht so weit nach unten fallen.
Das heißt, diese Intuition zu sagen, unten sind doch
ganz kleine Elemente, die passt halt nicht ganz.
Sondern unten sind immer nur Elemente, die kleiner sind
als alle anderen Elemente auf dem Pfad zu wurzeln.
Und das können, die können trotzdem ziemlich groß sein.
Und schon hier bei der Neuen tritt es ja nachher auf,
dass die gar nicht so weit fällt und die Elf fällt dann gar nicht mehr weit und sowas.
Die Eins fällt natürlich sehr weit wieder nach unten
Also gegeben ein Arry die Idee,
wir machen erst die Maxib, dann vertauschen wir die Wurzel.
Das ist das maximale Element mit dem Element ganz rechts unten.
Also wir können ja mit diesem Arry arbeiten,
wir nehmen die Wurzel und setzen die ganzen nach rechts ins Arry und das Element,
was bisher ganz rechts im Arry war, das kommt.
Nach vorne, dann ist das die Wurzel.
Hiebgröße um eins verringern, dann denken wir nämlich,
dass das Arry gar nicht so lange ist,
wie es tatsächlich ist für das, für den Hieb und fahren einfach weiter fort.
Beispiel 14 und 4 austauschen, 4 geht nach oben,
14 da und weil wir jetzt ja
die Hiebgröße verringern im Arry gehört,
dieser Pfeil geht jetzt weg
Die 14 gehört nicht mehr zum Hieb.
Die ist da jetzt nur noch, damit man sehen kann,
ah ja, wir haben die große Zahl uns gemerkt.
Jetzt führen wir die Maxibify-Operation auf die 4 aus,
tauschen also mit 13, 12 und 11 den Platz.
Das sind jeweils die größeren Elemente. Dann sieht das so
aus. Dann gucken wir wieder, Element ganz rechts im Arry
ist jetzt die 9. Also Element ganz rechts im Arry,
den Teil des Arys, der den Hieb beschreibt.
Also Hiebgröße A zeigt die Erziehung. Dann tauschen wir
die beiden aus, killen wieder hier die Kante,
weil das nicht mehr zum Hieb gehört und führen wieder die Maxibify-Operation aus.
Das heißt, die neuen tauschen mit der 12,
weil 12 am größten ist,
dann tauschen die neuen nochmal mit der 11,
weil 11 auch größer ist und da bleibt sie dann
Dann tauscht 12 mit 4, zack,
wird wieder aus dem Hieb rausgenommen, 4 wandert,
wieder nach unten, tauscht irgendwie mit 11 und 9,
dann tauscht 11 mit der 3, wird aus dem Hieb rausgenommen,
auf 3 wird die Maxi-Bify-Operation ausgeführt,
also tauscht das irgendwie mit der 10 und der 8 den Platz.
10 mit 1, ja, danke.
Drei Stunden Arbeit für 2 Minuten Vortrag
Ja, wir überspringen ein paar Schritte,
so sah es eben aus, so sieht es jetzt aus.
Dann können wir weitermachen. Sieben hat schon,
sieben wird mit eins getauscht, sieben ist das Größte.
Eins tauscht mit der 6 und der 4. Sie extauscht mit eins.
Noch mal ein paar Schritte überspringen. So,
und jetzt sind wir fast fertig. Drei tauscht mit eins
. Und Maxi-Bifa-Operation ausführen, das ist jetzt auch cool.
Dann tauschen, rausnehmen, fertig. Eins, zwei,
drei, vier, fünf, sechs, acht,
neun, 10, 12,
13,
14. Sortiert
Genau. Every steht jetzt an der letzten Stelle der höchste Wert.
Und dadurch, dass halt wir einmal Länge von A haben,
als Teiger quasi auf das Arry-Ende und einmal Hiebgröße A als Teiger dahin,
wo der Hieb quasi endet in diesem Arry.
Deswegen wird diese Hiebgröße immer um einen verringert und dadurch hier
in der bildlichen Darstellung sind immer die Pfeile weggegangen,
weil der es dann quasi nicht mehr zum Hieb gehört.
Und du kriegst dann eben raus einfach ein Arry, was
komplett sortiert ist. Also du fängst an mit dem Arry,
führst auf dieses Arry immer diese Bildmaxi-Operation aus und so.
Danach ist das Arry, enthält die gleichen Zahlen
Aber so, dass man, wenn man jetzt mit dieser Heat-Brille draufguckt,
dass Aaron Heap darstellt, und dann führst du diese Bild-Maxi-Operationen raus.
Das ist immer noch das Gleiche Area, aber so,
dass alle Elemente darin sortiert sind.
Ergo, anders als Merch-Sort, ist dieses Verfahren was?
In Place, ne? Genau. Also, genauso schnell
wie Merch-Sort mit O-Log-in, aber dafür in Place.
Weil man das Area jetzt anders rumsortiert möchte, also kleinstes,
mit so einer Casuals oder irgendwas, so kleinstes,
denen kann man es einfach mit Minz, EBIF machen.
Genau, die Frage war gerade, ob man,
wenn man das Area jetzt andersrum sortieren will, genau,
dann könnte man einen Min-Hiep nehmen.
Oder du sortierst es einmal und danach gehst du einmal rüber
und tauscht immer aus. Das geht ja auch ziemlich schnell
. Eine halbe Schritte
Jo. Da nochmal die Idee. Und so sieht das
dann eben im Pseudo-Code aus. Also ich kriege so ein RAR,
dann baue ich einmal den Hieb auf mit Bildmaxi,
mit ON-Schritten und dann gehe ich von Länge A bis 2
halt durch und tausche immer A1 mit AI aus.
A1 ist ja gerade mein maximales Element. Das tausche ich
dann mit meinem Element AI, dem letzten, in dem Hieb aus.
Und dann verringere ich Hiebgröße um eins, damit das Element A1,
was gerade an die Stelle AI gekommen ist,
nicht mehr zum Hieb gehört.
Und dann führe ich eben die Maxipify-Operation auf mein oberstes Element
im Array
Das ist jetzt hervorragend. Ja. Und wir freuen uns ganz lieb,
sortieren müssen in den Augen von Encover nicht auf.
Von dem Quadratmeter. Nee, du meinst, wenn du diese Bildmaxiebsache machen musst?
Genau, das ist ja das Bild maxibel. Also das,
wo du den Hieb aufbaust, das meinst du.
Der Siebaufbau geht in ON. Dann hast du also O
von N plus, nämlich nicht mal, sondern plus,
plus hier N-Mahl, die Maxibiver-Operation, also N-Ma-Log-An.
Das ist also N plus N-Ma-Log-An. Und das ist O
von N-Ma-Log-An. Weil das Ende dann quasi verschwindet
Kannst du nach oben abschätzen, dass du sagen kannst,
Ende ist kleiner als Endma Login, also hast du da
zweimal in My Login und das 2 wird in einer U-Notation verschwindet,
das da.
Dann sind das fertig. Genau. Und hier nochmal der Satz,
Heepsword sortiert ein Arry von Endzahlen in TTN My Login-Schritten.
Und es sortiert eben in Plays. Fragen. Das ist
Geisterfahrstelle als Enttäuschung. Gucken wir nochmal. Vielleicht,
vielleicht ja,
vielleicht nein
Mal schauen. Challenge, bis nächstes Mal. Geht es schneller
, das kann ich weiß? Das könntest du googeln,
ja, aber dann ist ja keine Challenge mehr.
Ich meine, das ist eine Drittklässler-Challenge, ne?
Geh mal nach Hause und google das. Da kann ja
jeder. Fragen. Das war Heepsword. Eigentlich ganz cooles
Verfahren, ne? Also was ihr mitnehmen solltet auch,
ist, dass das Ziel für einen war quasi irgendwie,
dass ich ein schnelles Sortierverfahren haben will
Und dann hat sich halt jemand gedacht, okay,
ich entwickle explizit eine Datenstruktur, die dafür gut geeignet ist.
Und bei der Datenstruktur ist es jetzt so,
dass die ja trotzdem weiterhin in einem Erry abläuft.
Aber das ist quasi die interne Speicherung. Also wenn dir
das jetzt irgendwie in der Programmiersprache implementieren würdet,
dann gibt es da irgendwie ein Interface,
dass einfach nur sagt, ja, hier, Bild,
Maxip und man kommt irgendwie an Vater und Kinder ran und solche Sachen.
Da sieht man nicht, dass die interne Speicherung Arry ist.
Müsste sie ja auch nicht sein,
nur mit dem Arry ist es schön effizient.
Ein Problem mit TV muss allerdings sein,
es würde ja am Anfang immer geben,
das war ja richtig
Nochmal? Weißt du das am Anfang? Am Anfang wurdest du
immer ein Lied machen, ganz egal, wie unser Ray 4 aussah.
Bei dem Heep South jetzt? Ja, genau,
weil du in der ersten Zeit, also die Frage war gerade,
ob man am Anfang immer erst mal einen Heep macht, ja, macht man.
Und das heißt, wenn wir dann einen Array hätten,
was schon fast sortiert wäre, bis vielleicht auch ein Element,
wie er dann jede Menge Zeit verschwindet, diese ganze Ordnung zu versauen,
indem wir alles daraus im Heed machen und dann wie lange jetzt noch mal ein Heep verkaufen,
das heißt, Heep South würde fast immer ungefähr die lange Zeit brauchen,
weil es ja alles in seine eigene Ordnung gewandelt und dann korrekt zu Okay,
die Frage geht in die Richtung von seiner Average-Case-Analyse.
Also weil die Frage quasi war, naja,
wenn das Area irgendwie schon fast sortiert ist und ich baue jetzt erstmal den Hieb auf,
jetzt bringe ich da quasi erstmal Unordnung rein, wenn man so möchte.
Und danach sortiere ich das wieder. Und dann ist die These,
dass Heapshot das ja quasi immer so machen würde.
Das heißt, bei Arrays,
wo ich vielleicht sonst gar nicht so viel tun müsste,
muss ich trotzdem jetzt viel tun und so weiter.
Das geht in die Richtung von Average-Case-Analysen, also sodass man sagt,
irgendwie, wie schnell ist das Verfahren eigentlich so im durchschnittlichen Fall so.
Und das ist relativ schwierig zu machen.
Deswegen machen wir das hier auch nicht. Wir machen eigentlich
nur Worst-Case-Analysen erstmal so. Und da ist das Verfahren
halt in ON mal locken,
das ist so schön
Und für den Fall, das Problem hast du eigentlich immer,
dass du bei jedem Verfahren irgendwie Fälle konstruieren kannst,
wo das Verfahren cool ist und Fälle konstruieren kannst,
wo das Verfahren dann total blöd ist.
Also bei Quicksort hatten wir ja auch die Aussage,
dass das in ganz, ganz,
ganz vielen Fällen in ON mal Login ist und sogar besser als Merch-Sort,
weil die versteckte Konstante schön klein ist.
Die Worst-Case-Analyse würde uns aber sagen, es ist ein Endquadrat.
Und hier sagt die Worst-Case-Analyse, halt ist es in ON mal Login.
Und jetzt gibt es durchaus Sachen, wo das ziemlich schnell geht.
Und es gibt auch Sachen, wo das irgendwie langsamer ist.
Bei Merch-Sort aber zum Beispiel, da ist es auch so,
dass du immer, auch wenn ich den sortiertes Erry gebe,
dann halbierst du das erstmal fröhlich.
Und danach vergleichst du die nochmal alle miteinander,
nur um festzustellen, dass sie wirklich schon sortiert sind.
Und dann fügst du sie wieder zusammen,
wo dann auch nicht
so sonderlich viel passiert
Und auch das dauert alles Zeit dann. Also ich meine,
bei Merchstord, wenn du hier schon ein sortiertes Area 1,2 hast und hier ein sortiertes Area 3,4,
dann machst du das trotzdem so, dass du 1,
2 dahin schiebst und 3, 4 dahin schiebst und so.
Das ist völlig ineffizient. Und bei anderen Verfahren halt auch.
Da wäre wahrscheinlich sowas wie so ein Insearch-Sort schön schnell,
dass man halt weiß, wenn das Area schon fast komplett sortiert ist,
dann ist es ein Insearch-Sort cool,
weil ich dann quasi rübergehe und nur bei den Elementen,
die wirklich noch nicht reinpassen,
da wandere ich dann einmal nach links wieder durch und gucke,
wo sie hingehören.
Kann man auch mal so mitnehmen,
dass man sagen kann, so wenn ich schon weiß,
dass mein Area prinzipiell ziemlich gut sortiert ist,
dann kann ich nur einen Search-Sort nehmen
Bei anderen Fällen nehme ich vielleicht was anderes. Wenn ich es in-place haben möchte,
nehme ich vielleicht Heepsword oder ein sehr komplexes Merch-Sword.
Wenn ich, ja. Man macht vielleicht eigentlich ein Surfen-Sword,
jede Menge Arbeit abnehmen, indem man kurz ein Wixword darüber laufen muss.
Kurz. Quicksword ist ja in ON-Quadrat sogar oder eben in ON mal Login so.
Ich weiß nicht, ob du dem Arbeit abnehmen kannst,
wenn du kurz Quicksword drüber laufen lässt.
Also klar, weil dann ist es sortiert.
Wenn ich Quicksword drüber laufen lasse, ist es sortiert.
Dann habe ich Insearch-Sword gerade alle Arbeit abgenommen.
Oder meinst du nur ein Detail von Quicksword? Ja,
ja, also zum Beispiel,
wenn man nur ein oder zwei Schritte Quicksword macht und dann
den Surfen-Sword weitermachen lässt
Oh, kommt drauf an,
weil wenn du in Search and Souls so machst,
wie wir das gemacht haben, dann wird ja quasi,
wenn du es einmal durchlaufen lässt,
nur das Element ganz rechts an seine richtige Stelle gesetzt.
Und dann weißt du, Links davon ist alles kleiner und rechts davon ist alles größer,
so, aber wie das jetzt hilft, dass du weißt,
das Element ist an der richtigen Stelle.
Also es würde ja dann nur, sagen wir mal,
nur einmal ein Fehlzeug gemacht hätten und jetzt zufälligerweise ein gutes Element genommen hätten,
dann würde ja die Linkenhälfte definitiv kleiner sein, wie die Rechte älter werden.
Das heißt, so ist das Wort,
wo wir maximal nur... Genau, aber wenn du eh schon weißt,
dass dein Arry ziemlich wahrscheinlich gut sortiert ist,
also bis auf zwei,
drei Elemente oder so,
dann wäre das jetzt ein Glückstreffer zu wissen,
das Rechte ist noch nicht an seiner richtigen Position
Quickstore ist dann ja ziemlich schlecht,
wenn die Aufteilung nicht in zwei ungefähr gleich große Teile zerfällt.
Wenn du jetzt ein fast schon sortiertes Arry nimmst,
dann ist es ja eher wahrscheinlich,
dass dein rechtes Element entweder schon an der richtigen Stelle ist oder
nur einen Platz weiter muss oder irgendwie sowas und dann hast du diesen Vorteil nicht,
dann wird das irgendwie doof.
So, soll es noch fragen?
Gut, ups. Also das waren die Heeps,
was sagt man,
Also das war so ein Hieb, also ein binärer Baum,
der Ebene für Ebene quasi voll ist,
bis vielleicht auf der letzten Ebene.
Da geht es nur bis zu einem gewissen Punkt und ab
da kommt nichts mehr. Und die wichtige Hieb-Eigenschaft,
eben jeder Knoten ist größer als alle seine Nachfolger.
Und es steht hier ja schon gut für Sortieren und für
Warteschlangen und Warteschlangen wollen wir uns gleich nochmal angucken.
Hier ist nochmal die Zusammenfassung für dieses Hiebs zum Sortieren.
Maxibify, Bildmaxib, Hiebshold. So,
und jetzt kann man Hiebs auch benutzen,
um Warteschlangen zu machen
Ja. Und zwar, doch,
Heeps können genutzt werden und effizient Prioritätswarte schlagen zu implementieren.
Jetzt hatten wir eben dieses Kapitel mit den Datenstrukturen noch nicht.
Warteschlangen kann man sich im Grunde genommen so vorstellen,
wie an der Supermarktkasse
Ihr habt Leute, die irgendwie an der Supermarktkasse stehen.
Und was ihr halt machen könnt, ist,
hinten kann was hinzukommen, ein neuer Kunde.
Und vorne kann einer rausgehen aus dem System quasi.
Kunde wird abgefertigt an der Kasse und geht raus aus dem System.
Das ist eine Warteschlange. Da brauche ich so Operationen,
wie irgendwie vorne den Kopf wegnehmen können und hinten was ranfügen können.
Sehr viel mehr brauche ich da irgendwie nicht. Und vielleicht
was zentraversieren dieser Warteschlange. Und bei einer Prioritätswarteschlange ist es jetzt so,
das ist eine Warteschlange, so wie in der Mensa.
Und zwischendurch kommt einer und sagt,
Moment, ich bin Professor,
ich muss weiter nach vorne
Und genau, also ihr wollt jetzt quasi wieder
eine Warteschlange haben und wenn ihr ein neues Element einfügt,
dann muss es nicht zwingen, ganz nach hinten,
sondern es darf irgendwie eine bestimmte Position eingegliedert werden.
Und was auch noch dazukommen kann, ist,
dass irgendwie in der Mitte der Schlange plötzlich jemand sagt,
ich muss ganz dringend auf Toilette, darf ich bitte vorgehen,
dann erhöht sich seine Priorität und er darf weiter nach vorne gehen oder sowas.
Solche Operationen will ich haben können. Und ich will die
möglichst schnell machen können. Das heißt, was ich haben will,
ist, ich will die wichtige Operation Maximum,
also was ist gerade mein Maximum in der Schlange,
dann will ich das,
da will ich es mir nur angucken,
dann will ich
das Maximum extrahieren können
Ich will in die Schlange neues Element X einfügen können.
Und anders als bei der normalen Schlange, wie gesagt,
nicht einfach nur hinten, sondern eine beliebige Position abhängig von diesem Schlüssel X.
Also wir machen das jetzt so,
dass wir quasi sagen, wir haben eine Schlange,
wo vorne das Element mit der höchsten Zahl ist.
Das ist halt die höchste Priorität und hinten ist das Element mit der niedrigsten Zahl.
Das ist halt die niedrigste Priorität. Und wenn ich jetzt sowas habe wie 10,
8, 6, 4, 2 und es kommt jetzt ein Element,
der sagt, ich habe eine 5,
dann muss ich das halt an die richtige Stelle eingliedern.
Und in Crease Key, in der Schlange S soll
die Position X halt um K erhöht werden.
Also das Ding mit dem Wert X soll um K erhöht werden.
Oder auf K,
glaube ich
Genau, so und das Ziel ist jetzt,
wenn man die jetzt einfach alle nur so hätte in so einem Arry,
dann könnte man das natürlich auch machen.
Dann sagt man so, ich packe die alle in Arry,
wenn jetzt ein Element kommt mit einer gewissen Priorität,
dann suche ich halt einmal in dem Area an,
welche Position das kommen soll.
Alles, was danach kommt, schiebe ich einfällt weiter
nach rechts und an die Position setze ich mich.
Kann man machen. Problem ist, das wird schnarch langsam.
Dann sind alle Operationen irgendwie in O von N oder so,
weil ich da ständig durch die Gegend kopieren muss.
Und was ich gerne hätte ist, ich möchte das gerne
in diesem O-Login-Zeit realisieren. So und jetzt kann man sich überlegen,
ob man dafür Heeps benutzen kann.
Kann man sonst würden wir das jetzt nicht machen,
aber wie kann man
das machen
Am Anfang ist die Schlange leer, nichts ist da,
es kommt ein Element. Dann kommt ein weiteres Element,
dann kommt ein drittes Element und so weiter.
Das muss ich irgendwie sicherstellen, dass das geht. Sprich,
es wird vielleicht am Anfang ganz oft diese Insert-Operation ausgeführt.
In die Schlange wird fünf, sechs,
eins und zehn eingefügt, irgendwas passiert.
Und dann wird vielleicht mal so eine Erhöhung des Kies eingeführt.
Ja, wie macht man das? Mit Aris habe ich
es ja gerade kurz so anskizziert, da wird das irgendwie langsam,
weil wir wollen das alles in O-Login-Zeit machen.
Wie kann man das machen mit einem Hieb
ganz oben
Genau. Ich fange an. Also die Aussage war gerade,
die Wurzel im Hieb, die ist ja immer das größte Element.
Also fange ich an. Wenn das erste Element kommt,
die zehn oder so, dann packe ich die da hin.
So, jetzt kommt das nächste Element. Das ist jetzt
irgendwie eine Acht. Was mache ich damit?
Ich lasse das irgendwie in diesem Hieb nach unten wandern.
So, das ist ja nicht größer.
Also bei dem, das ist ja kleiner als die zehn.
Also muss es irgendwie ein Kind davon sein.
Und dann tauscht das aus. Problem ist,
wenn ich jetzt schon so einen ganz großen Hieb habe,
Und jetzt kommt irgendwie eine Zahl.
Die will ich da jetzt einsortieren. Wie mache ich das?
Ich könnte jetzt bei der Wurzel anfangen und irgendwie gucken,
ist sie größer als die Wurzel.
Falls ja, soll es eine neue Wurzel werden.
Das ist aber irgendwie unpraktisch, weil was mache ich jetzt
mit der Wurzel? Wie macht ihr das?
Naja,
genau so
Ja. Ja, das heißt, du willst sie so drücken, ne? Ja,
dann kriegst du das Problem, dass, also ne,
du nimmst dein neues Element, das ist größer,
das packst du an die Stelle der Wurzel.
Jetzt ist die Wurzel quasi so frei fliegend. Und dann sagst du,
okay, jetzt gucke ich, welches Element, naja,
jetzt ist sie ja größer als beide Kinder, ne?
So, also muss ich mir erstmal irgendwie eins auswählen,
wo ich sie hinpacke. Dann fliegt das jetzt aber frei
herum. Und wenn ich das immer so weitermache,
jetzt kommt noch ein Problem, jetzt könnte es ja sein,
du landest irgendwie ganz links so bei so einem Blatt.
So, und das musst du jetzt ja auch noch weiter nach unten schieben.
Das heißt, du machst plötzlich eine weitere Ebene auf,
obwohl hier vielleicht noch Platz war.
Auch doof. Problemverstanden
Bis jetzt. Ja, das könnte ich machen.
Genau. Also wenn mein Element größer ist als die Wurzel,
dann packe ich es dahin, neben die Wurzel,
packe sie in das Arida ganz nach rechts unten und lasse sie nach oben wandern und so.
Dann kriege ich wieder so ein Maxip irgendwie.
Das könnte ich machen. Jetzt aber das Problem,
jetzt ist das neue Element vielleicht ja nicht größer als die Wurzel,
sondern irgendwie ein bisschen kleiner als die Wurzel,
aber zumindest größer als irgendwie das übernächste Element oder irgendwie sowas.
Was mache ich jetzt? Wohin das kleinste Element geht
Und das wieder durchaus lassen, dann müssen sie sich von
den neuen Momenten vorherige Großel, das alles vorzusetzen.
Ja, aber was machst du jetzt kurz mit dem neuen Element?
Also die Idee war gerade, ich nehme das kleinste Element,
tu das noch um, was mache ich mit dem neuen?
Das neue flattert jetzt irgendwie gerade noch rum. Genau,
ich kann auch gleich von Anfang an das Neue umsetzen.
Ja, genau, das mache ich. Ich lasse das
. Und das Schöne ist, ich lasse es nach oben
will laufen. Ich mache es jetzt nicht so,
dass ich es da einmal austausche, nach unten wandern lasse,
sondern ich mache es genau andersrum.
Ich nehme mal ein neues Element,
packe es ganz rechts unten in meinen Hieb und dann gucke ich,
wenn das jetzt größer ist als das Ziel,
dann tausche ich die
So weiter. Weil wenn es größer ist als sein Vater,
dann ist es ja auch größer als all die anderen,
die hier kommen. Das heißt, ich kann die tauschen.
Und dann lasse ich den immer weiter nach oben wandern.
Und dann bin ich wieder in. Ja, wieder in Log-End.
Ich gehe ja maximal ein, so ein Fahrt nach oben,
also bin ich wieder ein Log-End. Also Maximum, das ist jetzt,
oh Gott, das ist noch die Idee für Maximum,
beziehungsweise Expect-Maximum, an das Maximum ranzukommen,
ist ganz einfach, das ist einfach die 14 so.
Das ist einfach, ist zu extrahieren,
also rauszunehmen aus der Schlange,
ist ein kleines bisschen schwieriger, ich nehme die 14,
schmeiße die weg und das Problem hatten wir aber eigentlich schon beim Heepshot auch,
nehme ich einfach die 4,
packe die ganze Zeit nach oben und lasse das einmal mit einer Maxipify-Operation nach unten wandern.
Dann habe ich wieder Heep
Also Maximum,
also Hiebmaximum kriegen jetzt einfach die Wurzel zurückliefern und wenn ich das Maximum extrahieren will,
das sieht jetzt gerade ein bisschen kompliziert aus,
aber der Kern ist im Grunde genommen,
dass sich das Element, ist mein Maximum,
das liefere ich nachher zurück und hier in den drei Zeilen drei,
vier, fünf, da passiert quasi der Umbau,
an die Stelle der Wurzel A1 kommt das Element,
was bisher im Hieb ganz rechts unten war,
dann verringere ich den Hieb um eins und dann führe ich auf das Wurzelelement die Maxi-PV-Operation aus.
Also das,
was wir eigentlich auch schon beim Heebsword gemacht haben,
ich nehme das Maximum,
tue es irgendwo hin,
weil ich es gleich zurückliefern will und dann kommt das Element
ganz rechts unten im Hieb nach oben
und wandert nach unten
Beispiel dafür später. Heap Insert ist komplizierter. Da machen
wir jetzt das, was er eben gesagt hatte.
Ich füge das neue Element ganz rechts unten im Baum an,
also ganz rechts im Arry. Erhöhe den Hieb um eins.
Die Hiebkur ist um eins und lasse es dann nach oben wandern.
Sehen wir gleich. Hier ist erstmal jetzt diese Operation für Heap
in Kreas Key, weil das quasi aufs Gleiche hinausläuft.
Wenn ich das Element an der Stelle i um oder auf
diesen Wert hier erhöhen möchte, dann gucke ich einmal,
ist das überhaupt eine Erhöhung,
falls ja, liefere ich voll zurück.
Und sonst kriegt mein Element an der Stelle i
jetzt eben diesen Wert des Schlüssels
Und dann gucke ich immer. Ist das schon die Wurzel?
Also genau, solange es noch nicht selbst die Wurzel ist.
Und solange es größer ist als der Vater,
tausche ich das Element und seinen Vater aus.
Und I wird dann eben Vater I,
damit ich hier in der Schleife weiter durchgehen kann.
Also ich wandere quasi im Baum einfach nach oben.
Und dann kann ich halt damit diese Heep-Insert-Operation ausfinden.
Darüber steht nur das Gleiche nochmal, dass ich sagen kann,
ich erhöhe die Hiebgröße um eins und an die Stelle des neuen Elements
kommt jetzt eins mit minus und endlich als Wert.
Und dann erhöhe ich den eben auf den Schlüssel.
Deswegen hat man Heep-Insert einmal auf dieses Increase Key zurückgeführt
Aber von der Idee her sehen wir jetzt hier ein Beispiel,
wenn ich hier die 15 einfügen will,
dann packe ich mein neues Element, egal welchen Wert das hat,
packe ich ganz rechts unten in meinen Hieb.
Und jetzt vergleiche ich halt, ist das größer als der Vater?
Ja, ist es, also tausche ich sie aus.
Dann vergleiche ich wieder, ist es jetzt größer als sein Vater?
Ja, ist es, also tausche ich aus.
Größer als der Vater, ja, ist es, also tausche ich aus.
Und jetzt würde ich aufhören, weil diese Abbruchbedingung erfüllt ist,
dass ihn nicht mehr größer ist als eins.
Jetzt bin ich ganz oben angekommen. Und sonst würde ich
halt abbrechen, wenn hier irgendwie so eine Position erreicht wird,
dass der Vater nicht mehr größer ist
Hat. Ach so, das ist nur so ein,
ja, hier ist nur so ein Workaround, wir fügen,
wir wollen ja ein neues Element mit dem Wert Schlüssel einfügen.
Dann erhöhen wir den Hieb um eins, damit wir sagen können,
jetzt hat der Hieb ein Element mehr und da kommt jetzt quasi mein neues Element hin und erstmal belege ich das mit dem Wert minus unendlich,
damit ich dann diese in Krease-Key-Operationen ausführen kann und sagen kann,
bisher hättest du die Priorität minus unendlich,
jetzt sollst du die Priorität Key haben,
weil hier am Anfang getestet wird, ob das Element einen Wert hat,
der größer ist als das, wohin ich setzen will,
also ob es wirklich in den Krease ist.
Das ist aber so ein bisschen,
also die drei Zeilen sind, glaube ich,
nicht so spannend,
also da käme man
auch drum rum
Weißt du nur, weil das, ich glaube,
im Corman ist es genauso, deswegen habe ich das so drin gelassen.
Ja, so, das ist das Beispiel. Ja,
genau. Und dann noch so ein Beispiel für dieses Extrakt,
Extrahieren des Maximums, wenn ich jetzt das Maximum eben nehme,
dann kommt das weg und ich tue das Element,
was jetzt ganz rechts unten im Baum ist,
also die sechs, die kommt da hin, zack.
Und jetzt die 15 auch wirklich weg, weil ich die
ja irgendwie zurückliefere und gar nicht mehr in dem Arry drin haben will.
Und jetzt führe ich auf die sechs wieder diese Maxi-Bify-Operation aus, das heißt,
sie wandert einfach, tauscht Mitte 14 und Mitte 13 in dem Beispiel.
Und dann sind wir schon fertig
Da haben wir wieder einen Hieb. Genau. Fragen.
Was ist denn Prioritätswarteschlangen? Eine andere Möglichkeit, die zu
implementieren ist mit verketteten Listen. Die haben halt den Nachteil,
dass man nicht so gut an einzelne Elemente in der Liste rankommt.
Also wenn ich da irgendwie so eine Increase-Key-Operation ausführen will,
dann muss ich erstmal in das Element kommen,
wo ich das machen will.
Dann kann ich einen Schlüssel erhöhen und dann kann ich es eventuell nach vorne schieben.
Aber das wird ein bisschen hässlich. Wie würde man das machen,
wenn jemand jetzt in der Schlange sagen würde,
er hätte einen Hörspiel?
Dann führst du
diese Increase-Key-Operation aus
Die... Nee, das war die Insert-Operation.
Bei der Increas Key würdest du jetzt einfach nur...
Das Element an der Stelle i in deinem Array soll jetzt
auf den Wert Key erhöht werden. Jetzt guckst du einmal,
ist das wirklich eine Erhöhung,
so gehen wir jetzt mal davon aus, dass das eine ist,
dann setzt du einfach den Wert dieses Elements auf den Wert von Key.
Und jetzt, du weißt, das ist eine Erhöhung,
also weißt du, es ist weiterhin größer als alle seine Kinder.
Das heißt, für die Kinder ist weiterhin die Maxi-Eigenschaft erfüllt,
aber eventuell ist der Papi größer. Also machst du jetzt das,
was wir eben hatten und lässt das in dieser Beischleife nach oben wandern.
Du guckst immer, ist es größer jetzt durch die Erhöhung geworden,
ist größer geworden als sein Vater,
falls ja,
tauscht du
die beiden aus
Und immer so weiter. Was würde man machen, wenn er uninteressanter geworden ist? Also wenn man den Schlüssel verringern will, ja, könntest ihn runterfallen lassen. Ist aber auch,
das ist so ein bisschen, würde man das wirklich machen,
dann hat man nämlich dieses Problem, was ich eben schon einmal skizziert hatte,
wenn ich irgendwie ganz links im Baum, wenn ich hier,
wo haben wir mal ein Beispiel da,
wenn ich hier jetzt die sieben auf eins verringer,
dann würde ich das irgendwie mit der zwei, ne,
warte mal, doch ja, es funktioniert, Entschuldigung,
ich dachte gerade, der wandert dann immer weiter nach unten,
aber wir fügen ja kein neues Element ein,
also kann ja maximal ein Blatt werden.
Ne,
klappte,
alles gut
Genau, und die Crease-Operation könnte man auch hinkriegen.
Was ist sonst noch Fragen? Gut, dann,
mich wundert gerade die ganze Zeit, dass ich diesen,
ich dachte, ich hätte den Source-Code für diese Maxi-Pify-Operation auch.
Vielleicht kommt er jetzt in der Zusammenfassung.
Zusammenfassung, das war ein Hiebs. Ja, ist klar
, ne? Haben wir jetzt ja
so viel gesehen
Sollte klar sein, gut für sortieren und für Warteschlangen,
das Sortieren geht in ON mal Log-in und ist inplace,
das ist ziemlich cool. Gut für diese Prioritätswarteschlangen,
weil alle Operationen dann in O-Log-in gehen oder so,
über dieses Extrahieren des Maximums und so geht ja sogar in O1,
das ist alles ziemlich schön.
Das waren die Operationen, die wir zum Sortieren benutzt haben,
dieses Maxipify zur Aufrechterhaltung der Hieb-Eigenschaft, Bild Maxib zur Erstellung
des Maxibs und Heepsword dann eben zum Sortieren des Aris.
Man kann immer sehen, dass man irgendwie die vorherigen braucht,
also für das Bild Maxib brauche ich die Maxipifyen,
für Heepsword brauche ich beide sogar.
Dass da auch, dass man weiß, also das ist das Schöne daran,
dass man diesen Hieb in einem Erry speichern kann.
Man könnte den Hieb ja auch so speichern,
dass man sagt, ich habe einen Knoten und in der Implementierung
habe ich jetzt zwei Pointer zum linken und rechten Kind,
so wie man das bei einer verketteten Liste machen würde.
Dann wird es aber wieder ineffizient, wenn man an die
Kinder und so kommen will, das wird irgendwie schwierig.
Da kann man nicht so schöne Erry-Operationen machen. Also das Swappen,
also es wird umständlicher. Da ist das nochmal ein Beispiel.
Maxipify, Vergleich immer das Element mit seinen beiden Kindern.
Und dann tausche ich das mit dem größten aus.
Nicht mit irgendeinem von den beiden, sondern immer mit dem
größten von beiden. Ja, da ist der Code.
Warum war denn der vorher nicht da? Maxibify auf so
ein Element ausgeführt an der Stelle I. L ist das linke Kind,
er ist das rechte Kind und dann gucke ich hier,
wäre ich irgendwie der größte ist.
Ach ne, hier schon, da gucke ich und da.
Und in den Zeilen drei bis zehn gucke ich ein bisschen umständlich,
weil ich das größte Element ist und falls ich nicht selbst das größte bin,
dann tausche ich mit mir und dann führe ich auf meinen Jetzt geswapptes Element nochmal,
diesem Maxi-Pify-Operation aus.
Genau, das ist die, dann ist das die Bild-Marxieb-Operation.
Hiebgröße wird auf die Länge gesetzt und dann fange ich hier
eben bei der halben Länge an. Und heeps hot,
die Idee, ich baue erst einen Hieb auf und
dann nehme ich immer die Wurzel als maximales Element raus,
da auch nochmal im Code.
Und da die Zusammenfassung mit den Ergebnissen für die einzelnen Operationen
Genau, und Korrektheitsbeweise haben wir nur kurz erwähnt oder angedeutet.
Also wir hatten ja die schleifenden Variante für das Bild Maxib.
Man kann jetzt auch noch eine Schleifenden-Variante für das Heepsword machen.
Das geht auch relativ fix,
weil man halt davon ausgehen kann, dann ja,
dass das Bild Maxib korrekt ist und das Maxi-Pify korrekt ist,
dann geht das immer ziemlich schnell.
Aber die könnt ihr mal zur Übung machen oder eben dann,
wenn ihr nicht weiterkommt, das Kapitel im Kormen lesen.
Ich glaube, das sind irgendwie 15 Seiten da drin,
was wir heute gemacht haben zu diesen Heep-Geschichten.
Da steht drin, was man zum Beispiel als Schleifenden-Variante für
Heepsword nehmen kann. Also wer da keine Idee hat,
kann da
mal nachgucken
Genau, das dazu. Und
letzte Wiederholungen sind auch gleich fertig.
Ja. Ja
Du meinst, das wäre das Problem,
was wir dann eigentlich im Prinzip jedes Mal hören.
Wir feiern können. Jetzt mal, jetzt wird also Mottember,
M-Praktisch, aber das Problem ist,
du denkst immer noch in dem Schimmertar, dass der erste,
die feiern, die auf einen vollkommen unnötig feiern.
Meistens da ist die solche Zeit maximal ändern,
weil du musst ja alles...
Es geht mir gar nicht so. Dass bei dem einmal
ein O-Datch vorsteht und bei dem anderen
mein Täter
Ich übersetze jetzt immer noch. Ihr habt jetzt alle
das Problem verstanden, aber noch keine Lösung, ja?
So,
was hat dich gestört
Wieder. Genau. Du müsstest halt bei dem,
bei dem Bildmarkt-Sieb noch, also beim Bildmarkt-Sieb ist die Laufzeit
durch ON mal Login beschränkt, das ist richtig.
Und eine genauere Analyse zeigt, dass die Laufzeit sogar durch ON beschränkt ist.
Ja, genau. Und jetzt denkt nochmal darüber nach,
wie das Bild maximal funktioniert hat.
Wir hatten eine Vorschleife, die von N halbe bis 1
gegangen ist
Brauche ich mindestens auch von Omega von End viele Schritte.
Von End halbe bis eins, ne? Eine halbe Schritte.
Daraus folgt sofort, dass du Omega von End brauchst.
Also schneller geht's, es geht nicht schneller als O von
N. Oder Omega von End jetzt.
Jetzt will ich keine Schrank gefunden, Mann.
Nicht braucht, sondern das... Also die eigentliche Antwort ist,
eine genaue Analyse zeigt, dass die Laufzeit sogar durch O von End beschränkt ist.
Da könnte man auch schreiben, Täter davon enden.
Warum kann man schreiben, Täter von denen?
Ich weiß es so von N. Jetzt muss ich nur noch
zeigen, dass es auch ein Omega von Ende ist
Dann ist es ja ein Täter von denen.
Ja, aber hören wir doch mal weiter zu.
Also, du musst nur noch zeigen,
dass es auch ein Omega von Ende ist.
Ja? Jetzt guckst du dir den Source-Code an.
Im Source-Code ist eine Forschleife, die auf jeden Fall ein
halbe Mal ausgeführt wird. Ergo, Omega von denen.
Er runzelt, er sagt, juck. Wenn du einen
Schritt dann mindestens brauchst, dann ist es Omega von denen.
Es ist Gleit oder Mehrleit. Wenn es sich stört,
könnte man auch sagen, es ist also in Omega von Enhalbe,
was aber das Gleiche ist wie Omega von N,
weil das ja
nur eine Konstante ist
Also da sollte dann vielleicht besser stehen. An genau dieser Stelle,
wo das O von entsteht, im zweiten Punkt sollte dann
vielleicht Täter davon entstehen. Aber die Idee ist halt hier,
die Laufzeit ist durch ON mal Log-End-Beschränkt, da stimmt es auch,
dass man da lieber nur O schreibt, nicht Täter,
weil die untere Schranke ist nicht En mal Log-End,
da wirklich 0O, aber an der Stelle ist,
kann man sagen, ich kann das jetzt verbessern auf O von N.
Gleichzeitig weiß ich sowieso, dass es in Omega von Ende
ist. Also es ist ein Täter von Ende
So, genau. Und das waren die Sachen mit Hiebs für Warteschlangen.
Da hatte man diese vier Operationen, Hieb Maximum,
Hieb Extract Max, Heep and Crease, Key und Heep Insert.
Genau, dann da die Ideen, ne? Idee von Heep Insert,
ich füge das ganz unten rechts im Arry ein und im Baum auch.
Und dann lasse ich es nach oben wandern.
Bisher haben wir alles immer nach unten wandern lassen.
Das ist so dieses eine Neue jetzt, dass man sagt,
hey, ich lasse es nach oben wandern und die
anderen Operationen gehen dann sehr einfach.
Also diese Heep-Insert-Operation,
das ist die Spanne
Genau, und da nochmal der Source-Code für die Übersichtlichkeit.
Hier passiert die spannende Arbeit in den Teilen 5 bis 7 von diesem Algorithmus 11.4.
Da passiert eben die Arbeit, dass sie es nach oben wandern lasse.
Genau. Und auch da, jetzt haben wir gezeigt,
dass die alle, wir haben jetzt alle gezeigt,
man kann von allen zeigen, dass sie korrekt sind,
die Zeitschranke ist einfach, da kann man auch wieder Täter sagen,
dass die Arbeit mit einem Täter von Login.
Genau, und hieb Maximum sogar in Täter von 1,
das ist ja auch klar,
da lief euch ja nur das oberste Element zurück.
Und dann müsste man da eben auch jetzt nochmal für
die Korrektheitsbeweise bei den vier Operationen, wobei der eigentlich,
also eigentlich nur für dieses hieb in Crease Keeno,
die anderen tun ja alle
das Gleiche
Genau, das könnt ihr auch noch mal zur Übung machen,
wenn ihr mögt. Fragen. Zum ersten, zum zweiten
. Zum dritten, zum vierten. Gut,
dann sind wir für heute fertig mit dem Heeps.
Wir machen mal so Pause bis 10 vor oder so,
10 vor 11, machen wir Pause und dann mache ich mit denen,
die dann noch da sind, noch die Datenstrukturen,
die wahrscheinlich überwiegend bekannt sind.
Da gehen wir halt einmal durch und gucken uns die an.
Stack, Q, verkettete Listen
, Bäumegrafen
Genau. Und nächstes Mal beschäftigen wir uns dann mit der Frage,
ob wir noch schneller sortieren können als dieses,
jetzt haben wir zwei Verfahren,
die in Täter N mal Login sind.
Das eine ist Inplace, das eine ist nicht Inplace,
geht es noch schneller.
Damit wollen wir uns ja nächstes Mal nochmal beschäftigen.