JAVA FÜR JEDER: Datenstruktur

1. Einführung: Hallo und willkommen zu einer neuen Klasse. Wir haben bereits die grundlegenden Konzepte von Java und Programmierung im Allgemeinen behandelt. Und in dieser Klasse sprechen wir über Datenstruktur. Also zunächst definieren wir eine Datenstruktur. Welche Arten von Datenstruktur haben wir in der Programmierung, wie sie zu erstellen und zu verwenden. Und er wird sich auf lineare Datenstrukturen wie Stacks, Warteschlangen und LinkedList konzentrieren. Und wir haben bereits über Arrays gesprochen und sie in den vorherigen Klassen verwendet. Also würden wir uns hauptsächlich auf Stack Cuz LinkedList konzentrieren. Also im Stack, lernen, wie man selbst einen Stat erstellt und wie man den eingebauten Java-Stack verwendet, wie man den verknüpften Listen-Stack verwendet. Dann fahren wir mit einer Warteschlange fort. Wir machen das Gleiche mit der Warteschlange. Und dann erstellen Sie endlich unsere einzeln und doppelt verknüpfte Liste, um Sie im nächsten Video zu sehen. 2. Datenstruktur: In diesem Video werden wir über Datenstrukturen sprechen. Und Datenstruktur ist ein spezielles Format zum Organisieren, Verarbeiten, Abrufen und Speichern von Daten, in dem es mehrere grundlegende und erweiterte Strukturtypen gibt. Jede Datenstruktur ist so konzipiert, dass Daten an bestimmte Zwecke angepasst werden, so dass auf sie zugegriffen und mit einer geeigneten Weise gearbeitet werden kann. Wie Sie hier sehen können, haben wir zwei Arten von Datenstruktur. Wir haben das lineare und das nichtlineare. Zum Beispiel ist Array ein, ist ein Beispiel für eine lineare Datenstruktur, und wir haben es so oft in den vorherigen Klassen verwendet. Wir haben auch Stack- und verknüpfte Listen. In der LinkedList haben wir einzeln und doppelt verknüpfte Listen. Und der nicht-lineare Typ, wir haben Graphen und Bäume. Also in dieser Klasse werden wir lernen, wie und wann wir jeden von ihnen verwenden sollten. Und wie können sie uns helfen? Und was sind die Vorteile? Um Sie im nächsten Video zu sehen. 3. Array: Ein Stapel ist eine lineare Datenstruktur, die einer bestimmten Reihenfolge folgt , in der die Operationen ausgeführt werden. Es gibt viele reale Beispiele für einen Stapel. Zum Beispiel sind die Spiele, die übereinander gestapelt sind, so dass sie aktualisiert werden, was sich oben befindet, die erste, die entfernt werden. Und die Platte, die an der untersten Position platziert wurde, bleibt für die längste Zeit im Stapel. Hier haben wir zum Beispiel unseren leeren Stapel und wir haben zum Beispiel die Nummer eins geschoben , und dann haben wir es in Nummer zwei und dann drei geschoben. Also haben wir 123. Nun, wenn wir ein Element herausnehmen wollen, wird drei nehmen, die das letzte Element ist, das eingegebene. So kann einfach gesehen werden, um die Livoreihenfolge zu folgen, die zuletzt in ist, zuerst heraus. Also hier haben wir zwei Hauptoperationen, die Push und Pop. Jetzt haben wir eine Stack-Klasse in Java, aber wir verwenden sie nicht in diesem Video. Wir werden die Methoden einfach selbst implementieren. Und um den Stack zu implementieren, haben wir ein Array verwendet. Also lassen Sie uns voran und verwenden Array, um unseren Stack zu implementieren. Lassen Sie uns voran und erstellen Sie ein neues Projekt. Nennen wir es. Und dieser Name des Pakets als Phase. Und, und dieses Paket wird erstellen. Das ist also unser Klassen-Array-Stack. Und Lassen Sie uns eine Schnittstelle erstellen und nennen es Stack. Also hier haben wir Schnittstelle, und hier werden wir alle Methoden haben. Das ist also unsere Schnittstelle. Und so haben wir zunächst, wie Sie sagten, die Methode Push and Pop. Es wird also öffentliche Leere schieben, und wir werden ein Objekt schieben. Es können ganze Zahlen, Zeichenfolge, Zeichen usw. sein. Und eine andere Methode, die ein Objekt auftaucht. Und lassen Sie uns einige andere Methoden erstellen. Anstatt also zu knallen, ein Element zu knallen, und wenn wir ein Element Pop, verschieben wir es aus dem Stapel. Wenn wir jedoch nur einen Blick auf dieses Element werfen wollen, müssen wir eine andere Methode erstellen und wir werden es nennen. Also werfen wir nur einen Blick auf dieses Objekt mit dieser Top-Methode. Und lasst uns weitermachen und eine andere Methode erstellen. Zum Beispiel die Größe, um die Größe des Stapels und der SMD zu überprüfen. Es ist leer. Und um zu überprüfen, ob der Stapel leer ist oder nicht, wird ein Boolean true zurückgegeben, wenn er leer ist und andernfalls false. Also hier haben wir unsere Methoden. Jetzt. Wir haben hier ein Problem. Denn wann immer wir Array schieben und wiederverwenden wollen, wenn wir also pushen wollen, ist das Array voll, wir haben ein Limit für das Array. Und zum Beispiel, sagen wir, die Fläche ist von Größe vier. Und wir sind bereits auf Elemente gedrängt. Und wir haben versucht, den fünften zu schieben. Dann haben wir hier einen Durchschnitt. Da das Array begrenzt ist und wir können nicht fünf Elemente in ein Vier-Element an einem schieben. und natürlich, wenn Sie ein Element Pop wollen und der Stapel leer ist, dann wird nicht haben, wird kein Element haben, um von oben zu sehen -Methode. Um das zu beheben, müssen wir unsere eigene Exception-Klasse erstellen. Lassen Sie uns also voran und erstellen Sie unsere Ausnahme. Lassen Sie uns es Stack-Ausnahme nennen. Und wie üblich erstellen wir einfach unsere öffentliche Ausnahme des Konstruktors. Und wir nehmen eine String-Nachricht und ziehen das Abendessen. Und natürlich gehen wir zu erweitern, sorry, die Exception-Klasse zu werfen , um es in dieser Klasse zu verwenden. Also jetzt sind wir mit dieser Stark-Ausnahme fertig. Gehen wir zurück und wir müssen diese Statik diese Ausnahme werfen. Also löst eine Ausnahme aus. Und das Gleiche. Andere Methoden, die Ausnahme. Und jetzt sind das unsere Methode. Also hier haben wir einen Fehler wirft. Nun gehen wir zurück zur Array-basierten Stack-Klasse und implementieren diese Methode, die früher hier erstellt wurde. Zunächst müssen wir die Stack-Schnittstelle erweitern oder implementieren. Denn wann immer wir eine Schnittstelle verwenden möchten, müssen wir hier Implementierungen hinzufügen und wir werden die Stack-Schnittstelle implementieren. Und natürlich haben wir einen Fehler, der sagt, dass wir abstrakte Methoden geerbt haben und dass wir implementieren müssen. Also lasst uns gehen und jede Methode, und das sind unsere Methoden. Beginnen wir also mit dem ersten, wir müssen natürlich den Konstruktor erstellen. so zuerst, wir haben heute, und es könnte eine ganze Zahl String, Zeichen, doppelt alles sein. Also geben wir ihm den Wert des Objekts und lassen Sie es uns nennen. Und natürlich haben wir unsere ganze Zahl weniger als m und so wäre dies, wo wir uns bewegen werden. Lassen Sie uns jetzt unseren Konstruktor erstellen. Und der Konstruktor der Basis. Dies ist also der Konstruktor und es wird die Kapazität des Arrays oder des Stacks nehmen , wenn Sie möchten. Und natürlich werden wir das Objekt bei einem mit dem Wert der Kapazität instanziieren . Und wir haben immer noch Top. Also zuerst sagen wir, dass tau gleich minus1 ist, und wir werden sehen, warum in einer Minute. So top ist gleich minus1, und hier haben wir öffentliche. Das ist also unser Konstruktor. Nun gehen wir zu unserer leeren Methode. Wenn beispielsweise top gleich minus1 ist, geben Sie true zurück, das ist leer, andernfalls false zurück. Also, wenn top gleich minus eins ist, ist es in der Anfangsbedingung oder wir haben nichts und der Stapel gibt nur true zurück, sonst false zurück. Nun, wir haben eine Abkürzung dazu. Anstatt also zurück zu sagen, andernfalls zurückzukehren, können wir einfach sagen, dass die Rückkehr gleich minus eins ist. Also diese Aussage, top ist gleich minus eins. Es wird prüfen, ob top gleich minus1 wird automatisch einen booleschen Wert zurückgeben. Und die Rückgabe eines Boolean hier würde dazu führen, dass eine boolesche Methode zurückgegeben wird. Also, wenn die Spitze gleich minus eins ist, wird es wahr zurückgeben. Andernfalls wird false zurückgegeben. Jetzt haben wir immer noch die Größe, die einfach ist. So wird Jahr einfach zurückgeben, was wir hier haben, ein Top plus eins. Also zuerst haben wir oben ist gleich minus eins. Also, wann immer wir die Größe wissen müssen, fügen wir einfach eins an die Spitze. Also hier haben wir minus eins plus eins gleich 0. Die Anfangsbedingung des Stapels ist also von der Größe 0. Gehen wir jetzt zu unserer Push-Methode. Also haben wir unseren Busch. Und hier müssen wir zuerst überprüfen, ob der Stapel voll ist, dann können wir keine weiteren Elemente hinzufügen. Also zuerst müssen wir die Größe einstellen. Ist gleich der array.length. Also, wenn wir die Größe haben, die top plus eins gleich array.length ist , als wir unsere Ausnahme hier werfen müssen. Eine Ausnahme auslösen. Diese Ausnahme mit einer Methodenmeldung. Es sagt, dass SQL. Wenn das nicht der Fall ist, fahren wir normal fort. Was wir also tun werden, ist zuerst inkrementieren, da wir ein Element hinzugefügt haben, nicht minus1 mehr, es ist gleich plus eins, das gleich 0 ist. Also jetzt, wenn wir die Größe verwenden wollen, bekommen wir Top plus 10 plus 11. Und das ist, wie viele Elemente wir im Moment im Stapel haben , wenn wir die Push-Methode verwenden. Also jetzt, nachdem wir oben inkrementiert haben, müssen wir das Array auf dem Wert des Objekts hören, das wir hier eingegeben haben. Und jetzt sind wir mit unserer Push-Methode fertig. Gehen wir zu unserem Dock. Hier. Zuerst müssen wir überprüfen, ob unser Stack leer ist, dann haben wir kein Element zum Anzeigen. Wenn es leer ist. Dann werfen Sie diese Ausnahme. Ausnahme und sagen, dass der Stapel leer ist. Nun, wenn dies nicht der Fall ist, dann fügen Sie unser Element einfach den Indexbecher hinzu. Jetzt gehen wir zu unserer endgültigen Methode. Und die Methode, die wir überprüfen müssen, ob es leer ist. Wenn der Stapel leer ist, müssen wir eine Ausnahme auslösen und das sagen. Und andernfalls müssen wir dieses Objekt zurückgeben. Was immer wir oben haben. Hier. Zum Beispiel, wenn wir hier pop verwenden, dann müssen wir dieses Objekt zurückgeben und es aus dem Stapel verschieben. Wenn Sie jedoch stop verwenden, dann werden wir nur einen Blick auf dieses Objekt gleich drei ist , ohne es aus dem Stapel zu entfernen. Also gehen wir zurück. Und hier, vor allem, lassen Sie uns ein Objekt ClassName erstellen und zurückzukehren. Das ist also das Objekt, das wir zurückkehren werden, und es ist. Jetzt starten wir das Objekt hier und diese Variable zurückzugeben. Und wir müssen dieses Element entfernen, also geben wir ihm einfach einen Wert von null. Und jetzt tun wir es nicht, wir haben ein Element entfernt, also müssen wir das dekrementieren. Also zum Beispiel, wenn wir drei Elemente haben und wir die Pop-Methode verwenden, dann wird unsere variable oben von drei auf zwei zu eins dekrementieren. Also werden wir einfach um ein Top-Minus-Minus dekrementieren und dieses Objekt und diese Variable hier zurückgeben. Was wir hier bekommen, ist, dass wir unsere Schnittstelle, unsere Ausnahme und unsere Klasse, die wir haben, alle unsere Methoden erstellen unsere Ausnahme und unsere Klasse, . Im nächsten Video erstellen wir also unsere Treiberklasse und verwenden diese Methoden darin. 4. Stack: Nun, da wir alle unsere Methoden haben, lassen Sie uns unsere Treiberklasse erstellen. Also das, das ist unser Fahrer. Und ich würde Hauptmethode. Natürlich werden Sie eine Stack-Ausnahme auslösen. Oder wir können Ausnahmen sagen, da Stack-Ausnahme eine Unterklasse der Exception-Klasse ist. Und vor allem müssen wir stattdessen unseren auf einem Basis-Stack S-Namen erstellen, einen Stack mit einer Kapazität von Port, zum Beispiel. Nun, das erste, was wir tun werden, ist, ein Element hinzuzufügen, das, also verwenden wir den Stapel, den Bush. Lassen Sie uns eine weitere hinzufügen und stapeln Sie den Push, um die drei zu stapeln. Also werden wir als dieses Beispiel zu tun. Also zuerst haben wir einen leeren Stapel. Dann haben wir drei Elemente geschoben. Und jetzt, was? Es wird hier passieren, wenn wir diesen Code ausführen, gehen wir zu unserem Array-basierten Stack. Wir werden diese Methode dreimal verwenden. Also vor allem haben wir die Spitze zunächst gleich minus eins ist. Als wir die Nummer eins geschoben haben. Was hier passiert ist, ist vor allem, es sollte überprüft werden, dass die Größe dieser Größe gleich array.length ist. Jetzt ist die array.length die Kapazität hier. Also diese Kapazität und die Treiberklasse hier ist die array.length. Nun ist die array.length hier gleich vier. Es ist also ein PE, da die Größe gleich plus eins ist und oben gleich minus1 ist. Und anfangs so Größe gleich 0, da wir kein Element haben und 0 nicht gleich vier ist. Also werden wir die Stack-Ausnahme nicht auslösen. Also, jetzt werden wir die Spitze erhöhen. Jetzt ist DOB gleich 0. Und in diesem Fall werden wir dieses Element hinzufügen, das eins ist. Wir werden es dem bei a hinzufügen, an der Position 0, da wir es hier inkrementieren. Nun, das Gleiche. Wir werden das Gleiche noch zwei Mal für Objekt 23 machen, für ganze Zahlen 23. Also, und wir werden überprüfen, ob Größe. Jetzt ist die Größe gleich eins. Da die Größe gleich plus eins ist und oben gleich 0 ist. Die Größe ist also gleich 0 plus eins. Und natürlich ist es nicht gleich vier, ist nicht gleich der Länge. Also ist der Stapel noch nicht voll, und wir erhöhen ihn noch einmal und wir speichern ihn an einer Position eins, an einer Position eins, dann Sie Element und dann an der Array-Position zum zweiten, dem dritten Element. Also hier lassen Sie mich die Seiten hier überprüfen. Also drucken wir Stapelgröße. Und nach dem Hinzufügen wird dieses Element gehen. Wir werden die Größe, die Größe überprüfen. Und schließlich werden wir es überprüfen, nachdem wir das dritte Element hinzugefügt haben. Gehen wir also voran und führen Sie diesen Code aus. Sieh mal, was passieren wird. Also zuerst haben wir diese Größe gleich 123. Und lassen Sie mich den Stack verwenden, ist eine leere Methode. Also hier ist der Stapel leer, er sollte true zurückgeben. Der Stapel ist also leer. Nun, wenn wir es zum Beispiel hier verwenden, ist der Stapel leer. Es sollte falsch zurückgeben. Da der Stapel nicht leer ist, haben wir drei Elemente im Stapel. Jetzt haben wir auch den Stapel, die Spitze. Hier. Wir haben drei Elemente. Wenn wir also den Stapel oben verwenden, wird es uns diesen Wert geben, ohne ihn zu entfernen. Also lasst es uns hier benutzen. Wir sagen oberstes Element. So diese Daten. Und lassen Sie uns den Code ausführen, der uns das oberste Element gibt, ist gleich drei. Jetzt lasst uns den Pop benutzen, Pop, und es wird uns auch drei geben. Allerdings, wenn wir den Stapel verwenden, die Top-Methode, wieder hier, jetzt, wo wir das Element drei entfernen würde nicht drei bekommen. Wir werden jetzt zwei bekommen, da wir dieses Element verschieben, jetzt ist das neue Element an der oberen Position das Element zwei. sind also alle Methoden, die wir in der Array-basierten Stack-Klasse und natürlich der Schnittstelle implementiert haben. Das ist es also für dieses Video. Wir sehen uns im nächsten. 5. Matching: Lassen Sie die Verwendung von Stack demonstrieren. Also machen wir ein Beispiel. Betrachten wir dieses Tag. Also hier haben wir unseren Stapel, und lassen Sie uns ein Beispiel für Symbol-Matching machen. Unser Programm sollte also entweder zurückgeben, dass der Ausdruck gültig ist oder nicht. So zum Beispiel sind dies die Öffnungssymbole, und das sind die schließenden Symbole. Lassen Sie mich auf diese Weise schreiben. Also hier haben wir unsere drei Symbole. Und lassen Sie mich hier einige Beispiele schreiben. Zum Beispiel, wenn wir sagen Etch. Also sollte unser Programm hier true zurückgeben, da dieses öffnende Symbol ein schließendes hat. Allerdings, wenn wir, zum Beispiel, sagen wir Kante, und lassen Sie mich eine hier platzieren. Dieses Öffnungssymbol hat also kein schließendes Symbol, bevor ein neues geöffnet wird. Also hier haben wir das. Und um ein gültiger Ausdruck zu sein, sollten wir hier einen hinzufügen und Sie haben diesen verschoben. Nun folgt jedem öffnenden Symbol ein schließendes Symbol. Und natürlich können wir hinzufügen, was Sie wollen. Und so ist das ein gültiger Sinn. Jedem öffnenden Symbol folgt ein Schließen. Was wir also tun werden, ist, einen Ausdruck zu akzeptieren und dann jede Öffnung, jedes öffnende Symbol im Stapel zu speichern . Nehmen wir an, wir haben diesen Ausdruck. Ok? So haben wir zum Beispiel a, B, C und D. Lassen Sie mich auf 20 klicken. Und so ist dies unser Ausdruck und wird durch diesen Ausdruck eins nach o gehen. Also passt a zu keinem dieser öffnenden, öffnenden Symbole. Also werden wir es ignorieren und zu diesen geschweiften Klammern gehen. Und es passt zu diesem. Also haben wir es im Stapel gespeichert. Also hier haben wir, jetzt diese geschweiften Klammern. Dann gehen wir zu B Wir haben nicht bei B nicht übereinstimmt keiner von diesen, eines dieser Symbole, wird es ignorieren und zu diesem gehen. Dieser stimmt auch mit keiner dieser Öffnungen überein, aber er stimmt mit der schließenden überein. Also hier haben wir diese Übereinstimmungen am besten. Und natürlich werden wir dieses Element in den Stapel legen, es mit diesem vergleichen. Wenn sie gleich sind, dann werden wir unseren Ausdruck fortsetzen. Andernfalls werden wir falsch zurückgeben. Der Ausdruck ist ungültig. Also machen wir das Gleiche hier. Wir haben diese Fantasien und ich werde sie vergleichen. Das hier. Wir werden es in den Stapel legen und es mit diesem vergleichen. Und schließlich haben wir auch die eckigen Klammern. Nun könnten wir zum Beispiel auch so etwas haben. Also, was hier passieren wird, ist lassen Sie mich, lassen Sie mich löschen ist. Und so ist das unser Ausdruck. Und vor allem, werde ich das ansehen. Es ist ein öffnendes Symbol, so wird es hier platzieren. Und dann schauen wir uns das zweite Element an. Wir haben eckige Klammern. So ist es auch ein öffnendes Symbol, und wir werden es im Stapel speichern. Also werden wir es schieben. Also werden diese Phantasien hier runtergehen und die eckigen Klammern hier. Jetzt werden wir das dritte Element überprüfen, dieses schließende, wir werden es mit dem obersten Element im Stapel vergleichen. Also hier haben wir eine schließende eckige Klammern und eine öffnende eckige Klammern, das Spiel. Also werden wir das einfach von hier aus abhauen. Und wir werden hier weitermachen. Und natürlich werden wir hier die Klammern setzen. Nun, danach werden wir dieses Öffnungssymbol mit dem letzten Element hier vergleichen. Und natürlich das Bild, dann ist unser Ausdruck gültig, sonst wäre es ungültig. Das ist also eine schnelle Idee über dieses Problem, und fangen wir mit dem Schreiben von R-Code an. Also hier haben wir unseren Array-basierten Stack. Lassen Sie uns eine neue Klasse und Name und Symbol Matching erstellen. Und jetzt Klasse, natürlich, haben wir unsere Hauptmethode und wir werden eine Methode erstellen, die einen Boolean true zurückgibt, wenn der Ausdruck gültig ist, andernfalls wird es false zurückgeben. Es wäre also ein privater statischer Boolescher Wert. Lassen Sie uns es nennen, validieren, und es wird einen Ausdruck als eine Form von String akzeptieren. Nun beginnen wir zunächst mit der Y-Schleife. Und wir werden sehen, was wir hier als Bedingung setzen werden. Lassen Sie uns nun unseren Array-basierten Stack erstellen und mit dem Umfang des Ausdrucks diese Länge. Die maximale Anzahl von Elementen, die im Stapel gespeichert werden können, ist also die maximale Anzahl von Elementen in dieser Zeichenfolge. Also, wenn sie sich alle öffnen, können wir sie alle speichern. Aber natürlich wird es einen ungültigen, falsch zurückgeben, da wir sie nicht geschlossen haben. Jetzt haben wir, unser Stack hat zum Beispiel einen Index erstellt , den gleichen Index. Es wird bei 0 sein. Und eine boolesche Anweisung ist gültig. Nun, vor allem, um wahr und Charakter gleich zu sein, lassen Sie uns den Strom nennen. Jetzt. Obwohl es gültig ist und warum dieser Ausdruck gültig ist, werden wir diesen Code weiterhin ausführen. Und natürlich, während der Index kleiner ist als die Länge, Länge des Ausdrucks. Diese Bedingungen sind also erfüllt. Fahren Sie mit der Ausführung dieses Codes fort. Nun, vor allem, gehen, um es in diesem aktuellen speichern, dieses Zeichen gleich dem Ausdruck am Index. Nehmen wir also an, wir haben dieses Beispiel und vor allem werden wir Kante und Strom speichern. Jetzt werden wir überprüfen, ob dieser Regisseur mit einem der öffnenden oder schließenden Symbole übereinstimmt. das zu tun, lassen Sie mich einige öffnende, einige Strings erstellen, um sie draußen zu erstellen. Sie werden privat sein. Therapie. Diese Öffnung entspricht diesen Öffnungssymbolen. Und natürlich, private statische. String schließt b gleich schließt schließt Symbole. Nun, was wir tun werden, ist zu überprüfen, ob dieser Strom mit einem der öffnenden Symbole übereinstimmt. Wenn wir uns also richtig erinnern, haben wir die String-Klasse, den Methodenindex aus. Also lasst es uns hier benutzen. Also F nach oben den Namen, der Index aus. Also, was wir hier zu tun versuchen, ist zu überprüfen, ob die Strömung eine Öffnung ist. Wenn also dieser Index des aktuellen geöffnet wird, wenn der aktuelle also eines der Zeichen in der öffnenden Zeichenfolge ist, wird er den Index davon zurückgeben. Also zum Beispiel, wenn wir Strom ist gleich diesem Öffnungssymbol, es gibt 0, Disziplinierungssymbol eins, und das letzte öffnende Symbol, zu dem es zurückkehren würde. Andernfalls wird es minus eins zurückgeben, wenn es nicht gleich einem dieser Symbole ist. Also vermute ich. Das Symbol ist ungleich minus eins. Dann werden wir es einfach in den Status des Stacks schieben, der Push. Und wir werden diese Summe drängen, aber jetzt ist das nicht der Fall. Es könnte ein schließendes Symbol sein. Also, was wir tun werden, ist zu überprüfen, dass dieser Index abschließt. Dieser Strom ist auch nicht gleich minus eins. Wenn dieser Strom eines des schließenden Symbols ist, würde er einen anderen Wert als minus eins zurückgeben. Dies ist also der Fall und der Strom ist ein schließendes Symbol. Dann werden wir, dann werden wir es mit einem öffnenden aus dem Stapel vergleichen. Also werden wir ein Öffnungssymbol aus dem Stapel öffnen. Und wir können leicht die Symbole vergleichen oder neu zählen vergleichen Sie den Index. So haben wir zum Beispiel die geschweiften Klammern. Wenn wir dann den Index des Öffnens und Schließens vergleichen, wenn sie gleich sind, dann sind die Symbole gleich. Das ist also, was wir tun werden. Wenn also diesen Index des Stacks geöffnet wird , ist dieser Puck nicht gleich dem schließenden Index dieses aktuellen. Und das ist nicht der Fall, dann kehren wir einfach zurück ist gültig auf falsch. Jetzt haben wir hier einen Fehler, der besagt, dass der Methodenindex des Typs String-Klasse kein Objekt akzeptiert, da der Stapel, der Pop ein Objekt ist. Und wir wissen auch, dass wir nur in diesem Stack-Charakter speichern. Also kann ich sicher sagen, dass wir wissen, dass wir das brauchen, um ein Charakter zu sein. Und jetzt lassen Sie uns unbehandelte Ausnahme sehen, da wir hier eine Ausnahme haben könnten und diese Art von Push und Stack den Pop. Also, um auf der sicheren Seite zu sein, werden wir versuchen, zu fangen. Also werden wir das versuchen. Andernfalls, wenn Stack-Ausnahme aufgetreten ist, nur Gadget und false zurückgeben. Wir werden den Index inkrementieren, um den gesamten Ausdruck der Elemente in diesem Ausdruck zu durchlaufen . Und wir werden zurückkehren ist gültig. Es wird also true zurückgeben, wenn der Ausdruck gültig ist, andernfalls wird er false zurückgeben. Jetzt haben wir noch eine Modifikation und wir werden es im nächsten Video tun. Warum den Code ausführen, um Sie im nächsten zu sehen. 6. Matching 2: Lassen Sie uns sehen, was unser Code bis jetzt tun würde. Zum Beispiel, wenn wir diesen Ausdruck haben, wird es zunächst das erste Element erhalten und es mit einem der öffnenden Symbole vergleichen. Wenn dies nicht der Fall ist, wird es es mit den schließenden vergleichen. Und natürlich, wenn es mit keinem dieser Öffnungen und Schließen übereinstimmt, werden wir weitermachen, ohne etwas zu tun. Zweitens erhalten wir dieses Öffnungssymbol im Vergleich zu einem der Öffnungssymbole in der Saitenöffnung. Und natürlich passt es zu den geschweiften Klammern und wir werden es auf den Stapel schieben. Jetzt machen wir das Gleiche mit diesem D und einem Charakter. Wir werden nichts tun, seit den Öffnungs- oder Endsymbolen. Dann hätten wir dieses schließende Symbol und es wird mit einem der schließenden Symbole und der schließenden Dehnung übereinstimmen. Und wenn das der Fall ist, dann machen wir nichts. Das erste Element, das oberste Element im Stapel, das ist dieses Symbol. Und wir werden es mit dem abschließenden vergleichen. Wir werden die Analyse von ihnen vergleichen und sie sind gleich, dann werden wir nichts tun. Wenn sie es nicht sind, dann werden wir es, ich werde sagen, dass als gültig ist jetzt falsch. Wenn wir zum Beispiel dieses Symbol als den Stapel haben, werden wir die geschweiften Klammern nach unten und die Klammern nach oben haben. Und wir werden die Klammern mit den geschweiften Klammern und dem Ungleich vergleichen. So wird es falsch zurückgeben. Jetzt haben wir noch eine Modifikation zu machen. Angenommen, wir haben, sagen wir, wir haben dies, dieser Code würde korrekt laufen. Nehmen wir jedoch an, wir haben hier eckige Klammern. Jetzt, ich zitiere, werden alle diese Zeichen beginnen, all diese Symbole und den Hirsch. Und zuerst wird es diese Klammer knallen und sie mit diesen schließenden Klammern dort gleich vergleichen, dann wird es weitergehen. Und die andere, das ist diese geschweifte Klammern und vergleichen Sie es mit den geschweiften Klammern. Jetzt werden wir mit b enden und wir werden nichts tun. Und unser Code haben wir true zurückgegeben, da wir kein Problem mit dem Öffnen und Schließen haben . Wir haben jedoch immer noch diese eckigen Klammern und unseren Stapel. Also sollte es, wir sollten falsch zurückgeben, da. Nicht alle Symbole sind aufeinander abgestimmt. Also, was wir tun werden, ist, den Hirsch zu vergleichen, die f m ist leer. Also, wenn der Stack leer ist, wenn er nicht leer ist, dann ist gültig wird falsch sein. Da wir immer noch ein oder mehrere Elemente im Stapel haben. Und das sollte falsch zurückgeben, nicht wahr. Und natürlich werden wir zurückkehren ist gültig. Sehen wir uns nun die letzten Beispiele an. Zum Beispiel die 3.5. Dieser Code. Wir haben ein Schließsymbol. Und natürlich werden wir aus dem Stapel springen und einen öffnen. Jetzt ist der Stapel leer und wir haben kein Symbol darin. Dies wird also eine Ausnahme generieren und wir werden es hier fangen und zurückgegebene fällt direkt. Also das ist unser Code und lassen Sie es uns hier verwenden. Lassen Sie mich zunächst mit der Annahme eines Ausdrucks beginnen. Wir verwenden Scanner-Scan. Wenn neue Scanner, wie gewohnt. Der Ausdruck, der dem Scan entspricht. Die nächste Zeile. Wir werden diese Validierungsmethode verwenden. Also, wenn validieren, wenn es wahr ist, dann werden wir Ausdruck drucken gültig Marke Ausdruck. Und lassen Sie uns diesen Code ausführen. Mal sehen, dass es passieren wird. Zum Beispiel geben wir den Rückgabeausdruck ist gültig. Nehmen wir an, wir haben diese Symbole. Und natürlich sind sie gültig, da jeder Öffnung ein schließendes Symbol folgt. Und wenn wir nur eine Öffnung haben, die eingeladen wird, nur ein schließendes Symbol, natürlich wäre es ungültig. Und schließlich, wenn wir zum Beispiel die Werte haben, die Symbole. Auf diese Weise ist es nicht gültig, obwohl jede Öffnung ein Schließsymbol hat, aber sie sind nicht richtig sortiert. Es gab also einen ungültigen Wert zurück. Also das ist es für die Gruppensymbol-Matching. Und wir sehen uns im nächsten Video. 7. Secret: Jetzt haben wir bereits einen Stack in Java gebaut. Also lasst uns es benutzen und mit dem Problem arbeiten. Das ist eine geheime Botschaft. Die Idee ist also, dass wir eine geheime Nachricht erhalten , die eine umgekehrte Nachricht reserviert. Also zum Beispiel, anstatt hallo zu sagen, wird Eddie o sein. Also werden wir dies zu Hallo berauschend mit stecken konvertieren. Lassen Sie uns zunächst unsere Hauptmethode erstellen. Aber dies hat eine Hauptmethode und eine andere Methode, die diese Nachricht zu dekodieren ist. Aber Sie werden privat statisch sein. String, benennen Sie es, dekodieren und String-Nachricht. Lassen Sie uns unseren Stack hier erstellen. Also zuerst haben wir einen Stapel, und der Stapel wird ein Stapel von Zeichen sein. Und dieser Name ist gleich nu. Und natürlich brauchen wir eine Schnur. Und lassen Sie uns den StringBuilder verwenden. Dies ist also eine String-Klasse. Saite. Es ist eine Klasse in Java als Name bei SBI und B gleich U StringBuilder definiert. Also in diesem StringBuilder, werden wir unsere Charaktere und schließlich unsere Worte auf den Kopf stellen. Also lasst uns einen String-Tokenizer verwenden. So hat eine eindeutige Tokenizer-Klasse erlaubt, eine Zeichenfolge in Token zu brechen. Um den String-Tokenizer zu instanziieren, schreiben wir einfach String, den Koloniser. Und Sie können es in der Java finden, dass die Klasse SD heißt, instanziiert mit der Zeichenfolge, der Nachricht selbst, instanziiert wird. Jetzt, wo wir bereit sind, gehen wir weiter und wurden freigesprochen. Es heißt also, dass der Stern nicht auch dazu führen kann. So kann einfach Stapel von Java Tutor setzen. Und hier sollten wir zurückkehren, wir geben es später zurück. Also zuerst würde jedes Wort im Zeichenketten-Tokenizer lesen. Solange der strenge Organisator mehr Token hat, wird die Ausführung fortsetzen. Das erste, was wir tun werden, ist eine gerade externe Liste Emit-Wort zu erstellen. Und wenn dieses Wort Der Wert, der im Zeichenketten-Tokenizer ist, um es als G zu geben, das nächste Token. Nehmen wir an, wir haben diesen Ausdruck zuerst, wo er dieser sein würde. Und wir werden es lesen und jeden Charakter in den Stapel schieben. Also hier erstellen wir eine for-Schleife. Denn i ist gleich 0, bis i kleiner ist als oder ist diese Länge wird einfach dieses Zeichen in den Stapel schieben, so dass das Kind. Und wir haben einfach alle Zeichen im Stapel in diesem Wort zu diesem Schritt geschoben. Nachdem wir sie gedrückt haben, müssen wir sie mit der Pop-Methode extrahieren und sie in den StringBuilder pflanzen. Also, obwohl dies nicht leer ist, fügen wir einfach Zeichen an, die die Standard-Glühbirne verwenden. Und danach, nachdem wir von der Wildschleife fertig sind, fügen wir einfach dieses Leerzeichen an. Also mal sehen, was wir hier gemacht haben, und ein Beispiel. Also zum Beispiel, wie wir gesagt haben, wenn wir es haben, schreiben wir es. Zum Beispiel. Hallo, statt ein Tief zu haben, wird passieren. Das hier. Nun, zuerst werden wir dieses Komma speichern und dann O, L, L, E und F. Also wird unser Stapel aussehen und L, o. und, und lassen Sie uns das trennen. Also, hier haben wir, das ist unser Stapel. Wir haben 123456 Zeichen. Nachdem wir sie in Stapel sortiert haben, müssen wir sie mit dem Statutenbuch extrahieren. Beim Auftauchen wäre der erste Schritt dann E, dann L, L O. Also bekommen wir e l, l. Also, wenn wir diese Eingabe geben, das wird uns diese zurückgeben. Und das ist es, was wir brauchen. Das ist es, was wir tun werden. Wir müssen das Wort von O Allel Edge auf Hallo umkehren. Also gehen wir zurück. Und einfach nach dem Abholen aus der Wildschleife wir SB einfach für zwei zurück. Lassen Sie uns nun zu unserer Hauptmethode zurückkehren. Und bei dieser Methode müssen wir die Nachricht und die dekodierte Nachricht haben. Zunächst werden wir einen Scanner verwenden, um den Benutzer zu bitten, eine Nachricht einzugeben. Und wir bitten den Benutzer einfach, eine Nachricht einzugeben. Und wir werden es in der Nachricht speichern. Dann gehen wir in das decodierte mit der Methode dekodieren und verkauften es in der Dekodierungsnachricht. Um unsere Nachricht zu entschlüsseln. Dann drucken wir es aus. Nachricht dekodiert. Und drucken Sie die dekodierte Nachricht aus. Gehen wir voran und führen Sie diesen Code aus. Also hätten wir eine Nachricht eingegeben. Zum Beispiel, wie wir gesagt haben, hallo. Um diese Nachricht dekodiert zu bekommen, ist hallo, glücklich. So verwenden wir den in Java definierten Stand und wie man ihn benutzt, um alles von Nachricht zu Zahlen oder irgendetwas umzukehren. Wir möchten Sie im nächsten Video sehen. 8. Array Queue: Lassen Sie uns jetzt über Warteschlangen sprechen. Eine Warteschlange ist eine lineare Datenstruktur, die einer bestimmten Reihenfolge folgt , in der die Operationen ausgeführt werden. Der Geruch ist zuerst rein, zuerst raus. Ein gutes Beispiel für eine Warteschlange ist ein Restaurant. Die Person, die zuerst kommt, wird zuerst serviert. Der Unterschied zwischen Stacks und Warteschlangen besteht im Entfernen. Und stattdessen entfernen wir das zuletzt hinzugefügte Element, Und die Warteschlange, entfernen wir das Element der zuletzt hinzugefügten. Zum Beispiel haben wir hier zwei Positionen vorne und im Grunde haben wir zwei Hauptoperationen, enqueue und dequeue. Sie sind äquivalent zu schieben und in Stapel zu knallen. Also, wenn wir wollen Enqueue und q, das Element an Position. Und wenn wir die Warteschlange entfernen möchten, verwenden wir einfach die vordere Position und entfernen das Element von der ersten Position oder Sekunden, so weiter. So lassen Sie jetzt die Verwendung einer Warteschlange und eines Beispiels demonstrieren. Gehen wir zurück zu Eclipse. Schließen Sie diese Klassen von Aktien und erstellen Sie ein neues Paket. Und auf Sname basiert. F: In diesem Paket, wie wir es in diesem Beispiel getan haben, werden wir eine grundlegende q a q Schnittstelle erstellen . Natürlich werden wir eine Ausnahme schaffen. Ausnahme. Lassen Sie es uns umbenennen. Das sind also unsere drei Hauptklassen. Und fangen wir mit unserer Schnittstelle an. Wir werden die Methoden haben, wie wir es in diesem Beispiel getan haben. Wir haben ein blaues, aber die Größe boolean ist leer. Public void nimmt öffentliche Objekte, um ein Objekt zurückzugeben, und Sie verschieben es. Und wir nennen ein schwarzes Objekt, nennen es vorne. Um nur die Front zu sehen. Hier haben wir ein Energiekapital. Und wie wir es in den vorherigen Beispielen getan haben, müssen wir in diesem Beispiel unsere Ausnahme erstellen. Lassen Sie uns eine Konstruktornachricht erstellen, Codierung Nachricht und erweitert Ausnahme. Jetzt müssen wir nur diese Ausnahmen und diese Methoden Warteschlangenausnahme werfen. Und wir machen das Gleiche hier und hier. Also das ist es für Q und Q Ausnahme. Und das nächste Video, das wir verwenden, wird mit dem Array-basierten Goo arbeiten und unsere Methoden erstellen. 9. Array 2: Beginnen wir nun mit dem Array-basierten Cube. Wie Sie hier in diesem Beispiel sehen können, haben wir den Indexvordereintrag. Also zuerst müssen wir ein Array der Objektbenennung erstellen. Und natürlich werden wir eine Front und Größe erstellen. Lassen Sie uns jetzt voran und erstellen Sie unseren Konstruktor. So wie üblich, die Kapazität, weil wir mit einem Array arbeiten und wir müssen die geben, die Größe der Länge und erstellen Sie unser Objekt mit der Kapazität gleich der Größe, gleich 0, gleich 0 anfänglich. Fangen wir mit unserer Größe an. Natürlich werden wir implementieren und wir müssen es auf zwei Methoden autorisieren. Also hier haben wir alle Methoden und die Schnittstelle abgesehen von der Größe wird einfach die Größe zurückgeben, unabhängig davon, wie es die Größe ist, wie wir es einfach zurückgeben. Leer ist leer. Wir geben nur zurück, wenn die Größe gleich 0 ist. Also, wenn Wissenschaft gleich 0 ist, dann ist es leer. Andernfalls ist es nicht leer und es sollte true zurückgeben. Dieser Ausdruck ist ein boolescher Ausdruck und gibt true zurück, wenn die Größe gleich 0 ist, andernfalls wird er false zurückgeben. Jetzt fangen wir mit enqueue an. Zunächst müssen wir überprüfen, ob die Größe gleich array.length ist. Dann haben wir keinen Platz mehr in der Schräglage und wir müssen die Ausnahme werfen. Also müssen wir die Ausnahme werfen. Und sagen, dass Q S Fuß. Dies ist die erste Bedingung. Nun, wenn dies nicht der Fall ist, dann können wir das Element zur Schrägstellung hinzufügen. Um es hinzuzufügen, verwenden wir einfach das Jahr. Also fügen wir es auf der Rückseite hinzu. Und jetzt müssen wir den Lesevorgang erhöhen. Also, wenn wir einfach sagen können, dass v plus plus. Wenn wir jedoch zu einem Punkt kommen, an dem das hintere an Position sechs ist, und wir fügen hier ein Element hinzu, dann müssen wir die reale U2 an Position sieben inkrementieren. Wenn wir nun versuchen, ein weiteres Mal hinzuzufügen, wird uns das eine Ausnahme geben. Aber wenn Eines der vorderen Elemente hier gelöscht werden. Zum Beispiel, wenn wir das Q verwenden und wir einen entfernt haben, dann haben wir hier ein leeres Feld. Und wir haben es nicht benutzt, weil das nur um eins erhöht wird. Also müssen wir es lösen. Wir müssen dieses Problem lösen, indem wir sagen, dass, wenn diese Kugel gleich array.length ist, in diesem Fall gleich sieben ist. Dann müssen wir es ändern und ihm einen Wert von 0 geben, um hier p2 zurückzugeben. Also, um das zu tun, können wir einfach sagen, kann f Anweisung verwenden. Und wenn ich benötigte Länge ist gleich hinten, dann geben wir dem nur einen Wert von 0. Wir können jedoch einfach sagen, dass v gleich Bier plus eins ist. Wir erhöhen es und den Rest der Zeit. Also, was wir hier sagen, ist V gleich d plus eins. Jedes Mal, wenn real plus eins kleiner ist als diese IDed Länge, haben wir kein Problem. Alles wird korrekt funktionieren, da j plus ein Rest von array.length gleich ist. Da, zum Beispiel, wenn wir für Commander von fünf sagen, ist es 43 Rest von fünf. Ist es. Jedoch, wenn fünf, Rest von fünf ist 0, so dass, wenn wir drei plus eins gleich array.length hinten wird 05 Rest von fünf Sechsteln, Rest von sechs ist gleich 0. Das ist es also. Und wir werden nur die Größe erhöhen, da wir ein Element hinzugefügt haben. Gehen wir nun in die Warteschlange. Und dieses Beispiel hier. Zunächst müssen wir überprüfen, ob die Größe gleich 0 ist, oder wir können als leere Methode verwenden. Zum Beispiel, wenn es leer ist, würden Sie nur Warteschlangenausnahme sagen, dass in dieser Warteschlange leer ist. Und dann können wir arbeiten. Nun müssen wir zunächst ein Objekt erstellen, um zurückzukehren. Also, was wir zurückkehren werden, ist das Element vorne. Also kehren wir einfach zurück. Und jetzt müssen wir es aus der Warteschlange entfernen. Um das zu tun, verwenden wir einfach die gleiche Technik, die wir für das Jahr r1 plus einen Rest von bei einem neunten verwendet haben, werden wir in eine Dekrementgröße gehen, da wir ein Element entfernt haben und wir einfach zurückkehren, um dafür zurückzukehren, ist es für die Dequeue? Wir haben noch eine letzte Methode. Und diese Methode werden wir nur einen Blick auf, was, was wir an der Front haben. Also zuerst werden wir prüfen, ob es leer ist. Reihe. Lassen Sie mich das kopieren. Und im Grunde reißen. Und natürlich das zurückgegebene Array vorne. Wir müssen nichts entfernen. Wir werden uns nur umdrehen, um zurückzukehren. Das sind unsere Methoden. Und zurückgegeben haben immer noch eine neue Methode. Das ist eine ToString-Methode. Wir haben es nicht im Stapel verwendet, aber Sie können hier eine erstellen und die Warteschlange drucken, wann immer wir wollen. Also lassen Sie uns voran gehen und umgesetzt. Nun, wenn wir diese Methode öffentlich erstellen wollen, versuchen zu string, und wir können mit der for-Schleife arbeiten und durch alle Elemente im Array passieren. Ich bevorzuge es jedoch, es jedes Mal zu ändern, wenn wir die Warteschlange einlegen oder dequeue. Lassen Sie uns zunächst einen StringBuilder erstellen. Es ist wie eine Zeichenfolge, aber wir können es ändern. Sie können es hinzufügen, wann immer wir wollen oder daraus löschen. Also erstellen wir wieder eine Zeichenfolge unter diesem in der java.lang-Klasse definiert. Also StringBuilder sb, sb, und er wird es geben, wird diesen neuen StringBuilder instanziieren. Und wirklich gut, wir können es benutzen. Jedes Mal, wenn wir die Warteschlange einlegen, können wir den SP unterscheiden, der anhängt, was wir hinzugefügt haben plus Speicherplatz. Und jedes Mal, wenn wir die Warteschlange entfernen, können wir das Element q es von hier entfernen, um nur sba dot löschen von Position 0 auf die Länge des Objekts plus eins, um den Leerraum zu berücksichtigen. Also bis das Objekt, um diese Länge zurückzugeben. Um den ToString zurückzugeben, müssen wir ihn zunächst in eine Zeichenfolge konvertieren, die neun plus eins ist. Und so löschen wir aus dem StringBuilder. Und natürlich geben wir hier einfach sba dot zwei zurück. Und wir sind gut. Dies ist es also für die Array-basierte Warteschlangenklasse. Und im nächsten Video erstellen wir die Treiberklasse, in der wir diese Methoden testen werden. 10. Queue: Jetzt, da wir alle unsere Methoden haben, lassen Sie uns unsere Transferklasse erstellen. Das ist also ein Fahrer und besprechen Essen. Wir haben unsere Hauptmethode. Wir müssen die Warteschlangenausnahme kennen. Und lassen Sie uns die feindliche Basis erstellen, nämlich U gleich U Array-basierten Q mit der Kapazität von. Für. Lassen Sie uns nun einige Elemente in die Warteschlange stellen. So zum Beispiel, q Punkt q eins. Und lassen Sie es vier Mal 234 kopieren. Wenn wir nun verwenden, wenn wir Q oder Q ausdrucken, sind die beiden Strings gleich. Wir bekommen 1234. Nun zum Beispiel, lassen Sie uns dequeue. Wenn wir zum Beispiel sagen, drucken wir es aus, um zu sehen, was wir entfernen werden. Q Punkt dq. Es wird das vordere Element an Position Material entfernen. Also in diesem Fall bekommen wir eins. Also haben wir den Teich entfernt und wenn wir sie noch einmal ausdrucken, bekommen wir 234. Nun, wenn wir zum Beispiel ein Element hinzufügen , sagen wir, wir werden fünf hinzufügen. Also, was wir bekommen, wenn wir es jetzt ausdrucken , ist 2345. Das ist es also. Jetzt. Es sieht nicht so aus in der, da wir den StringBuilder verwenden. Diese fünf befindet sich jedoch an Position 0 Now im Array. Aber wir sehen, wir sehen es als 2345, da wir nur das Element an abgeleiteter Position hinzufügen und Sie es von der linken Position und dem StringBuilder verschieben. Lassen Sie uns nun zum Beispiel einige der anderen Methoden verwenden. Zum Beispiel, die Größe der freien, um q-dot Seiten zu verwenden. Hier bekommen wir drei, da wir nur drei Elemente haben. Also hier haben wir drei Elemente. Wenn wir es jedoch hier verwenden, drucken Sie die Größe u Punktgröße aus, wir erhalten vier, da wir ein weiteres Element hinzugefügt haben. Also hier können wir sehen, es ist klar vor allem, wir haben drei. Wenn wir es jedoch ausdrucken, nachdem wir das Element fünf hinzugefügt haben, erhalten wir vier. Jetzt versuchen wir Q, das leer ist. Lassen Sie es uns ausdrucken. Ist leer und wir werden falsch, da wir einige Elemente hier hinzugefügt haben. Es könnte es jedoch vor dem Einlegen damit aufteilen. Dann werden wir das wahr und dann falsch bekommen, da wir einige Elemente hinzugefügt haben. Dies ist ein kurzes Beispiel für Q. Und das nächste Video werden wir über Josephus-Problem sprechen und gelernt, wie man es löst. So sehen wir uns im nächsten Video. 11. Josephus-Problem: Lasst uns das Problem Josephs lösen. Lassen Sie es uns zuerst verstehen. Also für dieses Problem, wir werden Spieler und eine Nummer haben. Nehmen wir zum Beispiel an, wir haben drei Spieler, John, Alfred, und Trends. In diesem Fall nehmen wir an, wir haben die Zahl und die Zahl ist gleich zwei. Zum Beispiel. Zuerst müssen wir diese Namen speichern, NICU. Das Spiel endet, wenn eine Person übrig ist. Zum Beispiel, wenn wir sagen k gleich vier, Zunächst einmal, wir müssen dequeue. Wir dequeue von hier aus. Wir müssen John abstellen und hier hinzufügen. Dann. Dies ist ein Mal, dass wir es vier Mal durchführen. Also haben wir immer noch drei Mal. Also müssen wir Dequeue, Enqueue, Dequeue und AQ. Und so ist dies das letzte Mal. Also jetzt führen wir diese Operation für alle Zeiten durch. Und wir landeten bei Alfred auf der ersten Position. Also dequeue wir. Jetzt haben wir noch zwei Namen. So werden wir die gleiche Operation auch vier Mal durchführen. Also, DQ, Cress, und das Gleiche hier. Und schließlich, letztes Mal mit einem riesigen Stück und legen Sie es hier. So enden wir mit Kamm an der ersten Position. Also entfernen wir es mit der q-Methode und wir enden mit John switch. John ist der Gewinner. Das ist es also. Das ist also die Idee des Georgiens, dieses Problem, das wir lösen werden. Lassen Sie uns jetzt umgesetzt und ausgehend. Zunächst einmal lassen Sie uns unsere Methode erstellen und es benennen , so dass es einen Aufenthalt in einem Array von Strings erfordert. Und nennen wir sie Spieler und eine ganze Zahl k. nun, zunächst einmal, lassen Sie uns eine Zeichenfolge erstellen und eine basierte zwei q gleich nu auf einer Basisansicht mit der Kapazität der Spieler diese Länge hinzufügen eine basierte zwei q gleich . Also, wie viele Spieler wir haben, würde nur das Cue-Display geben. Nun, zuerst einmal, lasst es uns versuchen. Und wenn etwas passiert, werden wir einfach fangen, dass diese Ausnahme natürlich eine Warteschlangenausnahme ist, und einfach das Wild zurückgeben und den Gewinner identifizieren. Lassen Sie uns jetzt mit unserem Try Block arbeiten . Zuallererst müssen wir alle Spieler in den Würfel stellen. Also für alle, können wir sagen, dass für die for-Schleife, gibt es diese Länge und in der Warteschlange jedes Mal, aber wir können eine andere Form leisten MOOC verwenden, die wir nennen Spieler. Vier Spieler in verschiedenen Ebenen, würde nur in die Warteschlange dieser Ebene. Dies ist also eine andere Form der for-Schleife. Wir können es verwenden, wenn wir einen Fleck oder etwas haben, mit dem wir arbeiten können, als Variable und wir können in dieser Warteschlange mit dieser for-Schleife aufnehmen. Jetzt gehen wir zu unserer while-Schleife. Solange unsere Warteschlange mehr als ein Element hat, wird einfach daran arbeiten. y-Warteschlangengröße ist also größer als eins. Dieser Code würde ausgeführt werden. Lassen Sie uns zunächst die Warteschlange drucken, ohne sie zu ändern. So würde es nur Warteschlange drucken. Und so q. Jetzt verwenden wir die Telefonschleife von 0, del k. Wir werden einfach die q-dot enqueue, Q, die Q. Also, was wir hier tun, ist zuerst, wir werden zu dequeue, gehen, um ein Element aus der -Warteschlange und dann noch einmal mit der Enqueue gespeichert. So können wir sagen, dass wir Objekt brauchen. Zum Beispiel gleich Q Punkt dQ. Wir haben das Element einfach entfernt und dann gespeichert. Das ist also das Gleiche, aber Sie können dies einfach in den Parameter des q-dot in die Warteschlange eingehängt hinzufügen. Da Enqueue ein Objekt und dieses du akzeptiert, der dq ein Objekt zurück. Das ist also das Gleiche. Jetzt haben wir einfach nach der Arbeit mit in dieser for-Schleife in der Warteschlange und dequeuing für k mal. Jetzt haben wir einfach das letzte Element, den Vornamen des Spielers, entfernt. So können wir einfach Dequeue anzeigen und Sie verschieben es aus der Liste und sagen wir, es ist raus. Jetzt sind wir damit fertig. Nachdem wir diese while-Schleife durchgeführt haben, haben wir immer noch einen Spieler und er ist der Gewinner. Also, wenn r gleich Q dot dq und wir entfernen es aus der Liste, natürlich haben wir einen Fehler, weil dies ein Objekt ist und dieser Gewinner geändert wird. Also, und Sie wissen sicher, dass dieses Element eine Zeichenfolge ist. So können wir ihm Wert der Zeichenfolge geben. Jetzt, da wir mit unserem Code fertig sind, würde zuletzt zurückgegeben. Also sind wir einfach hier. Das ist es also für das Josephus-Problem. Lassen Sie uns unsere Hauptmethode erstellen und ausgeführt. Aber lassen Sie uns zunächst eine Reihe von Arrays erstellen, also, und eine Zeichenfolge von Namen. Lassen Sie uns es Schichten nennen. Und das, wir werden die Namen erstellen, zum Beispiel Chris und Fred und John. Das ist also unsere Zeichenfolge und eine Zeichenfolge und wir haben eine ganze Zahl k, die twill kommen, um den Benutzer zu bitten, einzugeben. Also werden wir den Scanner benutzen, um ihn zu scannen. Und fragen wir den Benutzer und Homosexuell und gespeichert, was auch immer der Benutzer eingegeben und die Variable k. Jetzt ist der Gewinner lösen Ebenen und K. Also, da dies eine Zeichenfolge zurückgibt, können wir sie in einer Zeichenfolge speichern und einfach ausdrucken. Gehen wir jetzt weiter und führen Sie diesen Code aus. Also, was wir bekommen, ist Eingabe k Zum Beispiel, lasst uns Folie. Also zuerst haben wir Chris, Alfred Chuang. Jetzt führen wir k4 mal durch. Also bewegten wir Chris und dann Alfred, und dann John und dann Chris, und wir enden mit Alfred an der ersten Stelle. Also stellen wir Alfred aus und Alfred ist draußen. Jetzt. Wir haben immer noch John und Chris. Also führen wir diese Operation viermal durch. John, Chris, John und Chris, und wir enden mit John an der ersten Position. Und John ist draußen. Also haben wir immer noch ein Element oder einen Spieler, und er ist der Gewinner. Also drucken Sie einfach aus, dass der Gewinner Chris ist. Das ist es also für das Josephus-Problem. Wir sehen uns im nächsten Video. 12. Eindeutig vernetzte Liste Teil 1: Wie Arrays ist die verknüpfte Liste eine lineare Datenstruktur. Die Elemente in dieser Liste sind jedoch mit Zeigern verknüpft. Wenn wir Arrays verwenden, haben wir einige Einschränkungen. Zum Beispiel ist die Größe der Arrays fest. Und wenn wir ein neues Element in das Array einfügen müssen, ist es teuer, weil wir Raum für dieses spezifische Element schaffen müssen. Dies ist also ein Beispiel für eine LinkedList. Nun, dies sind Knoten, also haben wir vier Knoten in diesem Beispiel. Und jeder Knoten ist Daten und Adresse. Wir haben also eine Box für Daten, in der wir unser Elementobjekt, Ganzzahl, String, Zeichen und so weiter speichern . Und wir haben eine andere Box, um die Adresse des nächsten Knotens zu speichern. So können wir uns diese Adresse eines Zeigers vorstellen. Wir brauchen hier nicht die genaue numerische Zahl zu kennen, aber es sollte auf die Adresse des nächsten Knotens verweisen. Die LinkedList ist also diese Liste. Und wenn wir sagen, einzeln, Dies bedeutet, dass die Knoten miteinander in einer Richtung verbunden sind. Wir können also nicht von 20 bis zehn zurückkehren, wir können nur von zehn bis 2030 gehen und so weiter. Das ist also die Idee einer einfach verknüpften Liste. Und gehen wir zu unserem Eclipse-Arbeitsbereich und erstellen ein neues Paket. Nennen Sie es einzeln verknüpfte Liste. Und dieses Paket, wie üblich. Lassen Sie uns zunächst unsere Exception-Klasse erstellen. Nun, da diese Liste unendlich ist, können wir hinzufügen, was wir wollen in dieser Liste und wir haben keine Grenze. Also lassen Sie uns diese Ausnahme als leere Listenausnahme nennen. Da wir uns keine Sorgen darüber machen müssen , ob wir die Elemente überschritten haben, haben wir keine Begrenzung. Und in dieser Ausnahme werden wir natürlich die Exception-Klasse erweitern. Erweitert Ausnahme wie zuvor, und erstellen Sie unsere Konstruktor leere Liste, die Nachricht genannt eine Suppe mit Parameternachricht. Das ist also unsere leere Listenausnahme. Lass uns weitermachen und eine andere Klasse erstellen. Jetzt. Mal sehen, zum Beispiel, lassen Sie uns zuerst erstellen, die Position und diese Schnittstelle wird nur eine Methode haben, um das Element zu erhalten. Nun müssen wir angeben, dass dies ein generischer Typ ist. Also, wenn wir d sagen, Nun, das ist ein generischer Datentyp. Und wir kamen mit dieser Klasse. Wir haben gesehen, wie man es benutzt, lassen Sie mich einfach eine andere Klasse erstellen, die Knoten ist. Also lassen Sie uns es einzeln verknüpften Listenknoten nennen, der mit S naught hört. Und wie wir es in der Position getan haben, die einfach bei D. Und natürlich gehen wir, um die Schnittstellenposition zu implementieren. Und, und die Methode debug get Element. Und einfach, lassen Sie uns einige Elemente Variablen außerhalb erstellen. Wir haben das Element d. Wir haben auch das S Naught selbst. Es sei denn, Name und Nächstes. Also müssen wir private Werte, Variablen außerhalb. Um das Element zu erhalten, wir einfach das Element zurück. Das ist also unsere Datenelementmethode. Jetzt möchten wir vielleicht auch den nächsten Knoten zurückgeben. Also sagen wir einfach Öffentlichkeit noch als nächstes geschneit. Und wir kehren als Nächstes zurück. Dann nächsten Knoten zwei wir haben. Nun möchten wir vielleicht auch den nächsten Knoten setzen. Lassen Sie uns zum Beispiel eine andere Methode erstellen, um sie zu setzen. Also öffentliche Leere, es ist Name es und es wird es entfernen, und es wird einen Knoten und Zahlung als nächstes nehmen. Jetzt stellen wir das so fest, dass es diesem entspricht. Also, was wir hier getan haben, ist, den nächsten Knoten zu setzen. Wir haben hier. Es ist als nächstes benannt und setzt es, was wir hier haben. Das ist also das Subnetz. Und wenn wir das Element setzen wollen, haben wir das Element d kann einfach ein anderes public void set Element erstellen. Und in diesem Fall erhalten wir ein Element, das Element und sagen dieses Punktelement zu Element. Wenn wir dies verwenden, sagen wir, dass wir die lokale Variable d von hier brauchen und sie auf was immer wir haben, den Parameter hier. Lassen Sie uns jetzt unsere nächste Schnittstelle erstellen. Diese Schnittstelle wäre, sagen wir, ich bin ein Teslas. Also ist diese S-Liste irgendwie Schnittstelle, absolut. Und hier haben wir alle unsere Methoden. Also die erste Methode, und natürlich ist es ein generischer Typ. Die erste Methode wie in der Regel wird es die Größe sein. Dann ist der öffentliche Boolean leer. Jetzt müssen wir noch, wir müssen es auch beantworten. Nun, wenn wir zu diesem Beispiel gehen. Das ist also unser Kopf und das ist unser Dale. Also möchten wir vielleicht einen Wert in der Hand speichern. Lassen Sie uns also eine Methode erstellen, die am Kopf gespeichert wird. Also öffentliche Leere, legen Sie am Kopf und was auch immer das Tier ist. Außerdem möchten wir es vielleicht am Schwanz verkaufen. Also antworte. Jetzt, da es unbegrenzt ist, müssen wir uns keine Sorgen über die leere Listenausnahme machen. Jede Ausnahme. Dieses Mal möchten wir vielleicht ein Element mit dem Entfernen von Pat entfernen. Und in diesem Fall müssen wir die leere Listenausnahme auslösen, da sie leer sein könnten. Und das gleiche wird auftreten, wenn wir vom Schwanz entfernt verwenden, eine Ausnahme auslöst. Also jetzt sind wir mit unserer S-Liste Position fertig und werden mit diesem im nächsten Video fortfahren. 13. Eindeutig vernetzte Liste Teil 2: Jetzt, da wir alle unsere Methoden haben, lass uns gehen und eine neue Klasse erstellen und sie aufschreiben. Diese Klasse wird also eine einzeln verknüpfte Listenklasse sein. Und in dieser Klasse werden wir zunächst die S-Liste ausdehnen oder implementieren, die wir zuvor erstellt haben. Aber natürlich könnte es vor allem generisch sein und implementieren. Wir können die 0 haben und wir müssen die Methoden erben. Jetzt haben wir alle Methoden und lassen Sie uns mit ihnen arbeiten. Also zuerst haben wir die Größe. Und davor lassen Sie uns einige Variablen außerhalb erstellen. Die erste Variable sind die Knoten. Wie gesagt, wir haben zwei Knoten, der Kopf, das wird das erste Element oder der erste Knoten sein. Dies ist also der Kopfknoten und der Schwanz ist am letzten Knoten. Also haben wir zwei Knoten wie nicht mit E. und wir haben auch Anzeichen wie gewohnt. Und lassen Sie uns den StringBuilder erstellen, um ihn für die toString-Methode zu verwenden. Jetzt haben wir auch die Konstruktor Republic einzeln verknüpfte Liste. Und hier lassen Sie uns Kopf und Schwanz instanziieren, um gleich zu sein. Also, wenn wir das erste Mal die einzeln verknüpfte Liste erstellen, haben wir den Kopf und t gleich keiner. Und die Größe wird gleich 0 sein. Und wir werden den StringBuilder erstellen. Jetzt haben wir auch hier. Also das ist es für Flüssigkeit, der Konstruktor. Fangen wir mit der Wissenschaft an. Zuallererst, für die Größe, wir einfach die Größe zurück. Denn das Leere ist leer, wir sind einfach wie gewohnt zurückgekehrt. Wenn die Größe gleich 0 ist. Gehen wir nun zu den anderen Methoden über. Sie sind viel komplizierter und wir müssen sie langsam bearbeiten. Die erste Methode ist also einfügen am Kopf. Also gehen wir zurück auf das Bild. Und hier können wir vier Knoten sehen. Angenommen, wir müssen hier einen Knoten hinzufügen. Angenommen, wir müssen ein Audit mit einem Element 0 hinzufügen. Das erste, was wir tun müssen, ist, den Knoten zu erstellen und ihn dann mit diesem Knoten zu verknüpfen. Danach müssen wir den Kopf bewegen, da sie hier waren. Jetzt müssen wir es hierher bringen. Also geben wir den Kopf. Die neue Position, bei der es sich um den neuen Knoten handelt. Also lasst uns hierher zurückgehen und umgesetzt. Das erste, was wir tun müssen, ist, diesen Knoten zu erstellen. Und lassen Sie uns nennen, dass es als Knoten wusste. Es wird gleich neuen Knoten, dieser Knoten mit e. und der nächste Knoten ist, wie üblich, haben wir diese, diese verknüpfte Liste. Wenn wir hier einen neuen Knoten erstellen, wird der nächste Knoten der Kopf sein. Jetzt haben wir es noch und mal sehen, was es ist. Also ja, wir müssen den Konstruktor erstellen. Und das Schneeschneit haben wir vergessen, zu schaffen. Gehen wir also zurück zu S naught und schaffen unseren Konstruktor, der öffentliches Wissen ist. Und ich diene als Element. Und es wird zwei Parameter nehmen, a0 und a1. Und Element wird gleich E sein, max wäre gleich. Und jetzt können wir zu unserer einzeln verknüpften Liste zurückkehren. Und wir, okay, jetzt danach, nachdem wir dies als Knoten erstellt haben, müssen wir überprüfen, ob die Liste leer ist. Liste ist leer oder wir können einfach sagen, F ist leer. Wenn dies der Fall ist, dann haben wir kein Element in diesem Knoten. Das erste Element, das wir hinzufügen werden, ist der Kopf und Schwanz. Also nochmal, sagen, dass DE gleich mu naught ist. In beiden Fällen, wenn es leer ist oder nicht, wird der Kopf gleich sein. Also dieses f führt nur diese Zeile aus. Und sie hatten in beiden Fällen würde gleich dieser neuen Asymptote sein. Danach müssen wir die Größe erhöhen, da wir ein neues Element hinzugefügt haben, und wir müssen es in den SPS StringBuilder einfügen, damit wir anhängen können. Aber wenn wir append verwenden, haben wir an das Ende angehängt. Wir müssen es jedoch am ersten als erstes Element hinzufügen. Also müssen wir einfügen verwenden, nun, müssen wir es an Position 0 einfügen? Und was müssen wir beantworten? Wir müssen diesen neuen Knoten und dieses neue Element einfügen, das E. ist das Leerzeichen hier. Und wir werden reden. Also das ist es für den Einsatz am Kopf. Jetzt gehen wir und arbeiten mit Einsatz am Schwanz. Also das erste, was wir überprüfen müssen, fügen Sie einen Schwanz ist auch, wenn er leer ist. Lassen Sie uns nun den neuen AST-Knoten erstellen. Als Knoten. Der neue Knoten als Knoten, der Wert von E. Und so ist der nächste Knoten, wie Sie in diesem Bild sehen können, null. Zum Beispiel, wenn Sie hier ein Element hinzufügen möchten, eine ODE. Also müssen wir von hier auf den neuen Knoten zeigen. Und jetzt wäre die Tabelle der letzte Knoten. Und dieser letzte Knoten wird nichts darauf hinweisen. Das wird es nicht sein. Also gehen wir zurück zu hier und arbeiten. Also hier haben wir an der es eingefügt. Zuerst müssen wir überprüfen, ob es leer ist. Wenn es leer ist, dann ist es auch die könnte diese neue beschneit. Und in beiden Fällen wird es dem Astronauten gleich sein. Andernfalls, wenn es nicht der Fall ist, wenn es nicht leer ist und wir bereits ein Element haben. Also dieses Element, das letzte Element, das hier Detail ist, werden wir auf diesen Knoten hinweisen. Also, wie machen wir es? Wenn es nicht leer ist, dann tail das nächste Mitglied saß, haben wir eine Methode erstellt, um max zu setzen und das Delta SetText wird der neue Knoten sein. Nun, der Schwanz wäre dieser neue Knoten. Wie gesagt. Wir erhöhen die Größe und angehängt am Ende des String-Builders oder mit entweder toString LAS-Spezifikation, wir haben immer noch von Hut entfernt, von Schwanz entfernt. Und Sie könnten hinzufügen, voran und bekommen Schwanz, um einen Blick auf, was wir an Kopf und Schwanz haben. Und natürlich unsere letzte Methode, diese toString-Methode. Also arbeiten wir an ihnen im nächsten Video. 14. Eindeutig vernetzte Liste Teil 3: Wir haben hier noch einige Methoden. Beginnen wir also mit der Methode vom Kopf entfernt. Lassen Sie uns dies zunächst löschen. Und das erste, was wir tun werden, ist zu überprüfen, ob die Liste leer ist. Also, wenn es leer ist, dann müssen wir die leere Listenausnahme auslösen. Geben Sie die Ausnahme ein und sagen Sie, dass die Liste leer ist. Wenn dies nicht der Fall ist, fahren wir fort, ohne diese Ausnahme zu werfen. Nun, das Element, das wir zurückgeben werden, dass es in einer Variablen zurückgeben aufgerufen wird, um zurückzukehren. Und es ist das Element, das am Kopf ist, das Element bekommen. Also, jetzt haben wir dieses Element und speichern es und zurückzukehren. Nun, wenn wir überprüfen müssen, ob der Kopf gleich Schwanz andere n ist, Mit anderen Worten, dass wir nur ein Element in dieser Liste haben, dann werden sowohl Kopf als auch Schwanz gleich null in diesem Fall sein. Also f ist gleich k, dann wird einfach sagen, dass AD gleich ist, ist gleich neun. Also verschieben wir dieses Element dorthin. Wir hatten nur ein Element und wir entfernen das. Also jetzt Kopf und Schwanz gleich null sein. Sonst. Wenn dies nicht der Fall ist, dann, da wir vom Kopf entfernt, wurde dieses Element entfernen. Nun, anstatt auf dieses Element zu zeigen, wird jetzt der Kopf dieser Knoten sein. Also müssen wir die Zeiger vom Kopf von hier nach hier entfernen. das zu tun, werden wir einfach sagen, dass Kopf gleich dem Kopf ist, dass als nächstes. Als Nächstes. Das ist es also. Und natürlich, da wir ein Element entfernen, müssen wir die Größe um eins verringern und aus StringBuilder löschen, wie Lead aus dem StringBuilder. Wir müssen mit 0 und beginnen, und mit allem, was wir hier haben. Und dieses Objekt, ist es, um die Stärke und die Länge davon plus einen Punktzähler Fuß Leerraum zurückzukehren . Wir werden löschen und schließlich zurückkehren. Jetzt wird dies abgeleitet, von kopflos entfernt. Fahren Sie fort, sie zieht von Taylor. Jetzt hier. Das Gleiche. Zuerst müssen wir überprüfen, ob es leer ist, leer ist, dann werfen wir eine Ausnahme, die diese Liste sagt. Und ansonsten machen wir weiter. Wir müssen die Rückkehr gleich dem speichern , was wir im Detail haben, seit dem Entfernen aus dem Schwanz, das Element erhalten. Jetzt müssen wir auch überprüfen, ob Kopf gleich k. mit anderen Worten, ist Kopf und Schwänze. Derselbe Knoten. Wir haben also nur ein Element. Dann. Der Kopf und der Schwanz sind gleich null und die Liste wird leer sein. Also, wenn Kopf gleich ist, sagen wir einfach, das musste gleich sein, um das zu nehmen. Ansonsten werde ich einfach damit arbeiten, seit wir von heute umziehen. Also gehen wir zurück zu unserem Bild hier. Und mal sehen, zum Beispiel, wenn wir diesen Knoten entfernen möchten. Also entfernen wir das. Jetzt müssen wir sagen, dass der Schwanz dieser Knoten ist. Und um das zu tun, denken Sie daran, dies ist eine einfach verknüpfte Liste. Wir können nicht von hier nach hier zurückkehren. Was wir also tun müssen, ist eine Schleife zu erstellen und durch alle Knoten zu gehen , bis wir zu diesem Knoten kommen. Also wollen wir nicht den letzten Knoten, wir brauchen den davor. Um das zu tun, gehen wir zurück zu Eclipse und implementieren diesen Code. Also zuerst müssen wir einen neuen Knoten erstellen, der nicht den Kopf und den Schwanz ist. Also hier haben wir den Kopf und hier haben wir detaillierte Mitte, um eine Atlas Grenze zu schaffen. Und es wird durch alle Knoten gehen, bis dieser Knoten erreicht wird. Also hier haben wir einen neuen Knoten, D. Lassen Sie uns eine Stadt an der ersten Stelle nennen, an der ersten Stelle. Es ist am Kopf. Während feucht dem Detail nicht gleich ist, wird dieser Code ausgeführt, so dass sie gleich sind, aber als nächstes. Also jedes Mal, wenn wir überprüfen, ob die nächste Note der Schwanz ist, wenn es nicht der Schwanz ist, dann gehen wir zum nächsten Knoten. Und das hier zu erreichen. Wir, wenn wir diesen erreichen, werden überprüfen, ob der nächste Knoten der Schwanz ist. Ja, dann gehen wir aus dieser while-Schleife. Jetzt haben wir unsere Position, unsere neue Position, die hier ist, und die Feuchte zeigt auf diesen Knoten. So können wir einfach sagen, dass sie gleich der Zeit wären. Und natürlich, da wir hier sind und wir diesen Araber nicht mehr wollen, geben wir einfach diesen Wert, einen Wert von null. So können wir einfach sagen, dass das neben einem Wert von null saß. Wir müssen nicht mehr auf einen Knoten nach dem Schwanz zeigen. Jetzt, da wir mit diesem Gold fertig sind, können wir einfach die Größe und Sweep dekrementieren, ein Element entfernen, und wir müssen es von hier aus dem StringBuilder löschen. Nun, lassen Sie uns sehen, wie wir löschen können. Zum Beispiel, wenn jetzt StringBuilder, wir haben 1234 und wir müssen aus dem Schwanz entfernen. Also, was wir tun werden, ist zu wissen, was die Länge davon ist und minus die Länge des endgültigen Wertes. Zum Beispiel ist es 12 mit dem Leerzeichen 34567. Also ist es sieben minus eins, das ist sechs. Also fangen wir an dieser Position an und beenden die Länge. Also, wie machen wir das? Wir rechts einfach sba dot Länge minus was auch immer wir in diesem Element haben , um die Zeichenfolge, die neunte minus1 zurückzugeben. Und wir enden mit SBY, dieser Länge. Jetzt haben wir von StringBuilder gelöscht und werden es einfach zurückgeben. Also das ist es für die von Dale entfernt. Und lasst uns gehen und mit der anderen Botschaft fortfahren. Wir schicken, kriegen Kopf und kriegen Schwanz. Und natürlich die letzte Methode, die eine Zeichenfolge ist. Also fangen wir mit dem Get an. Und wir erzwingen einfach, wir werden die leere Listenausnahme werfen. Wenn es leer ist. Wir werden diese Ausnahme auswerfen. Und diese Ausnahme, dass die Liste leer ist. Nun, sonst ist es nicht der Fall. Dann geben wir einfach den Kopf zurück, der Element bekommt. Lassen Sie uns diesen Code kopieren und erhalten Schwanz erstellen. Also statt Kopf oder Schwanz zu bekommen und zu überprüfen, ob es leer ist, sonst haben wir einen Schwanz, der Element bekommen. Nun ist die letzte Methode öffentliche Zeichenfolge zu String. Und da wir den StringBuilder verwenden, kann einfach zurückkehren, es, gibt Sb an Stärke zurück. Das sind also unsere Methoden und jetzt sind wir alle bereit. Wir können sie in einer Rhetorik Klasse im nächsten Video verwenden. 15. Einfache Linked: Jetzt, da wir alle unsere Methoden haben, gehen wir voran und verwenden sie in unserer Fahrerklasse. Das ist also unsere Fahrerklasse. Und diese Klasse ist wie üblich die Hauptmethode. Lassen Sie uns die einzeln verknüpfte Liste von Ganzzahlen erstellen. Und das gleiche es einzeln verlinkt Liste SLL. Sie denken, LinkedList. Und vor allem, lassen Sie uns die Größe davon drucken. Also als Punktgröße, lassen Sie uns voran und führen Sie diesen Code aus. CO2 zählen, um passieren zu können. Die Größe ist 0. Nun lassen Sie uns einige Elemente hinzufügen. Also sagte ich, dass Einsatz am Kopf eins, SLL, dass Einsatz bei SLL Punkt Einsatz bei unterstützen hatte drei. Lassen Sie uns die Singlingliste hier ausdrucken. Und wir werden jetzt 12 haben. Und danach haben wir am Kopf das Element drei eingefügt. Das ist also der Kopf, also haben wir 312. Wenn wir nun zum Beispiel bei Tate einfügen, fügen Sie Datum Nummer eins ein und drucken Sie es dann noch einmal aus. Wir kriegen 3121. Lasst uns hier nachsehen. Wenn es leer ist, ist leer, und lassen Sie es noch einmal überprüfen. Ist leer. Führen Sie diesen Code aus, wir werden zuerst wahr und dann nach dem Hinzufügen einiger Elemente werden wir falsch. Jetzt haben wir immer noch einige Methoden. Zum Beispiel, lassen Sie uns vom Kopf entfernen. So können wir einfach speichern, dass SLL Punkt aus dem Kopf entfernen. Drucken Sie SLL aus. Wir haben hier. Dieser Fehler ist also nicht behandelte Ausnahme, wir müssen diese Ausnahme auslösen, weiß Empty Exception. Jetzt gehen wir weiter und führen Sie diesen Code aus. Ich habe keine Erde mehr. Und wir bekommen Eins-zu-Eins-Gefühl, entfernen Sie dieses Element vom Kopf. Lasst uns das Gleiche machen. So wie LL vom Schwanz entfernen und ein letztes Mal ausdrucken. Wir werden eine zu bekommen, nachdem das letzte Element entfernt wurde. Und in all unseren Beispielen haben wir Integer verwendet. Wir können jedoch jeden Typ auswählen, den Sie wünschen. Zum Beispiel, die Zeichenfolge double, irgendetwas. Und es wird auf die gleiche Weise funktionieren. Das ist es also für dieses Video. Wir sehen uns den nächsten. 16. SLL basierter Stack: Nun, eine Sache, die wir tun können, ist, einen Schritt zu erstellen. Also hier haben wir die Klassen, das ist ein 100 Raum für diesen Tag. Lassen Sie uns also unsere Stack-Schnittstelle erstellen. Nennen Sie es. Und der Stapel wäre generisch. Typ: Geht wie gewohnt. Der Boolesche Wert ist leer. Und der Schub. Was wir das Element B schieben werden , auch diese Beule. Und natürlich müssen wir die Exception-Klasse erstellen, aber dieses Tag, also Stack-Ausnahme. Und wie üblich erweitern Ausnahme mit dem Konstruktor. Aber diese Nachricht, aber diese Nachricht und wir sind mit dieser Ausnahme fertig, würde es mit Bob und Top verwenden, so weiß, dass Ausnahme. Und hier weiß auch Ausnahme. Aber der Unterschied zwischen der Verwendung von einzeln verknüpften Listen und bei a besteht darin, dass wir, wenn wir drücken müssen , kein Limit haben, da die einzeln verknüpfte Liste nicht begrenzt ist. Wenn wir jedoch Array verwendet haben, denken Sie daran, dass wir hier auch eine Ausnahme werfen da wir möglicherweise die Grenze des Tages überschreiten. Also das ist es für die StatPlus. Lassen Sie uns nun voran und erstellen Sie unseren einzeln verknüpften Listen-Stack. Dies ist also eine einzeln verknüpfte Liste basiert. Und diese einzeln verknüpfte Liste, die wir haben. Also die Methoden, die wir in der Schnittstelle erstellt haben. So werden wir einfach die Stack-Schnittstelle implementieren. Und oben rechts, alle Methoden. Lassen Sie uns sie einfach von E überschreiben , indem Sie implementierte Methoden und die Methoden hinzufügen. Nun, das erste, was wir tun werden, ist, die einzeln verknüpfte Liste außerhalb des Konstruktors zu erstellen , private einzeln verknüpfte Liste von D. Nun lassen Sie uns einen Konstruktor erstellen, eine öffentliche einzeln verknüpfte Liste, die darauf basiert. Und in diesem, in diesem Konstruktor wird einfach. Geben Sie einen Sattel definiert Sie neue Sache, die verknüpfte Liste. Und natürlich, hier haben wir so. Also das ist es und das ist sie getrennt. Das ist also unser Konstruktor. Jetzt gehen wir zur Wissenschaft über. Während der Verwendung der Größe. Wir können einfach die einzeln verknüpfte Liste zurückgeben mit ist leer. Wir können auch die IsEmpty Methode zur Verfügung und die SLR verwenden. Also werden wir einfach ALLES zurückgeben, das leer ist. Was wir hier tun, ist, dass wir als verknüpfte Liste erstellt haben. Und verlinkte Liste. Wir haben alle Methoden. Wir haben Kopf eingefügt, einfügen, entfernen, bekommen, und natürlich Größe und leer, so können wir sie einfach verwenden. Und unser einzeln verknüpfter listenbasierter Stack, weil Größe und Empty gleich sind. Jetzt, wenn wir in Bush gehen, werde ich vorwärts treiben. Also verwenden wir den Push from head oder insert at head und die einzelne LinkedList-Klasse. Um das zu tun, sagen wir einfach SLL, aber legen Sie an, was wir hier haben. Und das ist im Grunde jetzt. Lassen Sie uns zunächst einen Try and Catch-Block verwenden. Also versuchen Sie, wenn etwas passiert ist, fangen Sie es einfach. Und das sollte die leere Liste sein. Wenn es leer ist. Wenn die Liste leer ist, dann werden wir die neue Ausnahme auslösen, die wir erstellt haben, was die Stack-Ausnahme ist. In diesem erstellen wir eine neue Ausnahme, die besagt, dass der Stapel leer ist. Nun, das ist der Haken. Gehen wir zurück, um hier etwas Code zu schreiben. Das erste, was wir tun werden, ist, das Objekt zu erstellen. Und wir müssen auch vom Hut entfernen. Also in diesem Stapel, wie wir bereits gesagt haben, fügen wir den ersten und letzten hinzu. Und wir können sagen, dass N zuerst raus ist. Also müssen wir voran drängen. Und das ist die gleiche Zeit, wenn wir pumpen wollen, müssen wir aus dem Kopf springen. Also SLL Punkt, entfernen Sie vom Hut. Jetzt, nachdem wir dies entfernt haben, kehren wir einfach zurück. Und wir sind fertig mit Pub. Lassen Sie uns einfach gehen, um Methode zu verbinden, die oben ist. So wie wir es taten und versuchen zu fangen, fangen Sie die leere Listenausnahme ab. Wenn wir eine Activist-Ausnahme haben, werfen wir eine neue Stack-Ausnahme. Und wir werden sagen, dass der Stapel leer ist. Nun, wenn dies nicht der Fall ist, dann sind wir nur ein Objekt, um die get-Methode von SLL zurückzugeben und zu verwenden, aber Hilfe erhalten und dieses Objekt zurückgeben. Das ist es also für die Top-Methode. Und jetzt sind wir mit allen vorausstehenden Methoden fertig und erstellen eine Klasse, um sie zu verwenden. Wir werden es SLL-basierten Stack nennen. Also in dieser Klasse haben wir wie üblich unsere Hauptmethode und das ist SLL-basierte dunkle Ganzzahlerstellt SLL-basierte dunkle Ganzzahl und Slim es SLL b gleich neuer Stack-Integer. Das erste, was wir tun werden, ist, einen Schub zu schaffen, ein Element zu schieben, das eins ist, das Bush und das Bush-Regime. Gehen wir voran und drucken Sie die Größe, Größe und diesen Code. Sieh mal, was wir bekommen. Also haben wir drei. Jetzt haben wir vergessen, die toString-Methode zu erstellen. Wir können es einfach nach dieser Methode erstellen. Und diese Methode wird einfach der SLM sein. Gut. Jetzt gehen wir zurück und führen diesen Code noch einmal aus. Wir kriegen drei. Jetzt, wenn wir voran gehen und drucken SLM b wird drei zu eins bekommen, da wir in den Stapel schieben. Also zuerst haben wir eins geschoben, dann drücken wir zwei, dann drücken wir drei. Also setzen sie in D. Nun, wenn wir daraus pumpen, bekommen wir SLL B, dass wir die Nummer drei hier sagen, dass unbehandelte Ausnahme, wir müssen diese Ausnahme hier werfen, wirft die Ausnahme und Führen Sie diesen Code wird drei erhalten. Nun, wenn wir es noch einmal ausdrucken, kommen wir zu einem. Lassen Sie uns überprüfen, ob es leer ist. Das ist leer, es sollte false zurückgeben, da wir zwei Elemente haben. Und schließlich, lassen Sie uns die Gesäßmethode verwenden. So SLL v Punkt. Und wir sollten die Nummer 222 ist die erste Position bekommen. Dies ist es für den einzeln verknüpften listenbasierten Stack. Jetzt haben wir Stack mit drei Methoden implementiert. Die erste ist die Verwendung von Array, und die zweite war die Verwendung des eingebauten Java-Stacks. Und schließlich verwenden wir einzeln verknüpfte Liste, um Stack zu implementieren. Das ist es also für dieses Video. Wir sehen uns den nächsten. 17. Doppelt vernetzte Liste Teil 1: Gehen wir zur doppelt verknüpften Liste. Und doppelt verknüpfte Liste ist eine verknüpfte Datenstruktur, die aus einem Satz Link Schakale genannt Knoten besteht. Jeder Knoten enthält drei Felder, um Felder mit dem vorherigen und dem nächsten Knoten zu verknüpfen. Und natürlich ein Datenfeld. So enthält dieser Knoten beispielsweise ein Datenfeld zum Speichern von Daten. Und zum Beispiel, wir haben Variable namens b und zwei Knoten, zwei Felder, um auf den vorherigen Knoten und auf den nächsten Knoten zu zeigen. Und natürlich haben wir im ersten Feld, im ersten Knoten, keine, und im letzten Feld, den letzten Knoten und auch nicht. Und hier haben wir den Kopf, der auf den ersten Knoten zeigt und den Händler auf den letzten Knoten zeigt. Also lassen Sie uns voran und implementieren dieses Programm hier. Lassen Sie uns also ein neues Paket erstellen und es doppelt linkedList nennen. Und in diesem Paket beginnen wir mit der Erstellung unserer Positionsschnittstelle. Wie bei einer einzigen verlinkten Liste. Wir haben unsere Schnittstellenposition. Und in dieser Position wird es generischer, generischer Typ sein. Wir haben nur eine Methode, erhalten Element. Das ist also unsere Positionsklasse. Lassen Sie uns eine andere Klasse erstellen. Ich würde bemerken, dass Klasse D heißt, da es eine doppelt verknüpfte Liste ist, der Knoten. Und in dieser Klasse lassen Sie mich einfach, ja, okay, also hier werden wir die Positionsschnittstelle implementieren. Also durch einfaches Schreiben implementiert Position. Und natürlich müssen Sie diese Methode nicht außer Kraft setzen. Element abrufen. Lassen Sie uns also eine Variable außerhalb dieses Namens des Elements erstellen. Knoten. Wir brauchen hier zwei Knoten, da wir mit vorherigen und nächsten arbeiten. Also lassen Sie uns sie nennen, bezeichnen das vorherige. Und als Nächstes. Nun, in dieser Methode, was wir das Element zurückgeben werden, wir einfach das Element hier zurück. In diesem Fall. Lassen Sie uns nun einige andere Methoden erstellen. Zum Beispiel müssen wir den vorherigen Knoten erhalten. So wird es öffentlich vergessen und auch vom Typ d nichts sein. Und das vorherige. In diesem Fall geben Sie einfach den Radius zurück, erhalten Sie den nächsten. Also in diesem Fall, der Knoten zum nächsten Knoten, und wir kehren einfach als nächstes zurück. Nun möchten wir vielleicht den vorherigen und den nächsten Knoten einrichten. Lassen Sie uns also eine Methode erstellen, um sie einzurichten. Es wird also vom Typ void sein, da wir gerade diese Knoten einrichten. Also setzen Sie vorher. Und wir müssen ihm seinen Namen geben, seinen vorherigen. Und setzen Sie einfach diese dritte vorherige lokale lokale Variable vorherigen IE auf den Schrittzähler zu devaluieren, der vom Benutzer für das Programm eingegeben wurde. So wird es gleich dem vorherigen sein. Und wir müssen eine andere Methode, Methoden, Methode erstellen , um als nächstes zu setzen. Wie wir in den beiden vorangegangenen, wäre dieser Punkt als nächstes gleich sein. Also jetzt sind wir fertig mit der Einstellung und dem Erreichen und Nächsten. Jetzt haben wir immer noch nur eine Methode, um das Element zu setzen. So wird es ein leeres Element und Element sein. Und dieses Element gleich Elementen. Und jetzt sind wir fertig mit dieser Klasse. Lassen Sie uns voran und erstellen Sie eine Exception-Klasse. Wie üblich haben wir zunächst die leere Listenausnahme. Also würde ich Liste vielleicht leer sein. Lassen Sie uns also eine Ausnahme erstellen. Aber diese leere Listenausnahme. Und es wird nur die Ausnahme beim Erstellen des Konstruktors und der Listenausnahmemeldung und dieser Nachricht erweitern . Dies ist also die erste Ausnahme. Lassen Sie uns nun einige andere Ausnahmen erstellen und wir werden später darüber sprechen. Also haben wir auch eine ungültige Positionsausnahme. Und es wird dasselbe sein. Es erweitert die Ausnahme. Und so ist die letzte Ausnahme, die wir erstellen werden, die Grenzverletzungsausnahme. Diese Ausnahme wird es uns leichter machen zu erkennen und wir werden diese doppelt verknüpfte Listendatenstruktur setzen. So Grenzverletzung Ausnahme. Und natürlich sollte ich die Exception-Klasse erweitern. Der Konstruktor. Der Konstruktor. Jetzt, mit diesen Ausnahmeklassen getan. Und wir können mit unserer doppelt verknüpften Liste weiterarbeiten. Wie bei einer einzelnen verknüpften Liste haben wir eine Schnittstelle erstellt, um es S-Liste zu benennen. Also hier werden wir die D-Liste erstellen, da es eine doppelt verknüpfte Liste ist. Also werden wir diese D-Liste erstellen, und dann werden wir alle Methoden von dieser Schnittstelle in unsere WMA-Listenklasse überschreiben . Also machen wir das im nächsten Video. 18. Doppelt vernetzte Liste Teil 2: Bevor wir nun unsere Delist-Klasse erstellen, lassen Sie uns diese Ausnahmen verstehen. Also zuerst haben wir die leere Listenausnahme. Und diese Klasse in dieser Ausnahme, wer wird überprüfen, ob die Liste leer ist? Also werden wir diese Ausnahme nur auslösen, wenn die Liste leer sein könnte. Die andere Ausnahme, die invertierte Positionsausnahme. Also zum Beispiel, wenn der Benutzer einen Knoten eingibt, ist er nicht in der Liste, dann werden wir diese ungültige Position Ausnahme auslösen sagen, dass der Knoten nicht Teil der Liste ist oder wir nicht und identifizieren die verschneiten. Und schließlich die Ausnahme der Grenzverletzung. Wenn wir also die Liste durchlaufen, zum Beispiel, wenn wir eine nächste Methode verwenden, werden wir durch den Knoten gehen und am Ende mit dem letzten Knoten. Und wir haben noch ein Mal benutzt, das nächste. Dann werden wir diese Grenzverletzungsausnahme auslösen, da wir keinen Knoten nach dem letzten haben. Das sind also unsere drei Ausnahmen, Brille. Und lassen Sie uns voran und erstellen Sie die Klasse bezeichnen. Also in diesem Fall, das ist die Denote, die Liste, tut mir leid. Und diese Klasse wird T. Und das schafft eine Methode. Zunächst einmal haben wir, wie üblich, Boolean ist leer, ist leer. Und wir haben die Methode, um das erste Element, den ersten Knoten zu erhalten. So wird es vom Typ T sein und es wird zuerst sein. Also hier könnte die Liste leer sein. Was wir also tun werden, ist die leere Listenausnahme zu werfen. Jetzt können wir auch eine Methode erstellen, um den letzten Knoten in der Liste zu erhalten. Und natürlich könnte es auch leer sein. Also werfen wir das noch einmal bis zur Nachfolge. Lassen Sie mich sehen, was hier vor sich geht. Der Methodenkörper, es tut mir leid, versteckt. Wir müssen die Schnittstelle und Schnittstelle mathematische Klasse erstellen. Und hat das abgesagt. Lassen Sie uns die Methode als nächstes erstellen, um den nächsten Knoten zu erhalten. Also hier haben wir d nichts e, um die nächste zu bekommen. Nennen wir es als Nächstes. Und es wird einen Bezeichner akzeptieren. Nennen wir es d. Und nachdem wir Ihn angenommen haben, diesen Knoten akzeptiert haben, haben wir hier zwei Probleme. Zunächst einmal ist dieser Knoten möglicherweise nicht einer der Knoten in der Liste. Also, was wir es werfen werden. Die ungültige Positionsausnahme. Da diese Position, die wir hier eingegeben haben, in diesem Fall ungültig sein könnte , werden wir diese Ausnahme auslösen. Jetzt. Wir können auch auf eine Grenzverletzungsausnahme stoßen, da wir versuchen werden, auf den nächsten Knoten zuzugreifen. Angenommen, dieser Knoten ist der letzte, so dass wir nicht auf den nächsten Knoten zugreifen können. Um das zu beheben, zeichnen wir einfach die Grenzverletzungsausnahme. Jetzt haben wir auch die vorherige. Also haben wir die gleiche DNA. Das Ende wirft, ungültige und begrenzte Variantenausnahme. Danach haben wir zwei Methoden zu entfernen und zu ersetzen. Also zuerst, lassen Sie uns den Zug erstellen. Also werden wir ein Element entfernen. Also ist es div. Lassen Sie uns es nennen, Sie sind umgezogen, und so werden wir es aus dem Knoten entfernen. Lassen Sie uns einen Deem nennen und ihn entfernen. Vielleicht ist dieser Knoten nicht einer der Knoten in der Liste. Was wir also werfen werden, ist die ungültige Positionsausnahme. Und wir werden dasselbe werfen, wenn wir zum Beispiel ersetzen wollen. Beachten Sie, dass hier möglicherweise nicht auch einer der Knoten in der Liste ist. Also werden wir als nächstes in die violette Position werfen. Jetzt gehen wir zum Einfügen. Wir können zuerst einfügen, schließlich einfügen und vor einem Knoten einfügen, und nach einfügen. Also gehen wir zurück zu unserem Bild hier. Zum Beispiel können wir hier zwischen a und b einfügen. So können wir entweder einfügen vor b oder einfügen nach a verwenden. Und Sie können auch zuerst antworten und zuletzt einfügen. Also lassen Sie uns zurückgehen und diese Methoden erstellen. Lassen Sie uns zunächst den Knoten erstellen und zuerst einfügen. Und wir werden akzeptieren und Element d. Dann das gleiche in der Klasse, fügen Sie letzte E, und nennen wir es E. Dann haben wir vor einem Knoten einfügen und nach einem Knoten einfügen. Fügen Sie nun den Knoten ein. Und lassen Sie es uns nennen, fügen Sie vorher ein. Jetzt werden wir sie akzeptieren. Also werden wir wissen, welchen Knoten vor eingefügt werden soll. Und wir werden es hier akzeptieren. Lassen Sie uns ein d nennen und natürlich, das Tier, das in Bezug auf einfügen. Dies ist also das Element d. Nun bezeichnen, dass uns gegeben wird, könnte und gültig sein. Also natürlich wirst du die unverletzliche Positionsausnahme werfen. Das gleiche mit dem Einfügen an einem bestimmten Knoten, fügen Sie nach dem sname es D, D, E und E wird die ungültige Positionsausnahme noch einmal werfen. Also das ist es für die Klasse. Diese alle unsere Methoden für jetzt. Und im nächsten Video werden wir sie in der doppelt verknüpften Listenklasse implementieren. 19. Doppelt vernetzte Liste Teil 3: Also haben wir jetzt auf Methode in der Schnittstelle D-Liste. Lassen Sie uns gehen und erstellen Sie die doppelt LinkedList-Klasse. So doppelt verknüpfte Liste. Und in dieser Klasse werden wir diese Schnittstelle implementieren. Und natürlich werden wir alle Methoden überschreiben , damit ich dies verwenden und nicht implementierte Methoden hinzufügen kann. Also werden wir alle Methoden hier haben. Zunächst einmal lassen Sie uns unsere konstruierten und einige Variablen außerhalb erstellen. So wie üblich, haben wir die Größe und wir haben zwei Knoten. Nun, das D, nennen wir sie Header und Trailer. Jetzt können wir unseren Konstruktor erstellen. Und in diesem Konstruktor gehen, um unseren Header und Misserfolg und Selbstmord einzurichten. So Größe. Dann haben wir Header und Taylor. Also gehen wir zurück zu diesem Bild. Dies ist unser Header, und das sind unsere Daten. Zuallererst haben wir keinen Knoten in diesem doppelt verknüpften Listen-Join , der den Header und den Trader erstellt, der Header sollte auf den Trailer hinweisen und der Schneider sollte auf den Header hinweisen. Also hier können wir sagen, dass diese Box auf den Schneider und den Fehler hinweist, sollte die erste Box auf den Kopf hinweisen. Also gehen wir zurück und sehen, wie wir das umsetzen können. Zuallererst wird unser Header gleich dem neuen Knoten E, Knoten sein. E-Knoten. Und vor allem, wir haben, wie gesagt, in der Positionsklasse, lassen Sie mich sehen, wo unsere bezeichnen. Wir haben Element vorherigen und nächsten, aber vergessen, unsere konstruierten zu erstellen. Das ist also erschaffen. Und in diesem Fall wird der Konstruktor von drei Parametern sein. Es wird d Knoten, Knoten D. Nennen wir es vorherigen Seifen und das Element e. Und schließlich das d Naught, das ist der nächste Knoten. Und natürlich, lasst uns sie hier setzen. So wird das Element gleich a sein, vorherige wäre gleich b. Und schließlich, als nächstes. Und natürlich hat er das identifiziert. Jetzt können wir zu unserer Notiz zurückkehren, und hier müssen wir das vorherige nächste und Element erstellen. Also zuallererst, da wir keine vorherigen haben. Als nächstes setzen wir sie auf Null. Und danach werden wir unseren Trailer erstellen. Nun, Ich werde taylor, Wie gesagt, es sollte auf die Kopfzeile hinweisen. Also keine, keine. Und wir haben auch gesagt, dass der Header sollte auch darauf hinweisen, Schneider. Hier beim Erstellen des Headers hatten wir jedoch keine zugeschnittenen. Stattdessen werden wir hier darauf hinweisen. Header, der als nächstes saß. Und wir werden neben den Trailer setzen. Jetzt sind wir mit dieser Methode und dem Konstruktor fertig, meine ich, und wir können mit unserer Methode arbeiten. Also zuerst haben wir die Größe wird einfach die Größe zurückgeben. Dann haben wir die SMT und wie üblich bestimmt Größe gleich 0. Jetzt können wir mit unseren komplizierteren Methoden arbeiten. Also zuerst haben wir die erste Methode und wie gesagt, wenn wir einen Knoten extrahieren, könnte er auflisten, möglicherweise leer sein. Um also auf der sicheren Seite zu sein, werfen wir diese leere Listenausnahme aus. Jetzt lassen Sie uns diese Methode erstellen. Also hier haben wir, wir wollen nicht die erste Bezeichnung extrahieren. Also zuerst werden wir überprüfen, ob es leer ist, so dass die Liste leer ist, dann werfen wir eine neue leere Ausnahme. Und in diesem Fall werden wir sagen, dass die Liste leer ist. Nun, das ist nicht der Fall. Dann geben wir einfach den ersten Modus zurück. Wie greifen wir auf verteilten Knoten zu? Gehen wir zurück zur Anstecknadel. Und wir können sehen, dass, wenn wir einige Knoten in der Liste haben, der erste, der Header wird auf den ersten Knoten hinweisen. Und der Händler, der an diesem letzten Knoten darauf hinweisen wird. Also die Achse, der erste Knoten, wir einfach, lassen Sie uns zurückgehen. Und in Eclipse geben wir einfach alles zurück, was wir im Header haben, der neben dem nächsten Knoten zum Header kommt, ist der erste Knoten in der Liste. Und das Gleiche hier. Zunächst einmal werden wir überprüfen, also lassen Sie mich das kopieren und hier einfügen. Wenn dies nicht der Fall ist, dann werden wir einfach Jailer zurückgeben, der den vorherigen Knoten erhält. Also, nachdem wir das vorherige bekommen haben, gehen wir zurück zu diesem Bild und überprüfen. Also hier haben wir unseren Trailer. Der letzte Knoten in der Liste ist der Knoten davor später. Was auch immer der Taylor darauf hinweist, ist der letzte Knoten in dieser Liste. Jetzt gehen wir zurück und wir werden später in den nächsten Videos mit den anderen Methoden arbeiten. 20. Doppelt vernetzte Liste Teil 4: Gehen wir nun weiter zum nächsten, vorherigen und entfernen, ersetzen und so weiter. Also hier in der nächsten Methode, die eine ungültige Positionsausnahme und die Grenzverletzungsausnahme auslösen könnte . Also lassen Sie uns sehen, was eine ungültige Positionsausnahme ist für uns. Zum Beispiel, wenn der eingegebene Knoten keine ist, ist Ereignis a keine gültige Position. O, natürlich, wenn wir den Knoten Header oder Trailer eingeben, gibt es auch keine gültige Position. Und schließlich, wenn dieser Knoten auf einen nächsten oder vorherigen Knoten zeigt, wie wir hier sehen können, sollten alle Knoten in dieser Liste auf den nächsten und den vorherigen Knoten hinweisen. Nur der Header und der Trailer dürfen nur auf einen Knoten hinweisen. Der Header weist also darauf hin, dass der erste und der Taylor am letzten. Und hier können wir keine haben. Und das Gleiche hier. Jetzt gehen wir zurück. Lassen Sie uns also eine andere Methode erstellen, die für uns die ungültigen Positionen überprüft , mit denen wir arbeiten können. Es wird also vor dieser nächsten Methode erstellt. Das wäre privat, da wir es nur in dieser Klasse verwenden. Also nennen wir es private Leere. Und es wird nur die Position und die Position dieses Nichts überprüfen. Und natürlich sollte es durch die ungültige Positionsausnahme. Zunächst einmal werden wir überprüfen, ob D keine ist. Dann werfen wir die neue ungültige Position. Ungültige Positionsausnahme. Lassen Sie Position Ausnahme. Und natürlich, lassen Sie uns geheilt schreiben, dass null keine gültige Position ist. Und lassen Sie mich das kopieren und zwei Mal einfügen. Und wenn D gleich Header ist, dann werden wir auch die ungültige Positionsausnahme werfen, aber sagen, dass Header keine gültige Position ist. Und auch der Anhänger der den Gefängniswärter wirft, ist keine gültige Position. Also das letzte, was wir überprüfen werden, ist, ob dieser Knoten D Punkt Punkt als nächstes gleich null ist. Oder das vorherige ist auch gleich null, dann ist dies nicht Teil der Liste. Also werden wir Ihnen eine ungültige Position werfen. Ausnahme, dass Knoten nicht Teil eines Deals ist. Jetzt sind wir mit dieser Methode fertig. Wir können es in unseren Methoden hier verwenden. Also zuerst, bevor wir etwas tun, müssen wir die Position überprüfen. Also ruft es diese Methode auf. Also, wenn etwas passiert ist, als ob eine ungültige Positionsausnahme von gut es einfach mit dieser chap-Position werfen würde. Also wird es reingehen, um es zu überprüfen. Und wenn nichts passiert, dann können Sie wie gewohnt arbeiten. Und lassen Sie mich sehen, was das Problem ist, das wir zurückgeben müssen. Natürlich werden wir es am Ende zurückgeben. Also zuerst, da wir den nächsten Knoten bekommen, werden wir zuerst überprüfen, ob der nächste später ist. Wenn die nächste Tür ein Schwanz ist, dann können wir den nächsten Knoten bekommen. Sends Taylor ist nicht Teil der Liste. Also werden wir die neue Grenzverletzungsausnahme auslösen und sagen, dass sich nicht als letzte Note bewegen kann. Also, wenn diese Bedingung erfüllt ist, dann sind wir am letzten Knoten und wir können danach nicht zugreifen. Das ist nicht der Fall. Dann geben wir einfach die nächste zurück. Jetzt werden wir dasselbe mit dem Vorherigen machen. Aber wir werden überprüfen, ob der vorherige Knoten der Header ist. Und dieser Fall können wir nicht darauf zugreifen, da er nicht Teil der Liste ist. Also zuerst müssen wir die Position überprüfen. Wenn alles in Ordnung ist, können wir weitermachen. Wenn vorherige ist gleich in diesem Fall, die Grenzverletzung Ausnahme, dass wir es schreiben, eine Zeilenumgrenzungsverletzung Ausnahme besagt , dass der erste Knoten nicht verschieben kann. Und hier ist das nicht der Fall. Geben Sie einfach die vorherigen Studien, die nächsten und vorherigen Methoden zurück. Lassen Sie uns mit unserer Methode entfernen fortfahren. Gehen wir zurück. Und nehmen wir an, wir müssen diesen Knoten entfernen. In diesem Fall. Zuallererst müssen wir diese Zeiger von hier und hier schneiden und neue Zeiger erstellen. Also wird ein auf See zeigen. Und C wird auf a zeigen, also lassen Sie uns dies in unserem Code implementieren. Um zu entfernen, erstellen wir einfach. Zuallererst müssen wir die Position des Knotens überprüfen. Wenn alles richtig funktioniert, können wir fortfahren. Also müssen wir zurückkehren. Lassen Sie uns eine Objektrückgabe erstellen. Und in diesem Fall wird es das Punkt-Punkt-Punkt-Element sein. Bevor wir diese Felder in nicht setzen, müssen wir diese beiden Felder in a und C so einstellen, dass sie aufeinander zeigen. Also, wie greifen wir auf ein? Wir können einfach schreiben, dass Knoten d Punkt vorher bekommen. Also, wenn wir sagen, nicht vorher bekommen, wir bekommen eine und wir müssen eine setzen, um auf See zeigen. Also, wie machst du das? Wir können einfach d schreiben, die vorherige bekommt. Nun, mit get previous, haben wir eine was wir tun werden, ist, dieses Feld so einzustellen, dass es auf See hinweist. Also saß das als Nächstes. Wir gehen als Nächstes. Und wie greifen wir auf c durch a, das Sprichwort, dass B, die als nächstes kommen. Also was ist, was sollten wir hier schreiben, ist Geschwindigkeit oder DDL GetMax, es tut mir leid. Nicht als Nächstes. Also lassen Sie es mich wiederholen. Zuallererst haben wir eine mit DDL zugegriffen erhalten vorherige nach dem Zugriff auf die vorherige. Hier. Nachdem wir versehentlich dies a gesagt haben, setzen wir dieses Feld einfach so ein, dass es auf den Knoten nach B zeigt, und wir greifen darauf zu, dass mit B entweder als nächstes kommt. Jetzt müssen wir noch dieses Feld so einstellen, dass es auf a zeigt. Also, wie machen wir es mit einfach Zugriff auf das nächste Element, den nächsten Knoten. Und wir sollten das vorherige auf das vorherige setzen. Also, was wir hier getan haben, ist, dass wir auf das nächste Element zugreifen, den nächsten Knoten. Also, indem wir den Punkt Get Next benutzen, haben wir C. Und was wir sollten, was wir sollten, was wir hier am vorherigen speichern sollten. Also werden wir vorher setzen, um auf ein und was ist ein? A ist d, D würde vorher bekommen. Nun, nachdem wir dies getan haben, können wir einfach neben D gleich null und die vorherige gleich null setzen, und einfach die Größe dekrementieren und den Namen abschrecken, um zurückzukehren. So entfernen wir den Knoten aus der Liste. Das ist ein bisschen kompliziert, wenn es um Einstellung und Anreise geht. Aber wenn wir Schritt für Schritt daran arbeiten, wird es einfach sein. Also werden wir im nächsten Video mit ersetzen fortfahren. 21. Doppelt vernetzte Liste Teil 5: Lassen Sie uns nun mit der Ersetzungsmethode fortfahren. Zunächst müssen wir überprüfen, ob dieser Knoten gültig ist. Also werden wir die Chat-Position verwenden. Die Position ist gültig. Dann kannst du fortfahren. Zuallererst müssen wir ein Objekt erstellen, ein Element zurückgeben, um zurückzukehren, und alles zurückgeben, was wir bei D haben , dann werden wir das Element an den beiden gleich e setzen und hier haben wir etwas in der Ersetzung -Methode. Also lasst uns wieder zu unserem Abscheuen gehen und es reparieren. Wenn wir ersetzen müssen, Wir müssen einen Knoten und ein Element eingeben. Gehen wir zurück und reparieren es. Jetzt können wir dieses Element hier hinzufügen und zurückgeben, was auch immer wir das Objekt zurückgeben müssen. Beginnen wir nun mit der Einfügemethode. Zuallererst haben wir den Einsatz zuerst. Lassen Sie mich also den Knoten erstellen. Wir haben das Element hier im Parameter. Also alles, was wir tun müssen, ist, ignorierte zu erstellen und lassen Sie es in Ihrer Bezeichnung nennen. In diesem Fall wäre der gleich der Anode und der Note. Und es wird drei Parameter nehmen. Jetzt lass mich zu diesem Bild zurückkehren. Nehmen wir an, Sie müssen hier einen neuen Knoten erstellen. Dieser neue Knoten sollte auf diesen Knoten a hinweisen, und a sollte auch auf diesen Knoten hinweisen, den ich erstellen muss. Und natürlich sollte Header auf den neu hinzugefügten Knoten hinweisen. Anstatt darauf zu hinweisen, ein Nichts. Also lassen Sie mich hier zurück. Zunächst einmal, wenn wir diesen Knoten erstellen müssen, sollte er auf den Header hinweisen. Dann das Element e, dann darauf hinweisen, was wir ein get hatten. Als Nächstes. Nachdem wir diesen Knoten erhalten haben, müssen wir die Pfeile reparieren. Jetzt. Wir haben den Pfeil, der von hier in die Kopfzeile zeigt. Also lassen Sie mich das beheben, indem Sie einfach head.next eingeben. Jetzt habe ich hier auf den ersten Knoten zugegriffen, was ein ist Und was muss ich tun, ist, vorherigen so zu setzen, dass er gleich dem neuen Knoten ist. Also, indem Sie einfach sagen, gesetzt vorherige. Und in diesem Fall, entweder das oder wir können einfach sagen, dass neue V nichts. Jetzt müssen wir auch den Header den nächsten setzen. Anstatt also auf das a hinzuweisen, sollte es auf den neuen Knoten hinweisen. Also, wie saß das neben und saß neben dem neuen bezeichnen. Schließlich müssen wir die Größe erhöhen. Und natürlich geben Sie diese neue Bezeichnung zurück. Dies ist es für den Einsatz zuerst. Lassen Sie uns mit dem letzten Einsatz fortfahren. Sobald Sie verstehen, die Idee ist die gleiche für die letzte, vor und nach. Also zuerst müssen wir den Knoten erstellen, der neue bezeichnen gleich zu bezeichnen. Und hier, wenn wir es an der letzten Position beantworten wollen, müssen wir unseren Knoten einrichten, der auf d von einer Aktion und auf der Taylor aus der anderen Richtung zeigt . So können wir einfach auf den Knoten zugreifen, indem Sie einfach auf den Trailer-Punkt bekommen vorherigen Element e. Und jetzt lassen Sie uns die Pfeile ändern. Zuallererst das vorherige. Also in diesem Fall ist es dieser Knoten D. Und wenn wir brauchen, wenn wir darauf zugreifen, können wir einfach das nächste so einstellen, dass es gleich dem neuen Bezeichnen ist. Dann müssen wir das vorherige des Taylor setzen, anstatt auf d hingewiesen zu werden, sollte es auf den neuen Knoten hinweisen. So bezeichnen die vorherige neue. Und schließlich, erhöhen Sie die Größe bestimmt diese neue bezeichnen. Lassen Sie uns nun mit dem Einfügen vor fortfahren. Hier akzeptieren wir Unbekannte. Also sollten wir die Position dieses Wissens überprüfen. Und dann können wir arbeiten. Lassen Sie mich zu diesem Beispiel zurückkehren. Angenommen, wir müssen es, lassen Sie mich die nehmen. Und nehmen wir an, wir müssen Knoten einfügen. Hier ist unser neuer Knoten. Und wir müssen es zwischen B und C einrichten. Also hier sollte C auf diesen Bereich hinweisen, und natürlich sollte dieser Bereich auch auf See hinweisen. Und das gleiche mit B. Also, wenn wir diesen neuen Knoten erstellen, so ist dies das neue d Naught. Lassen Sie mich es hier schreiben. Mu. Und mit einigen neuen bezeichnen und minimieren Sie die Front. Also hier haben wir unsere neue Bezeichnung, und dieser Knoten ist der Knoten d. Also hier bekommen wir den Knoten D Und wir müssen den neuen Knoten vor diesem D einfügen Also nehmen wir an, dieser Knoten ist C0 und wir müssen vorher einfügen. Also zuerst müssen wir die Pfeile ändern und den neuen Knoten erstellen. Also lassen Sie mich auf Erstellen klicken und neu bezeichnen D. D, sorry. New denote wird gleich neuer V naught sein. Und vor allem sollte es auf die B und C hinweisen, also von der ersten Position, sollte es darauf hinweisen, dass d Punkt vorher bekommen. Dann das Element e, Und dann sollte es auf D zeigen. Nun, lasst uns die Pfeile hier modifizieren. Dieser Knoten sollte auf dieses Feld hinweisen. Also, um auf diesen Knoten zuzugreifen, können wir einfach sagen, dass e Punkt vorher bekommen. Nachdem wir das vorherige erhalten haben, sollten wir nächste und vorherige setzen, um gleich dem neuen zu sein, bezeichnen. Das sollte. Wir sollten die vorherige von D setzen, um gleich neu bezeichnen auch. Schließlich erhöhen Sie die Größe und drehen Sie diese neue bezeichnen D. Nun lassen Sie uns das Gleiche mit dem Einsatz nach. Also, hier, diese Position nach, dass erstellen Sie die neue Bezeichnung, der neue Knoten gleich zu bezeichnen. Und lassen Sie uns zu diesem Beispiel zurückkehren. Angenommen, wir müssen diese Liste ändern, indem wir einen neuen Knoten zwischen B und C hinzufügen. Aber wir verwenden die Einfügung nach, sorry, ändern sie mit dem Einfügen nach B und das ist, was wir tun sollten, ist, sobald wir die neue angeben, sollte es auf diesen Knoten und dann auf den nächsten Punkt hinweisen. Es sollte also darauf hinweisen, dass das Element e und d ist, aber als nächstes erhalten. Also lassen Sie uns jetzt den nächsten dieses Knotens setzen , der in diesem Fall ist. Und wir können darauf zugreifen, indem wir sagen, d dot get next. Jetzt haben wir auf den zweiten Knoten zugegriffen und wir müssen festlegen, um gleich zu neuen bezeichnen. Dann bezeichnen die neue, erhöhen Sie die Größe und geben Sie einen neuen Knoten zurück. Also das ist es für Einfügen vor und Einfügen nach. Wir sehen uns im nächsten Video. 22. Doppelt vernetzte Liste Teil 6: Wir haben immer noch die toString-Methode, aber es wird sehr kompliziert sein, da wir vor und einfügen nach, Show und wir müssen einen StringBuilder Mitte erstellen, um das Einfügen vor einem Element und nach einem Tier zu berücksichtigen . Also, um ein wenig kompliziert zu sein, also lassen Sie uns unsere Stammesklasse erstellen und in diesem Klassennamen bei DLL-Demo arbeiten. Und er wie üblich, unsere Hauptmethode. Lassen Sie uns unsere doppelt verknüpfte Liste erstellen, geben Sie Integer ein und benennen DLL doppelt verknüpfte Listen. Und hier lassen Sie uns einige Werte hinzufügen. Also lassen Sie uns zuerst und Wert eins einfügen. Letztes einfügen. Lassen Sie uns nach dem ersten Knoten einfügen. Legen Sie nach was nicht. Es ist der Erste. Also DLL Gott zuerst. Und wir müssen es vorwärts speichern. Punkteinlage nach, vor. Also wollen wir vor dem letzten speichern. Und jetzt haben wir einige Fehler. Mal sehen. Wir haben unbehandelte Ausnahmen, um die Exception-Klasse zu werfen. Und jetzt lassen Sie uns ausdrucken, zum Beispiel, entfernen Sie ein Element. Also, um es zu entfernen, das ist Druck. Wir entfernen, entfernen das Element, eine DLL, die vor dem letzten Element. Also das vorherige des letzten Elements. Und in diesem Fall lassen Sie uns drucken. Wir werden zwei entfernt. Nun, wie wir hier sehen können, haben wir zuerst eins eingegeben, als wir fünf eingegeben haben. Dann nach der ersten Position, nach dem ersten Knoten, für den wir eingegeben haben. Also hier haben wir vier und dann müssen wir. Wenn wir also das Element vor dem letzten entfernen müssen, werden wir dieses entfernen, und wir haben immer noch 145. Also lassen Sie uns Größe DLL drucken, aber Größe, wir bekommen jetzt drei. Wie Sie sehen können, Größe, wenn drei, ist es leer, ist es nicht. Der DLLS-Punkt ist leer. Du bekommst Falten. Nun, wenn wir die Elemente in dieser Liste drucken möchten. So können wir eine for-Schleife erstellen, die mit i gleich 0 beginnt, gleich DLL-Punktgröße. Aber seit DLL kann sich diese Größe beim Entfernen ändern, Hinzufügen. Lassen Sie uns also mit einer Variablen außerhalb der mittleren Größe beginnen, die der Größe entspricht. Und in diesem Fall wird die Grenze die Größe sein. Lassen Sie uns nun einen Bezeichner außerhalb erstellen. Bezeichnen Sie also D gleich a, um gleich DLL zu sein. Aber zuerst, und wir drucken das Element aus. Und davor ist es auf der gleichen Linie. Und dann jedes Mal, wenn wir diese Schleife betreten, müssen wir das B gleich den nächsten zwei ändern, b gleich d, das nächste. Nun, während dieses Codes ausgeführt wird, könnte etwas passieren. Also lasst es uns in einen Try and Catch-Block setzen. Und wenn eine Ausnahme jeglicher Art, werfen Sie es einfach aus dieser for-Schleife heraus. Jetzt gehen wir weiter und rennen. Dieser Code wird 1425 erhalten. Also lassen Sie mich hier ein Element entfernen. Zum Beispiel. Wie wir es vorher getan haben. Die LL entfernen gelben Punkt vorherigen. Noch. Also lasst uns voran gehen und diesen Code ausführen und sehen, was mit dem Umzug nach passieren wird, und wir werden mit dieser Liste 145 enden. Nun können wir diese Methode auch in der doppelt verknüpften Liste verwenden und eine ToString-Methode erstellen. Aber ich fand es einfacher, wenn wir es in der Hauptklasse verwenden, da wir die Liste gleichzeitig mit dem Drucken erstellen. Das ist es also für die doppelt verknüpfte Liste. Es ist viel komplizierter als die einzeln verknüpfte Liste, aber es ist mächtiger in Bezug auf das Einfügen und Entfernen von wann immer wir wollen. 23. Insertion: Betrachten Sie, dass Sie eine Liste von Ganzzahlen wie diese Liste haben. Und Sie möchten, dass sie vom niedrigsten zum höchsten sortiert werden. Hey, du kannst Salzen benutzen. Und es gibt tatsächlich mehrere Sortieralgorithmen und wir werden über einige von ihnen sprechen. Also innen durch Einfügen Sortierung. Einfüge-Sortierung ist ein einfacher Sortieralgorithmus, der ähnlich der Art arbeitet , wie Sie Spielkarten in Ihren Händen gesehen haben. Das Array ist praktisch in einen sortierten und unsortierten Teil aufgeteilt. Werte aus dem unsortierten Teil werden ausgewählt und an der aktuellen Position im sortierten Teil platziert. Und hier können wir mit diesem Beispiel beginnen. Nehmen wir an, wir haben diese Liste, und diese Liste wird in zwei Teile unterteilt, einen sortierten und unsortierten Teil. Zunächst einmal wird unser sortierter Teil nur das erste Element sein. Das ist also unsere erste Liste, und das ist der zweite Teil. Jetzt ist vier bereits sortiert, da es nur ein Element ist, es gibt nur ein Element in dieser Liste. Und du musst gar nichts tun. Es gibt kein Element auf der linken Seite, das größer als vier ist, dann müssen wir drei hinzufügen. Also haben wir 43. Wir vergleichen drei mit vier. Also vier ist größer als drei. Also sollten wir sie tauschen und wir kriegen 34. Nun, der sortierte Teil der Liste ist 34 und der unsortierte Teil ist, was es hier gibt. Und wir gehen zum nächsten Element über. Wir müssen zwei zu vergleichen 44 ist größer als zwei, dann tauschen wir sie aus. Und das gleiche, was wir vergleichen zwei mit 33 ist größer als zwei auch. Also tauschen Sie sie noch einmal aus, wir bekommen 234. Und jetzt ist dies der sortierte Teil und das ist der unsortierte Teil, und so weiter, bis das letzte Element der Liste erreicht wird. Und dann sind wir fertig. Die allgemeine Idee besteht also darin, jedes Element mit allen Elementen auf der linken Seite zu vergleichen. Tauschen. Jedes Mal, wenn wir ein Element auf der linken Seite finden, das größer ist als das Element, das wir verwenden. Also lasst uns voran gehen und den Code schreiben. Du gehst und erstellst eine Klasse. Und zuerst, lassen Sie uns unser ganzzahliges Array erstellen, unsere Liste von ganzen Zahlen. Und zum Beispiel haben wir fünf Elemente in diesem Array. Lassen Sie mich sie direkt bei 5110 speichern. Also das ist unser Array, und lassen Sie uns unsere Methode erstellen . Aber nennen wir es Einfügung. Und um Parameter ein Array zu nehmen, lassen Sie uns es bei der Arbeit hier nennen. Also zuerst haben wir die for-Schleife, um alle Elemente von 0 bis zur aufgelisteten Länge minus1 zu durchlaufen. 0 ist bereits sortiert, so dass wir nicht mit 0 beginnen müssen. Also fangen wir mit einem an. Also unsere for-Schleife Ergebnis mit einem und endet eine Punktlänge minus eins. Jetzt erstellen wir eine ganze Zahl. Lassen Sie uns ID Schlüssel nennen, und es wird unser Element in dieser Liste sein. Also werden wir eine von i vergleichen. Also hier ist es drei zu 1012 und so weiter. Und wir verkauften es und eine ganze Zahl namens Spiel. Und wir haben eine andere Ganzzahl wird j sein, i minus eins bis i minus eins und gehen zurück, bis 0 erreicht wird. Und was wir hier tun, ist, dass wir diese Nummer starten, zum Beispiel, dass der Staat Fall ist. Die dritte Zeile, der dritte Schlüssel in einer Ganzzahl. Und wir dachten, diese Zahl auf eine ganze Zahl namens Schlüssel. Und dann haben wir die Position gespeichert, die wir erholen, um zu beginnen, was die Position i minus eins ist, j i minus eins. Also gehen wir auf die Seite mit dieser Position und gehen zurück, bis wir 0 erreichen. Also werden wir eine while-Schleife erstellen. Während j größer als 0 ist und der Schlüssel kleiner als a von J ist, müssen wir tauschen. Also zu sagen, hier ist, dass, während j weniger ist, größer als 0 ist. Also hier ist j in diesem Fall gleich eins. So gut. Und die zweite Bedingung, während Schlüssel, die zwei ist, ist kleiner als ein von J, in diesem Fall vier. Also müssen wir sie tauschen. Wir tauschen. Und dann noch einmal überprüfen wir die Bedingungen. Wir haben j größer als oder gleich 0. In diesem Fall ist j gleich 0. Diese Bedingung ist also gültig. Und zwei in diesem Fall haben wir hier zwei und hier vier, also 23, also drei ist größer als zwei. Dann gilt dies auch. Wir müssen noch einmal tauschen. Und dann beenden wir mit dieser for-Schleife, da j größer als 0 sein wird. Und in diesem Fall, also jedes Mal, wenn wir diese for-Schleife ausführen, wird j durch eins dekrementiert. Und hier müssen wir dies austauschen, eine ganze Zahl namens tamp erstellen. Und wie üblich, dass Swap sie nehmen a von j und Speicher hier, und zehn und a von j. A von j plus eins in diesem Fall. Und schließlich nehmen wir ein j plus eins und geben ihm den Wert von w also hier tauschen wir sie aus. Und jetzt sagten wir: Gehen wir zurück und drucken uns aus. Lassen Sie uns zunächst das Array so drucken, wie es vor dem Sortieren ist. So drucken Sie auf einem und etwas Platz. Dann führen Sie diese Methode mit a und dann wird das noch einmal gedruckt. Für lassen Sie uns das Licht aus dem Code und der Zeit drucken und wird zuerst das ungesalzene hinzugefügt und dann erhalten wir das sortierte, da wir die Einfügemethode verwendet haben, die wir hier erstellt haben. Jetzt können wir sehen, wie sich das jedes Mal verändert hat. Lassen Sie uns also das Array ausdrucken , um nach jeder Änderung in breit eine andere for-Schleife zu erstellen, nachdem die Schleife ausgeführt wurde. Und drucken Sie ein J2 aus, in diesem Fall etwas Platz. Und dann, und hier müssen wir eine Insel drucken. Bevor Sie diese Schleife ausführen und ausführen, wird der Code dies erhalten. Also zuerst haben wir 32510. Wir beginnen mit i gleich eins. Also ich gleich onRestart, t gleich a von i, j ist gleich a von 12, und j ist gleich 0 in diesem Fall, was i minus1 0 ist. Dann haben wir eine while-Schleife, die nur einmal ausgeführt wird , da J gleich 0 ist und dann empfohlen gelesen wird. Also die Bedingung hier, es wird nicht für eine andere Ausführung gültig sein. Daher müssen wir sie tauschen, da die beiden Bedingungen erfüllt sind. Dasselbe mit fünf. Wir vergleichen fünf mit jetzt. Fünf mit 25 ist größer als zwei, dann ist diese Bedingung nicht erfüllt. Wird die for-Schleife nicht mit einfach obwohl eingeben und I um eins inkrementieren. Jetzt haben wir die Nummer eins. Das Gleiche hier. Wir werden dieses mit jedem Element vergleichen und die beiden Zahlen austauschen. So werden zum Beispiel 15 sie austauschen. Und dann 13 tauschten wir sie noch einmal aus. Und schließlich tauschen 12 sie aus. Und schließlich haben wir 1010 ist größer als alle anderen Elemente. So wird es nicht in die Schleife, die while-Schleife, und wir werden mit den beiden Schleifen fertig sein, die innere und äußere Schleife. Und wir können drucken, drucken und sagen, dass Sie auf das neue Array schauen. Also das ist es für die Einfüge-Sortierung. nächsten Videos werden wir weitere Sortieralgorithmen untersuchen. 24. Selection: Lassen Sie uns jetzt zu einem anderen Sortieralgorithmus gehen, ist die Auswahl. Der Selektionssortieralgorithmus sortiert ein Array, indem wiederholt das minimale Element aus dem unsortierten Teil gefunden und es am Anfang gesetzt wird. Jetzt überlegen wir die aufsteigende Reihenfolge. Wir haben auch die absteigende Reihenfolge, in der wir das maximale Element finden und es am Anfang speichern können. Und als Einfüge-Sortierung haben wir zwei Teile. Der, der bereits sortiert war und der unsortierte Teil. Und bei jeder Iteration der Auswahlsortierung das minimale Element aus wird das minimale Element aus dem unsortierten Sub-Array aufgenommen und in das sortierte Sub-Array verschoben. Also lassen Sie uns ein Beispiel verwenden. Wir werden die gleiche Liste hier verwenden. Und lasst uns das löschen. Wir haben diese Methode, löschen Sie diese. Und wir werden diese Methode hier arbeiten lassen. Aber vorher lassen Sie uns diesen Code ausführen und diese Liste verwenden. Jetzt. Aber wir werden in diesem Sortieralgorithmus tun, ist es, jedes Mal das Minimum zu finden und es am unsortierten, sortierten Teil zu speichern. Also zuerst werden wir das Minimum finden und diese Liste hier haben wir eine als Minimum, nehmen diese 11 und tauschen sie mit dieser Nummer. Was auch immer diese Nummer ist, wir tauschen sie gegen eine aus. Also hier haben wir jetzt einen. Und so lassen Sie mich es hier schreiben. So haben wir 1253 und dass der nächste Schritt ist, das Minimum und diese Liste zu finden. Das Minimum ist also wahr und wir müssen es an dieser Position speichern. Also sind wir okay, da das Minimum zwei ist. Der nächste Schritt wäre also der gleiche wie der erste. Sense, wir müssen nichts ändern. Jetzt werden wir uns diese Liste ansehen. Wir haben 5310 und wir finden das Minimum hier. Das Minimum ist drei. Wir müssen es beim ersten Element speichern. Also müssen wir drei gegen fünf zum nächsten tauschen. Das heißt, sie zu tauschen. So bekommen wir 123510 und Glasschema verglichen diese beiden Zahlen wie üblich, Finden Sie das Minimum zwischen ihnen und speichern Sie es am ersten Element in dieser Liste. Und da zehn größer als fünf ist, brauchen wir nichts zu tun. Und das ist unsere endgültige Liste. Also jetzt gehen wir voran und schreiben es als Code. Also öffentlich statisch, void, Auswahl, Parameter eines Arrays, Integer. Und in diesem Fall zum Beispiel zuerst die Länge, müssen wir zum Beispiel zuerst die Länge,die Länge, die Länge, die Länge speichern , um sie in der for-Schleife zu verwenden. Also hier haben wir die Länge dieser Liste. Neben unserer for-Schleife können wir array.length oder beides sagen, das gleiche. Und jetzt müssen wir das minimale Element im unsortierten Teil finden. Also sollte der unsortierte Teil mit i plus eins beginnen. Also jedes Mal, wenn wir mit fertig sind, werde ich vergleichen und das Minimum und einen Teil von I plus eins auf der Länge finden . Und hier haben wir n minus eins. Da wir nicht am letzten Element enden müssen, können wir einfach hinzufügen und hier. Und die innere for-Schleife würde die beiden letzten Element vergleichen. Also lassen Sie uns in diesem Fall das Minimum als i gleich i speichern und jetzt sollten wir das Minimum und den unsortierten Teil finden. Also beginnen wir mit i plus eins und dann mit array, array.length oder und der gleichen Maxwell Einfachheit. Und jetzt werden wir jedes Element vergleichen, um das Minimum zu finden. Also zuerst haben wir gedacht, dass das Minimum bei Index i liegt. Der Index und eine ganze Zahl namens minimum. Erstens ist ich gleich 0. Also haben wir gedacht, dass die Mindestzahl in dieser Liste bei Index 0 ist , um zu gehen und auf Index 00 zu schauen. Also werden wir drei finden und es ist nicht das Minimum. Also müssen wir diese Zahl mit allen anderen vergleichen. Und das ist, was wir tun werden, um ein j zu vergleichen. In diesem Fall ist j die Liste von i plus eins von hier bis zum Ende. Also, wenn i von j ist weniger als Array von Männern, dann müssen wir den Index und Männer tauschen, es wird tatsächlich der andere Anhang sein. Also, was wir hier sagen, ist, dass Männer gleich sind, und lassen Sie uns mit diesem Beispiel arbeiten, um es besser zu verstehen. Also zuerst beginnen wir mit i gleich 0, i gleich 0. Wir speichern mindestens 0. Jetzt schauen wir uns diese Zahl an und j wird gleich 0 plus eins ist derjenige , der mit einem mit 1234 und mit vier saß. Wir werden Array von eins vergleichen. Wenn einer von einem weniger als Array von Männern und Männern ist, denken Sie daran, viele xn gleich 0 und J, in diesem Fall ist es gleich eins, wird gehen und vergleichen T2, das ist jeder aus eins mit drei, nur auf ein Minimum von 0. F zwei ist weniger als drei, dann ist das Minimum jetzt nicht mehr dieses. Es ist nicht mehr bei Index 0. Es ist bei Index j, in diesem Fall bei Index eins. Also geben wir Mindest- und NU-Wert von eins. Und das Gleiche wie zuvor. Jetzt ist J gleich zwei. Würde J, I, J und K von zwei vergleichen . Wir haben I2 hier, fünf mit einem der neuen Minimum, das ist eins. Also sollten Sie jetzt vergleichen, ist fünf mit 25 ist größer als zwei, dann wird nichts passieren. Dann gehen wir hier, wir verglichen Array von drei, das ist eins mit L2. So ist man niedriger als T2. Also müssen wir dem Minimum einen neuen Wert geben, den Wert von eins. Und schließlich haben wir hier, an welchem Index, den Minimalwert, wie nachdem wir das Minimum mit dieser for-Schleife gefunden haben, müssen wir dieses Minimum mit dem Element in der sortierten Liste austauschen , wo wir sie lösen sollten. Also, was Sie tun sollten, ist wie üblich, wir nehmen, zumindest, kann es in einer ganzen Zahl namens gedämpft als speichern. Wir ändern, was immer es Minimum mit unserem Auge gibt. Und schließlich, geben Sie dieses i Index ID-Array am Index i, den Wert von dam. Also hier tauschen wir sie aus und lassen Sie uns zurückgehen und diese Methode hier verwenden. Also Auswahl und die Arrays, Array. Und das Gleiche. Wir drucken sie aus und wir kriegen 123510. Also denke ich, dass die Auswahlsortierung einfacher ist als das Einfügen. In Bezug auf das Verständnis ist es im Grunde nur das Minimum in der inneren for-Schleife zu finden und es dann mit dem ersten Element hier zu tauschen. Aber hier. Und das ist es für die Auswahl, so dass es Sie im nächsten Video sehen. 25. Bubble Sort: Der dritte Sortieralgorithmus, über den wir sprechen werden, ist Bubblesort. Bubblesort ist der einfachste Sortieralgorithmus, der durch wiederholtes Austauschen der benachbarten Elemente funktioniert , wenn sie sich im Grundwasser befinden. Betrachten Sie also diese Liste von fünf Elementen. Zunächst einmal vergleichen wir die ersten beiden Elemente und tauschen sie aus, da fünf größer als eins ist. Und dann tun wir das gleiche für Nummer 235 ist größer als vier, dann sollten wir tauschen. Das ist jetzt das Nest. Und das Gleiche für die Elementnummer. 345 ist größer als zwei, sie sollte tauschen. Und schließlich haben wir 58. Und da sie in der richtigen Reihenfolge sind, ist acht größer als fünf, dann tauschen wir nicht aus. Jetzt können wir sehen, dass diese Liste noch nicht sortiert ist, da wir 1424 ist größer als zwei. Also, was Sie tun sollten, ist wiederholen Sie die gleichen Schritte und immer wieder, bis wir die sortierte Liste erreichen. Das schlimmste Szenario, wenn wir das hier ein Element haben, zum Beispiel, dass 0 sagen. Diese 0 sollte also 12345 mal getauscht werden. Wir haben sechs Elemente in dieser Liste. Und das schlimmste Szenario ist, das 05 Mal zu tauschen. Also, wenn wir eine Liste von n Elementen haben, sollten wir n minus einmal austauschen. So können wir diese Operation n minus einmal durchführen, und schließlich erhalten Sie diese sortierte Liste. Also lasst uns voran gehen und diesen Code schreiben, um eine andere Methode zu erstellen. Oder es blase mit einem Parameternamen ID-Array wie gewohnt und würde hier funktionieren. Also zuerst haben wir eine for-Schleife. Wie gesagt, von 0 bis n minus eins, können wir array.length sagen. Und in dieser for-Schleife haben wir eine andere for-Schleife, um alle zwei Elemente zu tauschen. Wenn der falsche Code für wir alle zwei benachbarten Elemente vergleichen, a von j ist a von j größer als a von j plus eins. Dann tauschen wir sie einfach aus. Lassen Sie uns einen ganzzahligen Tamp erstellen. Jetzt hier, RAM-Frühling, und das Gleiche hier. Und wenn wir bedenken, dass temp gleich Array dot j a j ist, was immer es bei j plus eins gibt. Und dann, wenn j plus1, der Wert Salz, und das ist unsere Methode und es tut mir leid, wir werden n minus eins und n minus eins haben. Lasst uns diese Blase benutzen und sie hier und das letzte noch einmal ausdrucken. Und wir kriegen 325110. Dies ist vor dem Essen und nach dem Salzen 123510. Jetzt kann unser Code verbessert werden, indem eine einfache Aufgabe ausgeführt wird. So haben wir hier zum Beispiel die Elemente ausgetauscht. Das erste Mal. Und dann mussten wir beim zweiten Mal nur 42 tauschen. Und diese Liste ist jetzt sortiert. Aber in unserem Beispiel sind wir verpflichtet, alle Liste und minus1 mal durchzugehen. Also eine Sache, die wir verbessern können, ist f. Und wir kamen zu einem Punkt, wo unsere innere for-Schleife keine Aufgabe ausführen, dann können wir gleichsetzen, weil wir keine Elemente zu tauschen haben. So können wir diese Aufgabe mit einem Booleschen tun. Also nennen wir es „swat“. Zuallererst ist es, sollte sein und geben Sie ihm nicht den Wert hier wird ihm den Wert innerhalb unserer äußeren for-Schleife geben. Swap zwei wird in diesem Fall zuerst gleich false sein. Und wenn, wenn wir nur mindestens ein Mal geworfen haben, dann wird nach dem Ausgehen aus dieser inneren Schleife den Austausch überprüfen. Wenn vertauscht gleich false. Dann haben wir hier keinen Austausch durchgeführt. So können wir die for-Schleife verlassen, da unsere Liste jetzt sortiert ist. Damit wir kaputt machen können. Andernfalls wird kontinuierliches Austauschen. Und wir führen den Code aus, wir erhalten das gleiche Ergebnis wie zuvor. Aber jetzt ist es viel einfacher und es wird nicht so viel Zeit wie zuvor in Anspruch nehmen. Das ist es also für Bubblesort, der einfachste Sortieralgorithmus zwischen allen von ihnen. Und wir sehen uns im nächsten Video. 26. Merge: Wechseln Sie zu einem anderen Sortieralgorithmus, Merge-Sortierung. Merge Sortierung ist ein Dividen- und Eroberungsalgorithmus Also lass mich weitermachen und eine neue Klasse erstellen. Unterklasse, erstellt Einfügungsname es zusammengeführt. Und er wird zusammenführen Art diskutieren. Betrachten wir zunächst eine kleine Liste von vier Elementen und diskutieren dann eine größere Liste. Betrachten wir zum Beispiel eine Liste mit vier Elementen, 2431. Also, was wir tun werden, ist, diese Liste in zwei Listen zu unterteilen. Der erste, den wir 24 haben, enthält zwei Elemente, und der zweite wird die letzten beiden Elemente haben, 31. Dann werden wir jede Liste allein sortieren. Also 24 sind bereits sortiert, so dass wir nichts tun müssen, tippen Sie sie einfach ein. Und hier haben wir 31, wir müssen sie tauschen. Das ist also unsere zweite sortierte Liste. Und danach müssen wir sie verschmelzen. Da sie sortiert sind. Das erste Element sollte also das kleinste sein. Also werden wir das erste Element in den beiden Listen vergleichen. Hier haben wir 21. Man wird also ausgenutzt und würde einen schreiben. Und dann werden wir vergleichen zwei mit 32 ist kleiner als zwei, und dann drei mit vier. Dasselbe, Stolz. Und dann noch das letzte Element in der ersten Liste, nur vier, und dann sind wir fertig. Verwenden wir jetzt eine größere Liste. Wir haben in dieser Liste sieben Elemente. Wir teilen diese Lektion auf Troilus. Und die erste Liste wird vier Elemente und die zweiten drei Elemente sein. Dann machen wir dasselbe mit dieser Liste, die in zwei Listen unterteilt ist, zwei, und dasselbe mit der anderen auch. Und wir haben immer noch nur ein Element, also teilen wir es in eins auf und wir werden dasselbe tun. Und diese Liste, wir haben zwei Elemente, würde sie in ein Element und jede Liste aufteilen. Und dann haben wir 1234567 Liste. Jede Liste enthält nur ein Element. Danach müssen wir sie verschmelzen. Wir beginnen mit den beiden Elementen hier. Wir haben siebenunddreißig und achtunddreißig. Siebenundzwanzig sind kleiner, als du 2738 schreiben würdest. Dasselbe hier, 343982. Und danach müssen wir die beiden Listen hier zusammenführen, wie wir es im vorherigen Beispiel getan haben. Also zuerst haben wir drei, dann haben wir siebenundzwanzig, achtunddreißig, dreiundvierzig. Das Gleiche hier. Und wir haben endlich unsere endliche Liste Finale gesalzen. Die Idee der Merge-Sortierung ist ziemlich einfach. Es erfordert, die Methode würde mehr als 1s aufrufen, zwei, bis wir erreichen. Liste eines Elements, dann sortierte Listen neu erstellen, wie hier gezeigt. Gehen wir weiter und schreiben es jetzt. Also, um die Merge Sort abzuschließen, müssen Sie zwei Methoden schreiben. Die erste Methode könnte gedacht werden, die Hauptfunktion, die das Array mit einer anderen Methode sortiert. Also lasst es uns schreiben. Öffentliche Leere. Nennen wir es öffentlich statisch, leer. Und es wird eine ganze Zahl und keinen Index und hohen Index akzeptieren . Sie stellen dar, wo sollen wir anfangen? Und dann, wenn niedrig weniger ist als die harte, dann können wir weitermachen. Sonst brauchen wir nichts zu tun. Es bedeutet, dass niedrig größer oder gleich hoch ist. In diesem Fall haben wir nur ein Element in der Liste und wir müssen es nicht zitieren. Also arbeiten wir daran, wenn niedrig weniger als hoch ist. Also, was wir hier tun sollten, ist auf den mittleren Index gleich niedrig geteilt durch zwei. Und dann werden wir die Liste sortieren und in zwei Listen aufteilen. Und dann, so der linke Teil allein und dann so das Recht, aber so kann das tun, wird unser Bei ein eingeben, wir haben mit niedrigen und dann sortieren das Recht, aber in einer Mitte plus eins. Und danach müssen wir die sortierten Hälften zusammenführen. Also werden wir eine Methode Limit Merge aufrufen. Und es wird als Parameter links, niedrig und hoch nehmen . Und lassen Sie uns weitermachen und unsere Merge-Methode erstellen. So haben wir hier können es privat, privat, statisch, nichtig, zusammengeführt und wie üblich Methode machen. Und jetzt müssen wir die Größen der beiden Subarrays finden und zusammengeführt werden. Der erste Typ ist also Limit n eins gleich minus eins. Und der zweite ist N2 gleich hi minus. Jetzt haben wir die beiden Größen. Neue Listen. Also nennen wir es Liste eins. Oder wir können links und rechts ausstoßen. So haben wir links, die Größe und rechts. Diese zweite Seite. Danach müssen Sie die Daten von diesem ursprünglichen Array in unsere zwei Arrays kopieren. Um dies zu tun, verwenden wir einfach eine for-Schleife mit der Grenze von un1 und kopieren alle Daten von rechts nach links. Also links ich gleich i und eine andere for-Schleife, um die Daten des rechten Teils des Arrays in unsere Liste namens rechts zu kopieren . In diesem Fall beginnen wir mit einem Array von Mitte plus eins und plus j und jetzt haben wir die Daten hier kopiert. Außerdem tut es mir leid. Und so kopieren wir unsere Daten. Jetzt müssen wir sie zusammenführen. Also, was Sie tun sollten, ist eine while-Schleife zu erstellen, um alle Daten, die wir gespeichert und links und rechts kopiert zurück zu unserem ursprünglichen Update zu kopieren. Wie wir in diesem Beispiel gesagt haben, nach dieser Phase müssen wir sie nach dieser Phasewieder in der ursprünglichen Liste speichern. Also hier werden wir die beiden Elemente vergleichen und dann starten wir sie und das ursprüngliche Array und das gleiche hier. Wir vergleichen diese Elemente zusammen und wir erhalten unsere sortierte Liste. Also gehen wir zurück zu unserem Code und schreiben eine while-Schleife. Und die Bedingung dieser while-Schleife, dass wir immer noch Elemente in links und rechts haben. Also hier lassen Sie uns ganze Zahlen erstellen i gleich 0, und das gleiche für J, 0. Und lassen Sie uns eine ganze Zahl und einen Namen erstellen, um sie zu benennen, die gleich o ist. jetzt, während i kleiner als n ist, eins, was die Größe von links und J ist kleiner als. Und zwei werden an dieser Schleife arbeiten. Nun zuerst werden wir links mit rechts von j vergleichen , von i ist weniger als j, dann speichern wir es. Diese Komponente und die ursprüngliche Liste. Also wäre a gleich links. Und dann erhöhen wir i da wir damit fertig sind, zum Beispiel, gehen wir zurück. Was wir in diesem Fall getan haben, ist, dass wir links von i hier, 27 mit drei verglichen haben. F, 27 ist weniger als drei. Wir sollten es hier aufbewahren. Nun, in diesem Fall ist 27 größer als drei, dann sollten wir drei in diesem Fall speichern. Sonst sollten wir es aufbewahren. Und bei jeder k abgeleiteten Komponente und erhöhen j um eins. Und in beiden Fällen sollten wir k implementieren, da es in beiden Fällen gefüllt wird. Nun, nachdem wir diese while-Schleife beendet haben, haben wir möglicherweise einige Elemente in jeder Liste übrig. Um also das Original auszufüllen, sollten wir alles vervollständigen, was in unseren beiden Listen übrig ist. So erstellen wir eine while-Schleife. Während ich weniger als N1 ist. Die N1, wenn i gleich N1 ist. Und wir brachen aus dieser while-Schleife wegen i gleich eins, dann wird diese while-Schleife nicht funktionieren, da sie bereits gleich Zeile eins wäre. Also, wenn dies der Fall ist, sollten wir nur kaufen, was es im linken Teil gibt und inkrementieren, k. und das gleiche mit n2, wenn j kleiner ist als und genau das gleiche zu tun, um Inkrement j und k. Jetzt sind wir mit unserer Merge-Funktion fertig. Und lassen Sie uns voran gehen und es und unsere Hauptmethode verwenden. Also gehen wir zurück. Aber bevor wir unsere Grenzen überprüfen. Hier haben wir links und rechts und gehen. Hier. Wir sollten mit einem Knoten beginnen. Da wir nicht mit Nullen gesessen sind, saß mit was auch immer unser Index hier ist. Und jetzt gehen wir zurück und dokumentieren hier. Unsere Hauptmethode. Dies erzeugt eine Verzögerung gleich, in diesem Fall vier bis 718 und verwenden Sie es jetzt, verwenden Sie die Sortierung mit einer 0 Länge minus eins. Und dann verwenden Sie eine for-Schleife, um unsere Elemente auszudrucken. Und Zwietracht 12478. Also das ist es für die Zusammenführung. So sehen Sie das nächste Video. 27. Schnelle Sortierung: Wie Merge Sortierung ist quicksort ein Dividen- und Eroberungsalgorithmus. Es nimmt ein Element als Pivot und partitioniert das Array um den Pivot. Es gibt viele verschiedene Versionen von Quicksort, die großen Pivot und verschiedene Möglichkeiten. Wir können den Drehpunkt als erstes Element auswählen. Erstes Element, zufälliges Element oder das Medium. Ich würde fragen erklärt, was Pivot ist in einem Moment. Zuerst schreiben wir eine Liste. Betrachten wir also, wir haben eine Liste enthält 101819. Und so ist das unsere Liste. Jetzt wählen wir Element als Drehpunkt. Gehen wir also voran und wählen Sie zum Beispiel das letzte Element und trennen Sie sie, um es zu verstehen. Und es wird das Gleiche hier haben. Also hier haben wir diese Liste und das ist unser Drehpunkt. Also genau hier unten. Und hier haben wir das erste Element. Jetzt brauchen wir zwei Pfeile, 2,2 bis zwei Positionen auf dieser Liste. Die erste, wir beginnen mit dem ersten Element von links und dem letzten Element vor dem Pivot. Also hier haben wir unsere erste, sagen wir, dies ist das erste Element und das ist das letzte. Nun, was tun wird, ist, das erste Element zu vergleichen, wenn es größer als der Drehpunkt ist, als wir es austauschen müssen, müssen wir mit einem Teil enden, das niedriger ist als der Drehpunkt und der andere Teil sollte größer als der Drehpunkt sein. Also, um das zu tun, zuerst, zehn ist größer als der Drehpunkt. Jetzt, dann wird sich bewegen, wird zu 80 bewegen. Hier haben wir 80. Jetzt sind wir bei 8050. So ist 80 bereit, ausgetauscht zu werden. Jetzt schauen wir uns 5050 an. Ist 50 größer als der Drehpunkt? Nein, dann können wir es tauschen. Jetzt tauschen wir 50 mit 80 aus. Hier werden 80 haben, und hier haben wir 15. Jetzt ändern wir die Positionen dieser Pfeile. Wir haben diesen Pfeil um 42. 30. Das Gleiche wird hier dasselbe tun. Wir haben 13, ist 30 niedriger als der Drehpunkt? Ja. Dann müssen wir nicht tauschen. Es wird zu einem anderen gehen zu 90 gehen. Und jetzt werden wir 90 mit 40 vergleichen. 90 größer als der Drehpunkt? Ja. Dann müssen wir es tauschen. Ist 40 niedriger als der Drehpunkt? Ja. Dann müssen wir diese beiden Elemente austauschen, wird 90 hier haben. Und die, jetzt die beiden Pfeile, lassen Sie uns sie nennen, um zu sehen, was passieren wird. Wir haben niedrig und hoch. Nun vor dem Austausch waren dies die Positionen und niedrige und hohe Strömung an Position 0123 und hohe Position für. Nun, nachdem wir die beiden Elemente getauscht haben, müssen wir um eins erhöhen und hoch um eins dekrementieren. Also werde ich an Position sein, an dieser Position und niedrig wird an dieser Position sein. Und wann immer niedrig gleich oder höher als hoch ist, können wir wissen, dass wir hier fertig sind, da Tief hoch überschritten hat. Nun, das letzte, was wir tun sollten, ist, dieses Element mit dem Drehpunkt zu tauschen. Also haben Sie 17 und am Drehpunkt 90. Jetzt können wir sehen, dass alle Elemente hier kleiner als 70, und alle Elemente hier sind groß und 70. Das ist also die Idee des QuickSort. Wir können den gleichen genauen Algorithmus zu dieser Liste durchführen. Wir können 40 als Drehpunkt wählen und entsprechend arbeiten. Und das Gleiche geht hier. Und wir lassen Rekursion die Arbeit für uns erledigen. Dies ist die allgemeine Idee und wir werden die Rekursion verwenden , um sie mehr als einmal implementieren zu können. Jetzt ist aufgetaucht. Also haben wir hier zwei Methoden. Die erste Methode wird privat, integer sein. Lassen Sie uns die Partition umbenennen. Es wird die Parameter nehmen und emittieren und niedrig. Und diese Methode wird das letzte Element als Drehpunkt nehmen. Das Pivot-Element an seiner korrekten Position im sortierten Array. Und Fälle alle kleineren, kleineren Elemente als der Drehpunkt nach links und größer nach rechts. Gehen wir also voran und beginnen mit dieser Methode. Zunächst einmal haben wir unser Drehpunkt erstellt wird. Jetzt ist der Vektor gleich dem letzten Element in dieser Liste. Und wir haben den Index des kleineren Elements. Es ist ein sname i , der gleich minus1 ist. Und in diesem Fall beginnen wir mit unserer for-Schleife. Wir fangen bei niedrig an. Den ganzen Weg zu. Jetzt müssen wir überprüfen, ob das aktuelle Element kleiner als der Pivot ist. Also, wenn j in diesem Fall weniger ist, und wir müssen i erhöhen Eins , Swap und Array j Also lasst es uns tauschen. Und gleich zu bearbeiten a. Er dann gleich, sorry, a gleich i, gleich j. Und schließlich, zurück zu G. Also jetzt tauschten wir die beiden Elemente. Nachdem wir mit dieser Wortschleife fertig sind, müssen wir den Drehpunkt mit bei einem i plus eins tauschen. Erstellen Sie in diesem Fall eine andere Zeit und tauschen Sie die beiden Elemente aus. Wie gesagt. Hier haben wir den Drehpunkt ist an Ort A. Und dann geben Sie die Bräune zwei. Jetzt haben wir die beiden Metadaten in Elemente getauscht und dann werden wir einfach plus eins zurückgeben. Das ist also unsere Methode, die Partitionsmethode. Diese Methode nahm das letzte Element als Pivot, platzieren Sie das Pivot-Element an seiner richtigen Position in der sortiert an a, und platziert alle kleiner nach links und größer abgeleitet. Nun ist die andere Methode die Hauptfunktion, die diesen Quicksort implementiert. Und nennen wir es öffentlich statisch, leer. So dass es drei Parameter wie gewohnt, und niedrig und hoch. Zunächst werden wir überprüfen, ob der Fluss nicht größer als hoch ist. Wir können arbeiten, sonst wird nicht funktionieren, weil es keinen Sinn ergibt. Und wir werden, wir werden eine ganze Zahl erstellen, lassen Sie uns es benennen, durch Partitionierung und Tiefe. Das wird, wo wir diese Methode verwenden, die wir hier erstellt haben. Pi würde also Partition am niedrigen verwenden. Nun, nachdem wir den Index bekommen haben, aber jetzt sollten wir die beiden sortieren, den linken Teil abschwächen, richtig? Aber so werden wir die gleiche Methode noch einmal verwenden, ohne einen anderen Weg zu Pi minus eins. Und das gleiche durch plus eine andere Art zu schreiben. Und dann sind wir mit dieser Methode fertig. Du kannst es benutzen. Und unsere Hauptmethode. So erstellen wir ein Array, zum Beispiel, dampfen es, und mit einigen Werten 426173. Und wir werden die Sortiermethode 0 nennen. Und bei der Länge minus1, erstellen Sie dann eine for-Schleife und drucken Sie die Elemente dieser Liste aus. Also wie üblich, mit etwas Platz hier, und lasst uns voran gehen und rennen. Der Code erhält 1234567. Dies ist also das Array sortiert Array nach der Durchführung dieser QuickSort. Also das ist es für Quicksort. Wir sehen uns im nächsten Video. 28. Jump: Wie die binäre Suche ist Jumps Search ein Suchalgorithmus zum Sortieren von Arrays. Die Grundidee besteht darin, weniger Elemente als die lineare Suche zu überprüfen, indem mit festen Registerkarten voran springen oder einige Elemente überspringen, anstatt alle Elemente in der Liste zu durchsuchen. Betrachten Sie zum Beispiel, dass wir diese Liste haben. Wir haben 16 Elemente hier. Nehmen wir an, wir suchen nach Nummer 55. So wird die Sprungsuche mit einigen Schritten den Wert von 55 finden. Betrachten wir zunächst, dass die Blockgröße, wie für seit 16, Quadratwurzel von 164 gesprungen werden . Also zuerst wird es von Index 0 auf Index vier springen. So wird es auf 01234 springen. Sprung zu diesem Element im Vergleich zu 5535 ist immer noch größer als drei. Dann springen wir noch einmal zu irgendeinem. Das Gleiche hier, 21 ist weniger als 55, dann müssen wir springen, wird auf 144 springen. Und dann können wir sehen, dass 144 größer als 55 ist. Also gehen wir zurück zu 21 und führen eine lineare Suche von 21244 durch, bis wir unser Element auf Nummer 55 finden. Normalerweise verwenden wir die Quadratwurzel der Länge als Blockgröße, die gesprungen werden soll. Denn im schlimmsten Fall ist dies die beste Schrittgröße. Also fangen wir mit unserem Code an. Springen. Die wichtigsten IJs von Integer und x , die wir in dieser Liste suchen werden. Und hier müssen wir zuerst die Länge des Tages speichern. Wir müssen unseren Stapel wählen. Und wie gesagt, nehmen wir die Quadratwurzel von n mit der Masse. Und diese Masse Quadratwurzel. Angenommen, wir haben 17 Elemente, geben US 14 und so als eine Zahl. Also nach der Einnahme der Quadratwurzel von und formatiert mit Math.Floor. Und da wir dann eine ganze Zahl zuweisen, um n zu konvergieren, und wenn das Element existiert, dann müssen wir den Block finden, in dem das Element vorhanden ist. Gehen wir also zurück zu unserem Beispiel. Und er 55 ist zwischen 2144. Also müssen wir diese beiden Elemente finden. Und wir haben bereits eine ganze Zahl, haben eine andere Entität neu erstellt oder nennen wir es, zum Beispiel, vorherige Flüssigkeit auf 0. Also am Anfang ist das vorherige gleich 0, also ist es an Position 0 und Schritt ist an Position vier. Und wenn das Element in diesem Intervall nicht gefunden wird, dann sollten wir vorherigen den Wert von vier geben. So vorherige ist jetzt an Position vier und wir müssen vier hinzufügen, um den Schritt. Also wäre Schritt an Position acht und weiter bis wir ein Arbeitselement finden und diese Interpretation und unser Intervall. Um das zu tun, müssen wir eine while-Schleife erstellen und die wilde Schleife so einstellen, dass bei a kleiner als x ist. Nun könnten wir zu einem Punkt kommen, an dem, wenn wir weiter vier hinzufügen, der Schritt, wir könnten Schritt größer als n haben, dann können wir nicht mit einem halben Schritt zugreifen. Also, anstatt auf Array von Schritt zuzugreifen, der ein Radarminimum zwischen Schritt und, und sagt. Jedes Mal, wenn wir diese Schleife ausführen, müssen wir vor dem neuen Wert ändern. Und das gleiche für Schritt drei hinzuzufügen. Was auch immer wir hier haben. So hat es hinzugefügt und dann werden wir vorherige ist größer als oder gleich. Und dann sind wir fertig. Wir haben das Tier nicht gefunden, das einfach minus1 gedreht hat. Und er sollten wir zu Integer wechseln. Jetzt. Also, was wir hier in dieser while-Schleife sagen, lassen Sie es an diesem Beispiel verwenden. Zuallererst haben wir vorherige gleich 0 und Schritt vier Position für jetzt, gehen wir durch diese while-Schleife. Zunächst werden wir überprüfen Array von Minimum zwischen Schritt und dann Schritt ist sicherlich kleiner als n. in diesem Fall ist Schritt gleich vier. Also Mathe bei einem von vier, das ist drei. In diesem Fall werden wir überprüfen, ob drei kleiner als x ist. Ja, dann werden wir die Ausführung dieser while-Schleife fortsetzen wird die Werte ändern. Nun, umgekehrt ist gleich vier und Schritt ist gleich acht. Und dann prüfen wir, ob wir die Grenzen überschreiten. Wenn vorherige größer als oder gleich n ist, Dann haben wir die Grenzen überschritten und wir getan, wir haben keine Zahl gefunden, die Acts übereinstimmt. Also, jetzt sind wir auf Position vier. Und Position acht. Das Gleiche. Wir vergleichen diese 21 mit 5521 ist weniger als 55 und wir müssen die while-Schleife noch einmal ausführen, bevor es jetzt an Position acht ist. Das ist also Position für, das ist Positionshilfe. Und der Schritt ist an Position 12. In diesem Fall haben wir 144. So verglichen einhundertvierundvierzig, fünfundfünfzig und fünfundfünfzig Jahre weniger als ein 144, dann wird die Schleife verlassen. Nachdem wir den Wert von acht und Schritt den Wert von 12, dann haben wir unser Intervall und 55 ist in diesem Intervall. Nun, nachdem wir die while-Schleife verlassen haben, müssen wir eine lineare Suche nach x und einer y und einer anderen while-Schleife durchführen. Also, während Array des Ergebnisses mit dem vorherigen. Jetzt, da der vorherige an Position acht ist und Schritt an Position einhundertvierundvierzig und fünfundfünfzig ist, was zeigte, dass der Empfänger in einem Dissens ersten Intervall ist, dann werden wir mit 21 beginnen und weiter. So weit tragen im vorherigen ist weniger als x, dann werden wir um eins erhöhen. Und wenn wir zu einem Punkt gekommen sind, wo vorherige gleich einem Schritt ist, gleich 12 über n, Also gleich Minimum zwischen den beiden ganzen Zahlen, entweder Stempel. Und dann müssen wir brechen oder zurückgeben minus1 kann einfach minus eins zurückgeben. In diesem Fall, da wir unsere Nummer nicht gefunden haben. Und dann überprüfen wir, ob wir das Element gefunden haben. Also, wenn Array vorherigen gleich x ist, dann geben wir diese Position zurück und geben minus eins zurück. Wenn wir sterben, haben wir es nicht gefunden. Das ist also ein t, das wir hinzugefügt haben, kann nicht von n Boolean konvergieren, wir haben eine fehlende. Also das ist es, das ist unsere Funktion. Und lass uns voran gehen und es hier wählen. Also drucken wir Brocken aus und suchen nach 55. Also lasst uns das nehmen und sie in unsere setzen, das ist unser Array und es wird zehn zurückgeben. 55 ist also an Position zehn. Also waren diese ersten beiden Zeilen aus den vergangenen Funktionen jetzt diese Stunde als unsere Position, wo 55 auf dieser Liste steht. Also das ist es für Sprünge. Wir sehen uns im nächsten Video. 29. Interpolationssuche: Und andere Suchalgorithmus als Interpolationssuche. Die Interpolationssuche funktioniert besser als die binäre Suche. Weil die binäre Suche immer auf einer mittleren Elementbasis überprüft wird. Interpretation kann jedoch nach dem Wert des zu durchsuchenden P an verschiedene Orte gehen . Also zum Beispiel, wenn wir für die Nummer drei und diese Liste suchen wollen, wenn wir binäre Suche verwenden, wird gehen und überprüfen in der Mitte. Also entweder 1321034, also ist dies die Mitte der Liste. Wenn wir jedoch Interpolationssuche verwenden, wird auf den Wert gehen, der näher an unserer Zahl mit einer bestimmten Formel ist , und wir werden später darüber sprechen. Also ist er drei näher an 0, als es näher an 610 ist. Unsere Formel wird uns zu einer Zahl zwischen diesen führen. Also die gleiche Idee wie binäre Suche, aber anstatt ein mittleres Element zu haben, werden wir eine Position haben, die sich entsprechend unseren Elementen ändern wird. Lassen Sie uns also voran und erstellen Sie unsere Methode öffentlich. Und nennen wir es Interpolation. Und wie in der Regel ein Array von Elementen und die Größe des Elements zu nehmen , sowie die IV oder sagen wir x. Jetzt müssen wir unsere niedrigen und hohen und niedrigen gleich 0 und wird und minus1 y Schleife. Also, während niedrig kleiner oder gleich i ist, sonst müssen wir nicht mehr arbeiten, weil wir unser Element nicht gefunden haben. Es ist also das gleiche wie bei der Binärsuche. Und wir müssen einige Bedingungen hinzufügen. Während unser Element x kleiner oder gleich ist, ist unser Tief größer oder gleich, es tut mir leid, und ist kleiner oder gleich unserem Element. Solange diese Bedingungen erfüllt sind, können wir hier arbeiten. Wenn wir nun zu einem Punkt kommen, an dem unser Tief gleich unserem hohen Index ist, dann bedeutet dies, dass wir es getan haben, entweder finden wir das Element oder nicht. Also werden wir überprüfen, ob ich das gleiche weiß, da sie gleich sind, ist gleich unserem x und dies ist der Fall Rückgabe niedrig, andernfalls gibt minus1 zurück. Und nach der Überprüfung dieser Bedingung, jetzt können wir arbeiten, können unsere Formel die gleiche Position erstellen, die springen wird. Wie wir es bei unserer binären Suche getan haben, haben wir eine Position namens Metallelement erstellt. Jedes Mal, wenn wir jetzt zum mittleren Element gehen, erstellen wir eine andere Ganzzahl namens Position. Und die Formel ist wie folgt. Auf diese Weise berechnen wir die Interpolation. Und ein von hohen minus niedrig. Dann multiplizieren wir es mit ich würde x minus eine Last. Und jetzt überprüfen wir, ob ein Strahl an dieser Position unserem Element entspricht, dann geben wir einfach unsere Position zurück. Andernfalls werden wir überprüfen, ob a an dieser Position kleiner ist als unser Element. Dann müssen wir unser Tief von der niedrigen auf die hohe Position plus eins ändern. Das gleiche wie wir es getan haben und in der binären Suche, aber anstelle der Position und wir verwendeten Methode andernfalls wird Position minus eins sein. Also, sonst, wenn die wir an einer Position haben größer als x, dann wäre du gleich Position minus1. Und nachdem wir diese Bedingung und alles, die while-Schleife beendet haben, können wir minus eins zurückgeben, wenn wir die ganze Zahl nicht finden. Und jetzt gehen wir zurück und benutzen es hier. Also drucke ich Interpolation aus. Wir haben die a und B und x wird die Zahl sein. Nehmen wir zum Beispiel für eine Suche nach b an und lassen Sie uns weiter gehen und unseren Code ausführen. Wird für SO drei bekommen ist an Position 401234. Ändern wir diese Zahl auf 89 und wir bekommen Position 11. 89 ist also an Position 11. Und das Letzte, was wir kommen, um zu überprüfen, ob wir eine Nummer eingeben, die nicht in dieser Lektion ist, 900, bekommen wir minus eins. Also das ist es für die Interpolationssuche. Wir sehen uns im nächsten Video. 30. Exponentielle Suche: Der letzte Suchalgorithmus, über den wir sprechen werden, ist die exponentielle Suche. Exponentielle Suche umfasst zwei Schritte. Zuerst müssen wir den Bereich finden, in dem das Element vorhanden ist. Und dann machen wir binäre Suche im Seltsamen. Betrachten wir diese Lektion. Wir haben 16 Elemente und wir müssen zum Beispiel 89 finden. Was wir also tun werden, ist zunächst zu überlegen, ob unsere Zahl gleich dem ersten Element in dieser Liste ist. Wenn dies der Fall ist, dann geben wir 0 zurück, also ist es an Position 0. Andernfalls überprüfen wir alle anderen Elemente. Wir beginnen mit i gleich eins und mit Doublet I gleich zwei, dann i gleich 24816 und so weiter. Und lassen Sie uns voran und implementiert, um dies besser zu verstehen. Gehen Sie hier und Sie haben öffentliche statische, und nennen wir es exponentiell. Wie üblich, nehmen Sie ein Array von ganzen Zahlen und, und, und, und den Wert, den wir suchen, wir werden es x hier nennen. Zunächst müssen wir, wie gesagt, überprüfen, ob bei Index 0, wenn der Wert bei Index 0 ist, dann geben wir einfach 0 zurück. Andernfalls müssen wir den Bereich für die binäre Suche durch wiederholte Verdoppelung finden. Also werden wir eine ganze Zahl mit dem Wert von eins definieren, und wir geben die Schleife ein. Während i ist weniger als n, die Länge des Tages. Und bei a, bei i ist kleiner als unsere, kleiner oder gleich unserer Zahl. Diese Schleife wird ausgeführt. Also werden wir einfach i mit zwei multiplizieren. Jedes Mal, wenn wir diese Schleife betreten, multiplizieren wir i mit zwei. Also lassen Sie uns hier in diesem Beispiel sehen, wann wir diese Schleife beenden können. Zum Beispiel, wenn wir nach der Zahl 13 suchen wollen, überprüfen wir zunächst, ob 0 gleich 13 ist. Nein, ist es nicht. Dann definieren wir i gleich eins und geben diese Schleife ein. Ich bin gleich eins, wird überprüfen. Während ich bei a, bei i kleiner oder gleich x ist, ist man kleiner als oder gleich 13. Ja, dann multiplizieren wir i mit. Also, jetzt haben wir ich gleich zwei, und wir gehen zu unserem nächsten Element. Hier haben wir auch eine, es ist weniger als 13 und ich ist weniger als n. dann multiplizieren wir i mit 21 mehr Zeit. Jetzt haben wir zwei Mal 24201234. Jetzt sind wir hier. Wir prüfen, dass die weniger als 13 ist. So können wir noch ein Mal auf vier Mal 28 multiplizieren. Jetzt sind wir 5678, wir sind bei 21. Jetzt. Wir prüfen, ob 21 weniger als 13 ist. Nein, ist es nicht. Dann. Wir verlassen die Schleife mit i gleich acht. Jetzt haben wir ich gleich acht. Und um unser Intervall zu erhalten, haben wir i gleich acht und i gleich vier, was acht durch zwei geteilt ist. Nachdem wir also unser Intervall hier gefunden haben, verwenden wir einfach binäre Suche. Und ich arbeite bei einem. Und hier haben wir ich durch zwei geteilt. Dies ist unser Intervall und Minimum zwischen i und eins, i und n. Da es sein könnte, könnte es sein, dass i größer als n ist und wir nicht außerhalb unserer Grenzen arbeiten können. Und hier haben wir unsere ganze Zahl x. und da wir den Typ zurückgeben müssen, so drehen wir einfach binäre Suche. Und dann sind wir fertig. Gehen wir weiter und benutzen es hier. Also gehen wir voran und drucken exponentiell bei array.length und w. Wir werden zum Beispiel suchen, 13. Und der Code wird sieben bekommen. 13 ist also an Position sieben. Also machen wir es besser, netter. Und exponentiell. Speichern wir es als exponentiell. Und ein ganzzahliges Ergebnis ist gleich diesem Exponentialwert. Wenn das Ergebnis größer als 0 ist, dann drucken wir das Element am Index vorhanden ist. Und wir drucken den Index aus. Andernfalls drucken wir aus, dass das Element nicht vorhanden ist. Und Ray und Clustering wird der Code Element erhalten ist vorhanden und Index sieben. Jetzt haben wir eine Verknüpfung in Java, die Sie verwenden können. Anstatt all diese zu schreiben, können wir einfach eine der beiden Zeilen ausdrucken. Also müssen wir hier die Bedingung festlegen, wenn das Ergebnis kleiner als 0 ist, dies ist der Fall. Wir können ausdrucken. Element ist nicht vorhanden. Und die andere Anweisung wäre Element vorhanden ist, Index. Und wir drucken den Index aus. Also lasst uns voran gehen und sehen, was hier gewesen wäre. Lassen Sie uns den Code ausführen und wir erhalten Element vorhanden ist und Index sieben. Also diese Verknüpfung, Zunächst einmal NDA System.out.print-Methode. Wir legen die Bedingung fest, dass Ihr Ergebnis kleiner als 0 ist. Dann wird automatisch diese Methode die erste Anweisung drucken. Andernfalls wird es drucken, was es nach den beiden Punkten hier gibt. Also fragten wir sie, ob es gefragt ist weniger als 0, ja, drucken Sie dies. Sonst. Drucken Sie das aus. Dies ist sehr hilfreich, wenn wir die Dinge nicht komplizieren wollen und wir eine sehr einfache Druckform brauchen. Dies ist also für die Suche nach Algorithmen. Wir sehen uns im nächsten Video. 31. Projekt: Lassen Sie uns schließlich auf das Projekt zu bewegen ist sehr einfach und unkompliziert, und dieses Projekt wird zwei Stapel haben und einen stapeln und beginnen zu. Hier müssen Sie einige Stärken auf diese Tags schieben. So zum Beispiel, Ich schob Sie sind, wie hatte die niedrige zu bekommen Hallo hatte die, wie geht es Ihnen. Nun müssen Sie diese Methode erstellen, die Merge genannt wird. Um Stapel eins zusammenzuführen und mit einem neuen Schritt zu beginnen und ihn dann in einem neuen Stapel hier draußen in der Hauptmethode zu speichern. Dann natürlich ausgedruckt habe ich verwendet und Java Stack. Aber natürlich können Sie den Stack verwenden, den wir selbst gebaut haben. Sie können hier auch jede Art von Daten anstelle der Stärke verwenden. Aber ich wählte Dinge, um nur zu sehen, wie es aussehen würde , wenn ich die Nachricht oder die Worte ausdrucke. Und natürlich sollte so Ihre Methode aussehen. Das sollte es. 32. Zusammenfassung: Danke und herzlichen Glückwunsch zum Schlagen Diskurs. Hier ist eine kurze Zusammenfassung dessen, was wir getan haben. Zuallererst sprachen wir über Stack. Wir haben Arrays und einzeln verknüpfte Listen verwendet, um diese Tags zu implementieren. Dann gehen wir zu Cues und einzeln und doppelt verknüpfte Liste. Und natürlich haben wir schließlich über das Sortieren und Suchen von Algorithmen gesprochen. Wir haben so viele von ihnen getan, wie schnelle und Bubblesort und lineare und binäre Suche. Und wir haben immer noch die nicht-lineare Datenstruktur. Und hoffentlich decken wir sie später in den nächsten Klassen ab. Also danke für Ihre Teilnahme und sehen Sie in der nächsten Klasse.