Transkripte
1. Willkommen in diesem Kurs!: Hallo Jungs und willkommen bei C plus Explosion Programmierung. Das Codierungs-Interview. Mein Name ist Alex und Zeit eines erfahrenen Softwareentwicklers , der seit etwa vier Jahren mit C plus plus arbeitet. Nun, die Struktur dieser Klasse wird in Schlüsselelemente aufgeteilt
werden, die Zieldokument genannt Interviews für Software-Entwickler diskutiert werden. Zuallererst werden wir über die Komplexität eines Algorithmus sprechen, sowohl Zeit als auch Raum. Dann werden wir in Arrays springen. Dann werden wir uns Saiten anschauen. Dann wieder, Interview-Fragen basierend auf Strings ist das Thema, auf das wir uns konzentrieren werden. Dann werden wir uns auch ein paar sehr wichtige Sortieralgorithmen wie Bubble Sortierung,
Quicksort und so weiter ansehen . Wir werden uns auch Bäume ansehen. Es sind Traversals und ein paar andere Interviewfragen, die Sie auf DOM erhalten können. Und wir werden auch einen Blick auf Stacks und Warteschlangen werfen. Die Klasse ist für jede Partei erstellt, die entweder einmal Algorithmen in der Programmiersprache von C plus plus lernen, oder jemand, der im Bereich der Software-Engineering beschäftigt werden will. Und wenn Sie Fragen lernen, die auf Interviews gegeben
werden können , so dass sie ihre Interviews stützen können. Es gibt keine tatsächlichen Voraussetzungen für diesen Kurs. Dann Ihre Lernbereitschaft und eine Internetverbindung. Was das Klassenprojekt betrifft, wird
es eine Frage sein, die in einem Interview-Szenario empfangen werden kann, das Sie betrachten können. Denken Sie an den Kopf, kann Zeit selbst für 30 Minuten und versuchen, mit dem besten Extrakt zu kommen, den Sie bekommen. So nennt es das interessant klingt. Ich freue mich, Sie in der nächsten Lektion zu sehen. Lasst uns loslegen.
2. Big O-Notation: Willkommen in Abschnitt
zwei, große O-Notation. In Vortrag eins werden
wir über großes O,
großes Omega in zeitlicher Komplexität sprechen . Lasst uns anfangen. Die große O-Notation ist eine mathematische Notation
,
die das einschränkende Verhalten einer
Funktion beschreibt , wenn das Argument zu einem bestimmten
Wert oder einer Unendlichkeit
neigt. In der Informatik wird die große
O-Notation verwendet, um
Algorithmen nach dem Wachstum der
Laufzeit oder des
Platzbedarfs zu klassifizieren Algorithmen nach dem Wachstum der
Laufzeit oder des
Platzbedarfs . Wenn die Eingabegröße zunimmt. es nicht gründlich verstehen, kann Ihnen bei der
Entwicklung eines Algorithmus
wirklich schaden. wird Ihnen nicht nur
hart angeklagt, dass Sie Big O nicht wirklich
verstanden haben, sondern Sie werden auch
Schwierigkeiten haben zu beurteilen, wann Ihr Algorithmus
schneller oder langsamer wird. Bei der Analyse von Algorithmen
auf Effizienz verwenden
wir großes O. Zum Beispiel kann
festgestellt werden, dass
die Zeit, die Anzahl der Schritte, die erforderlich sind, um ein Problem
der Größe n zu lösen, n mal n auf die Macht von zwei plus
acht Mal n plus eins. Wenn n groß wird, das n bis zur Macht von wird
das n bis zur Macht von
zwei
Begriffen das dominieren. Alle anderen Begriffe
können vernachlässigt werden. Zum Beispiel, wenn n 500 ist, ist
der Begriff fünfmal n bis zur
Macht von zwei hundert, zehnhundertmal so
groß wie das zweifache n. Ignorieren des Buchstabens hätte vernachlässigbare Auswirkungen auf die der Wert des Ausdrucks
für die meisten Zwecke. Darüber hinaus wurde der Koeffizient irrelevant, wenn wir ihn mit
einer anderen Ausdrucksreihenfolge vergleichen . Die große O-Notation
erfasst also, was übrig bleibt. Wir schreiben o of n an
die Macht von zwei. Betrachten wir nun
einige Beispiele für die zeitliche Komplexität bestimmter
Informatik-Algorithmen. Einer heißt „konstant“. Zum Beispiel würde ein Algorithmus
, der bestimmt, ob eine Zahl gerade oder ungerade ist, diese Zeitkomplexität
haben. O von log n wird
als logarithmisch bezeichnet. Suchen Sie beispielsweise ein Element mit binärer Suche
in einem sortierten Array. Ich werde diese Art der
Suche vorstellen und wie sie in
einem späteren Abschnitt von
n funktioniert , heißt linear. Dies ist die zeitliche
Komplexität des Iterierens durch ein Array für eine
Vielzahl von Zwecken. Zum Beispiel, um
ein Element zu finden und so weiter. O von n zur Macht von
zwei wird als quadratisch bezeichnet. Dies ist der Fall, wenn Sie
zwei verschachtelte Kraft in einem Array haben . Dies kann nützlich sein, wenn
Sie ein Array sortieren möchten. Schließlich
wird o n factorial als faktoriell bezeichnet. Und wir stoßen auf diese Zeit auf
Komplexität, wenn wir versuchen, Brute-Force-Lösungen uneingeschränkte
Permutationen
berechnen. Im Allgemeinen geben
Sie beim Codieren von Interviews die Zeitkomplexität , damit Ihr Algorithmus
jedoch weniger Zeit
für Ausführung benötigt und
effizienter und optimiert wird. Sie können jedoch von
einer Lösung ausgehen, die nicht so großartig ist, wenn dies die erste Idee ist, die
Sie lösen
und sich dann zu
einem optimierteren Ansatz begeben. Akademiker verwenden Peek, oh, großes Theta und großes Omega,
um Laufzeiten zu beschreiben. In der Wissenschaft ist großes Omega
das äquivalente Konzept, aber für geringere Bindung und Druck die Werte in einem Array
ein großes Omega von eins. Schließlich wissen Sie, dass es nicht schneller sein wird
als diese Laufzeit. Big Theta gibt eine
enge Laufzeit. Wir können sagen, dass die
Bindung der Funktion von oben und unten
durch Theta-Notation dargestellt wird. Das exakte asymptotische Verhalten erfolgt durch d Theta-Notation. In diesem Kurs werden wir nur die Big-O-Notation für
unsere Algorithmen in der Art und Weise
verwenden
, wie die Industrie sie tendenziell nutzt, indem wir immer
versuchen , die Laufzeit strengste
Beschreibung anzubieten.
3. Übersicht über Array und Vektorgrafiken: Hallo da und willkommen
in Abschnitt drei Arrays. In diesem Abschnitt
werden wir über
eine grundlegende
Datenstruktur namens erase sprechen eine grundlegende
Datenstruktur namens erase , die in
Interviewfragen zur Codierung häufig auftaucht. Und es ist sehr
wichtig,
dass Sie es bei der Programmierung gut verstehen. Wenn wir an ein Array denken, denken
wir an eine
Datenstruktur, die
einer Sammlung von Elementen und
gespeicherten Speicherorten ähnelt . Die Idee ist,
mehrere Artikel
desselben Typs zusammen zu speichern . Dies erleichtert es, die Position
jedes Elements zu
berechnen , indem einfach
ein Versatz zu einem Basiswert hinzugefügt wird. Beispiel: der Speicherort des ersten Elements
des Arrays, im Allgemeinen mit
dem Namen des Arrays bezeichnet wird. Der Basiswert ist Index 0 und die Differenz zwischen den
beiden Indizes ist der Offset. Der Einfachheit halber können wir uns
eine Array-Flotte vorstellen eine Array-Flotte bei jedem Schritt der Wert
liegt, sagen
wir einer Ihrer Freunde. Hier können Sie
den Standort eines
Ihrer Freunde identifizieren, indem Sie einfach den Bericht über den Schritt
kennen, auf
dem er sich befindet. Denken Sie daran, dass
der Speicherort des nächsten Index von dem
Datentyp abhängt, den wir verwenden. Und es heißt standardmäßig reguläre Arrays mit lokalem Umfang. Zum Beispiel werden diejenigen, die in
einer Funktion
deklariert sind, nicht uninitialisiert
gelassen. Dies bedeutet, dass keines seiner Elemente an
einen bestimmten Wert gesendet wird. Ihre Inhalte sind an dem Punkt,
an dem die Theorie deklariert wird, unbestimmt . Die Elemente in einem Array
können jedoch explizit auf
bestimmte Werte initialisiert werden, wenn sie
deklariert werden, indem diese
Anfangswerte umfaßt werden. Zum Beispiel sehen Sie hier die erste
Zeile in unserem Bild. Die Anzahl der Werte
zwischen Lob darf nicht größer sein als die Anzahl der Elemente
im Array. Zum Beispiel
wurde in unserem
Bild in der ersten Zeile deklariert, dass
fünf Elemente durch die Zahl in der
Nähe der eckigen Klammern
angegeben wurden. Und das Lob enthält
genau fünf Werte. Eins für jedes Element. Deklariere es mit weniger. Die übrigen Elemente sind auf ihre Standardwerte
festgelegt, was für fundamentale Typen bedeutet, dass sie mit Nullen
gefüllt sind. den Wert der Elemente
in einem Array kann genau wie der Ausfall
einer regulären Variablen
zugegriffen werden . Derselbe Typ. Die Syntax ist name und dann zwischen
Klammern der Index. Beachten Sie, dass der dritte
Elementar-Fu F-O-O angegeben hat. Dann in Klammern die Nummer zwei. Da der erste F0 von 0 ist, ist
der zweite F0 F1. Und deshalb ist der
dritte F o von zwei. dem gleichen Grund, sein letztes Element, Es ist F0, F4. Wenn wir also etwas wie F0 05
schreiben würden, würden
wir auf das
sechste Element von F-O-O zugreifen und daher tatsächlich
die Größe des Arrays überschreiten. In C plus, plus. Es ist syntaktisch korrekt, den Wertebereich
von Indizes für ein Array zu überschreiten. Dies kann zu
Problemen
führen, da sich X in
äußeren Randelementen befindet , keine Fehler bei der Kompensation verursacht, aber Fehler bei der Laufzeit verursachen kann. In diesem Punkt ist es wichtig
, klar zwischen den beiden Verwendungen
unterscheiden zu können zwischen den beiden Verwendungen
unterscheiden , die Klammern
im Zusammenhang mit dem Löschen haben. Sie führen zwei
verschiedene Aufgaben aus. Eine besteht darin, die Größe
von Arrays anzugeben , wenn
sie deklariert werden. Die zweite besteht darin, Indizes für
konkrete Array-Elemente
anzugeben ,
wenn auf sie zugegriffen wird. Verwechseln Sie diese
beiden möglichen Anwendungen
von Klammern nicht mit Arrays. Irgendwann
müssen wir möglicherweise ein Array an eine Funktion als
Parameter übergeben, C plus plus. Es ist nicht möglich, den gesamten
Blockspeicher,
der
durch ein Array dargestellt wird ,
direkt als Argument an eine Funktion zu übergeben. Aber was können Sie tun, ist, dass Sie stattdessen seine Einträge übergeben
können. In der Praxis hat dies fast
den gleichen Effekt und
aus dieser Sicht ist es viel schneller und
effizienter viel schneller und
effizienter. Um einen
Array-Parameter für eine Funktion zu akzeptieren. Die Parameter können als Typ deklariert
werden, aber mit leeren Klammern erfüllen sie die tatsächliche
Größe des Arrays. Zum Beispiel für ein Verfahren. Und dann in der
Parameterliste int arg. Dann ein paar leere Klammern. Diese Funktion akzeptiert
einen Parameter vom Typ Array von int namens ARG. Um diese Funktion,
ein Array, das als int deklariert ist,
meine Array-Elemente, einzufügen ein Array, das als int deklariert ist, , würde es ausreichen, einen Code wie
diese Prozedur meines Arrays zu schreiben. Dies wäre also ein Überblick über den Array-Typ in C plus plus. Natürlich können Sie
mit jedem der Elemente noch
viele weitere Operationen ausführen . Du kannst sie tauschen und so weiter. Als nächstes werden
wir uns in den kommenden Vorträgen eine Vielzahl von
Algorithmen
ansehen, die häufig bei Algorithmen
ansehen, die häufig Fragen zur Programmierung von
Interviews
auftauchen. Und wir werden uns
ihre Komplexität,
verschiedene Ansätze
und im Grunde genommen ansehen , wie
wir sie lösen
können, damit wir besser auf
Ihre zukünftigen Interviews vorbereitet sein können.
4. Löschen in einem Array: Hallo Leute und willkommen
, drei Vortrag, in einem Array zu
löschen. In dieser Vorlesung
werden wir darüber sprechen, wie ein
Element aus einem Array gelöscht wird. Diese Frage hat
zwei Variationen. Aus einem Array, in dem wir wissen, wie hoch der Wert der Zahl ist, die wir aus dem Array löschen
möchten. Und die Variation
, bei der wir wissen, wie
die Position des Elements in
dem Array ist die Position des Elements in , das wir löschen
möchten. Genau hier haben wir die Variation bei der
der Wert des Artikels eingegeben wird
und nicht die Ablagerung, aber der andere ist diesem sehr
ähnlich. Lassen Sie uns den Code und nach Schulden und einige
Erklärungen dazu ausführen. Wir können über
die Komplexität
dieses Programms nachdenken , wie wir es
in einer Interviewsituation tun würden. Fangen wir mit dem Mittelwert an. Als gute Praxis ist
es immer gut, Ihre Funktionen von
der Hauptfunktion zu trennen und dann
Ihre Funktion aufzurufen , die Sie für
eine bestimmte Frage geschrieben haben ,
von der Hauptfunktion. In einer Interviewfrage
und einem Interviewszenario können
sie Ihnen sogar die
Funktion ohne den Körper geben. Es ist also nur ein Header. Und dann schreiben Sie die
Funktion, die
tun soll , wie das SQL gestartet wurde. In unserer Situation, als wir die Hauptfunktion
betraten, haben wir unser int-Array
deklariert , von dem wir entfernen werden, es mit einigen
fest codierten Integralwerten
initialisiert. Dann haben wir jede Seite die Größe der Theorie
durch die Größe eines Integrals zu
teilen. Dann schrieben wir x ist sechs. Wir wollten
sechs aus diesem Array entfernen. Jetzt rufen wir die Funktion
delete element auf, die nach dem Entfernen die neue Größe
des Arrays zurückgibt und
das Element offensichtlich aus dem Array entfernt. Diese Löschelementfunktion
hat, wie Sie sehen können, drei Argumente. Das erste Argument ist unser Array, aus
dem wir das Element entfernen möchten. Der nächste Punkt. Das Element bedeutet die
Größe des Arrays. Und das letzte Element ist die Nummer wir
aus dem Array löschen möchten, in unserem Fall sechs. Und wie Sie sehen können, sind dies die Argumente, die wir übergeben,
wenn wir die Funktion aufrufen. Was diese Funktion
tut, ist, dass sie
eine i-Variable deklariert , die verwendet wird, um durch das Array zu
iterieren. Und dann durchlaufen
wir in einer for-Schleife das gesamte
Array und nehmen jedes Element. Und wenn das Element gleich
dem x D-Element ist, das wir aus unserem Array entfernen
möchten. Dann brechen wir kaputt. X wird im Array gefunden und ich ist der Index
, in dem x gefunden wurde. Wir werden die Größe
des Arrays
verringern , da
es
eine Nummer kleiner sein wird als zuvor, weil wir offensichtlich ein Element daraus löschen werden . Und dann werden wir alle
Elemente
einfach um einen Raum voraus bewegen. Lesley, wird
die Größe des Arrays zurückgeben. Hier ist die neue
Länge des Arrays. Dann werden wir
Monte Carlo sehen und ihn dann
durchlaufen und zeigen es. Wenn wir das ausführen, werden
wir sehen, dass
das neue Tower-Array 1158910 sein
sollte. Sie können sehen, dass das Array ist. Denken wir nun über die Komplexität des Raums von
Diamanten nach. Die Raumkomplexität
ist offensichtlich linear weil wir
keine anderen Variablen deklarieren. Wenn wir das tun,
gelten sie als konstant. Dieser Raum ist linear und
dann die Zeitkomplexität durchlaufen wir
das Array einmal hier. Und offensichtlich einmal hier. Die zeitliche Komplexität
ist ebenfalls linear. Können wir das in einer besseren
Komplexität als diese tun? Nun, nein, weil unser Element das erste sein
kann, dann wäre es immer noch
linear, weil wir das gesamte Array
durchlaufen müssen. In diesem Schritt. Es ging darum,
ein Element aus dem Array zu löschen. Und ihr könnt die
Variation machen, in der Sie ein Element aus
einem Array
löschen, in dem Sie wissen, dass die Position dieser sehr
ähnlich ist. Aber das kannst du zu Hause probieren. Und lass mich wissen, wie es gelaufen ist.
5. Lineare Suche in einem Array: Hallo Leute und willkommen
zurück zu Vortrag vier. In dieser Vorlesung werden
wir
über die Suche in einer
Reihe von Ganzzahlen sprechen , genauer gesagt über die lineare Suche. Das Szenario ist, dass
wir ein Array von
Ganzzahlen haben , das Zahlen enthält
, die nicht sortiert sind. Also jede Art von Zahlen
, die ganze Zahlen sind. Und das Problem
mit S-Gas,
eine Zahl aus diesem Array zu finden und seinen Index zurückzugeben. Jetzt würden wir offensichtlich
eine separate Funktion von der
Hauptfunktion schreiben , die wir aufrufen, von der
Hauptfunktion aus aufrufen und diese verwenden, um unser Element zu finden. Wie Sie in
meinem Code genau hier sehen können, erklären
wir eine Rate, fest codiert
ist, Werte 2341040. Dann der x-Wert, der da ist. Dann
verwenden wir wie üblich die Größe der
Hilfsfunktion, verwenden wir wie üblich die Größe der um
die Größe unseres Arrays zu berechnen. Dann geben wir unser int
an, welches den Wert
der Suchfunktion salzt. Diese Funktion gibt einen int und benötigt drei Parameter. Unser Array, die
Größe unseres Arrays
und die Zahl, die wir finden
wollten. Dann
durchlaufen Sie es mit Hilfe dieser
Hilfsvariablen namens. Während wir es durchlaufen, finden
wir unser benötigtes Element, dann werden wir seinen Index
zurückgeben. Am Ende werden wir minus eins
zurückkehren,
was bedeutet, dass wir es nicht gefunden haben. Gib ich zurück, wie du wahrscheinlich
schon weißt, aber ich werde dich daran erinnern. Sagen Sie, wenn Sie es nicht wissen, die return-Anweisung, wenn
Sie in Ihrer Funktion sitzen, stoppt
die return-Anweisung, wenn
Sie in Ihrer Funktion sitzen, diese Funktion
und sie
geht im Grunde dorthin, wo die Funktion aufgerufen
wird, und
gibt diesen Wert zurück. Was ist nach einer Rückkehr
, die erhitzt wurde? Die Funktion wird nicht ausgeführt. Diese Rückgabe minus einer
Anweisung ist nur Wärme wenn diese Rückgabe
niemals ausgeführt wird. Wenn also unser Wert nie im Array
gefunden wurde, das Ergebnis mit dem Index
des Wertes aus dem Array
, das wir finden möchten. Wenn das Ergebnis minus eins ist, wird
natürlich sagen, dass
das Element nicht vorhanden ist. Und wenn es
heißt, dass es am
Indexergebnis vorhanden ist , das von unserer Funktion
zurückgegeben wird. Wie Sie sehen können, werden wir, wenn Sie dieses Programm ausführen, sehen
wir, dass dieses Element in Index drei vorhanden
ist. Wissen Sie, das Zählen in
einem Array basiert auf Null,
was bedeutet, dass der
erste Index 0 ist. Deshalb
wird dies eins zu n sein. Die Anzahl der Forschungen
für Dan ist Index drei. Sprechen wir nun
über Komplexität. Die Raumkomplexität ist
die Größe unserer frühen, die in
Bezug auf den Input linear ist. Dann wird die zeitliche Komplexität, naja, die zeitliche Komplexität durch
unsere Funktion gegeben , weil
wir genau hier einmal durch
unser Array iterieren. Das bedeutet lineare
Zeitkomplexität. Können wir das jetzt
besser machen als linear? Nun, nein, denn im schlimmsten Fall
das Element, dass wir
diese Position finden wollen , und das bedeutet, dass wir
das gesamte Array durchlaufen müssen , um es
endlich an der letzten Position zu finden. Und das würde lineare Zeit in Anspruch nehmen. Bei diesem Problem
ist sowohl die
Raumkomplexität als auch die Zeitkomplexität kaum linear. Lassen Sie uns zur nächsten Vorlesung übergehen,
in
der ich Ihnen einen
effizienteren Weg zeigen werde, dies zu tun. Aber unter einer Bedingung, und das ist das Array, zunehmend
sortiert
oder abnimmt.
6. Binäre Suche in einem Array: Hallo Leute und willkommen
zu Vortrag fünf, binäre Suche in einem Array. Dies ist im Grunde der erste
ernstere Algorithmus , den wir uns in diesem Kurs
nähern werden. Und dieser wird öfter in Interviews
gegeben. Und vielleicht nicht diese
grundlegende Variation, sondern andere Variationen, die andere Einschränkungen haben
können oder Sie nicht aufgefordert haben, dies
unaufhörlich zu implementieren. Aber eine andere Art von
Problem, bei dem Sie diese
Art von Algorithmus verwenden
müssen. Das Problem ist, dass
Sie bei einem
sortierten Array von n Elementen die
Funktion schreiben sollten, um
ein Element x in diesem Array zu geben . Ein einfacher Ansatz, wie wir in der letzten Vorlesung
gesehen haben, wäre die lineare
Suche nach Ihrem Array. Die zeitliche Komplexität
wäre linear, wie wir in diesem Raum sahen, wäre die
Komplexität linear. Aber ein anderer Ansatz, um dieselbe Aufgabe mithilfe der
binären Suche
auszuführen und angesichts der Tatsache , dass unser Array bereits
sortiert ist. Was also die binäre Suche
im Grunde tut, sucht stattdessen ein sortiertes Array, indem das Suchintervall
wiederholt geteilt wird. Atme ein, beginne mit einem Intervall, das das gesamte Array
abdeckt. Wenn der Wert des
Suchschlüssels kleiner
als das Element in der
Mitte des Intervalls ist . Schenken Sie das Intervall
nach unten, helfen Sie, verengen Sie es bis
zur Oberhand. Prüfen Sie wiederholt, bis der Wert gefunden wurde oder das
Intervall genau
ist. Die Idee der binären
Suche besteht darin,
die Informationen zu verwenden , dass
das Array sortiert ist. Die zeitliche Komplexität wurde reduziert,
logarithmische. Wenn wir uns dieses Bild ansehen, können
wir ein Beispiel sehen. Wir haben dieses Array, das 2581216233856172091
hat. Wir werden
m in der Mitte nehmen würde niedrig
sein und es wäre
0 und h wäre neun. Die drei Indizes, mit
denen
wir arbeiten, müssen wir nach 23 suchen. Nun, wir werden es überprüfen, und 16 ist kleiner als 23. Also werden wir nach rechts
gehen. Wir werden l, m,
den arithmetischen Durchschnitt von n und
h nehmen den arithmetischen Durchschnitt von n und . Und wir können sehen, dass
23 kleiner ist, 36. Ich gehe
in der linken Hälfte auf die Suche. Und jetzt wären es sechs, denn es wird m minus eins sein. M wäre fünf. Genau hier haben wir nach 23
gesucht, ohne uns Gegenstände wie
5812 oder sogar 72
anzusehen. Schauen wir uns nun den Code an
und sehen, wie er funktioniert. Die Hauptfunktion ähnelt
sehr der letzten Hauptfunktion
,
die wir bei der
linearen Suche nach einem
Array von Ganzzahlen verwenden . Der einzige Unterschied ist
die Funktion, die sie verwendet und die Indizes zurückgibt
, in denen unsere Nummer gefunden wurde. Diese binäre Suchfunktion benötigt, wie Sie sehen können,
vier Argumente. Die erste ist unser
Array von Ganzzahlen. Der zweite, der
dritte ist der R. Oder für den Fall, dass dieses
Bild h sein würde. Weil genau hier
richtig ist, gab es hoch. Sie meinen im Grunde
das Gleiche. Und dann ist x die Zahl
, nach der wir gesucht haben. Wir werden
rekursive Anrufe tätigen. Beginnen Sie damit, zu sagen, dass nicht so richtig ist
größer oder gleich L. Wir
werden
das Treffen im GRE erklären und ihm
im Grunde den Durchschnitt
von R und L. geben Wenn Sie sich
fragen, warum ist dieses L plus
R nicht durch zwei geteilt? Und es steht so geschrieben. Nun, das
trägt zuerst minus l und fügt dann hinzu. Dies hilft,
Fälle von Überlauf zu vermeiden. Die Zahl ist groß genug, um
den Speicher zu überschreiten , und für Ihr Programm
wird grundsätzlich abstürzen. Wenn die Fleischpalette gleich x war,
die Zahl, nach der wir nicht
gesucht haben, sollten wir den
Index zurückgeben, weil wir ihn gefunden haben. Wenn es größer ist als das
Element, nach dem wir suchen, können wir nur
im linken Unter-Array suchen. Also werden wir rekursiv die binäre Suche von
ARR Again L.
aufrufen . Und dann anstelle von Bereich, den ich Mitte minus eins aufrufen werde, werden
wir
anstelle von Bereich, den ich Mitte minus eins aufrufen werde, nur
in das linke Unterarray schauen. Im anderen Fall werden
wir in den
richtigen Subarray schauen, indem wir
den rekursiven Aufruf
anstelle von l geben Im zweiten Argument
Mitte plus eins. Zuletzt, wenn bei der Rückkehr von
den rekursiven Aufrufen keine andere Rückkehr
getroffen wurde . Jetzt komme ich minus eins zurück. Wie Sie sehen können, wurde bei
der Ausführung dieses Programms Nummer zehn
wieder bei Index drei gefunden. Wie ich bereits sagte, ist
die Raumkomplexität linear, weil wir das Array
deklariert haben, dann
ist die Zeitkomplexität logarithmisch. Dank dieses netten Algorithmus. Wenn das Array jedoch
nicht sortiert ist, können
Sie kein Element
in einer besseren
Zeitkomplexität als linear finden . Dies wird
hier nur möglich, weil wir wissen, dass das Array sortiert ist
und wir auf diese Weise
schneller durchschauen können. Es geht um die binäre Suche. Sie können versuchen, es
selbst zu
implementieren , ohne sich diesen Algorithmus
anzusehen. Dies ist eine wichtige
Interviewfrage und ein wichtiger Algorithmus, Sie wirklich sehr gut
kennen sollten.
7. Saiteninstrumente: Hallo Leute und willkommen
zurück in Abschnitt vier. In diesem Abschnitt
sprechen wir über Strings. Strings sind Objekte in C
plus die drei vorliegenden
Zeichenfolgen. Die Standard-String-Klasse
bietet Unterstützung für solche Objekte mit einer Schnittstelle , die der eines
Standard-Byte-Containers
ähnelt. Aber ich denke, Funktionen,
die
speziell für die Arbeit mit Zeichenfolgen von
Einzelbyte-Zeichen entwickelt wurden. Hier können wir über
Memberfunktionen wie swap sprechen, die den Inhalt
von zwei Zeichenfolgen austauschen, append, die eine Zeichenfolge
an eine bestimmte Zeichenfolge anhängen und einen Zeiger auf
die resultierende Zeichenfolge
zurückgeben. Einfügen, Löschen, Finden
von SDR und vielen anderen. Ich füge
hier ein Bild mit Beschreibungen
für jeden von ihnen an, damit du
sie lesen und verstehen kannst ,
was jeder von ihnen tut. Wir können auch über
überlastete Betreiber sprechen, wie zum Beispiel eine
Biegung zweier Straßen. Sie stehen mit der
Plusgleichzeichen-Verkettung, diesmal mit dem Pluszeichen. Der Gleichstellungsbetreiber, der
bis zu
Gleichstellungszeichen
umsetzt und so weiter. Dieses Glas hat auch eine
Vielzahl von Konstrukteuren. Die leere Zeichenfolge, die eine leere Zeichenfolge
erstellt. Derjenige, der
als Argument die Zeichenfolge zwischen Klammern nimmt. Sie können Ihre
Zeichenfolge schreiben und es wird dieses Getränke-Objekt
mit dem Stream
initialisieren , den
Sie direkt dort haben. Derjenige, der
eine Ganzzahl und
ein Zeichen annimmt und
die Zeichenfolge mit dem Zeichen instanziiert die Zeichenfolge mit dem Zeichen , das um
die angegebene Anzahl von Malen wiederholt wird. Um Strings zu verwenden, müssen
Sie eine zusätzliche
Header-Datei, Illustrator-Code, der eingeschlossen werden soll
, einschließen. Und dann String Dot h zwischen
Dreiecksklammern. Außerdem haben Sie gesehen, dass Sie Iostream
einschließen könnten , der
aus Eingabe und Ausgabestream stammt und normalerweise Tastatureingaben schreiben
und lesen müssen. Beachten Sie, dass diese Klasse
Bytes unabhängig
von der Kodierung verarbeitet , um
Sequenzen mit multiplizierter oder
variabler Länge wie UTF acht zu behandeln. Mitglieder dieser Klasse, wie Länge oder Größe, sowie ihre Iteratoren, werden weiterhin
in Bytes arbeiten, nicht in tatsächlichen kodierten Zeichen. In den nächsten Vorträgen werden
wir uns
einige
Fragen zur Interviewcodierung genauer ansehen , die möglicherweise Strings verwenden. Lasst uns an die Arbeit gehen.
8. Schnüre und die Länge einer Schnüre finden und die Länge einer Schnüre finden: Hallo Leute. In diesem Vortrag
werden wir über
Kontaktnation sprechen und
die Länge der Straße finden. Beginnen wir damit,
über Verkettung zu sprechen. Der Plus-Operator kann zwischen zwei Strings
verwendet werden. Füge ich sie zusammen
und erstelle eine neue Zeichenfolge? Dies nennt man Verkettung. Behandeln wir es in C plus. Plus ist eigentlich ein Objekt, wir bereits gesprochen haben. In der letzten Vorlesung. Nice object enthält
Funktionen, die bestimmte
Operationen an Strings
ausführen können . Beispielsweise können Sie Strings auch mit
der append-Funktion
verketten. Sie können dies auf jede Art und Weise
tun, wie Sie es bevorzugen. Sprechen Sie auf einer
konkreteren Ebene. Sie können in Ihrem
Code etwas wie
String S gleich einem Plus b sehen , wobei a eine andere Zeichenfolge
und B auch eine Zeichenfolge ist. Und verketten Sie sie,
indem Sie diesen Zwilling von
A und B am Ende machen. Und es wird im Grunde
eins drei sein, beide
zuerst und dann B
enthält, beide
zuerst und dann B
enthält um die
Länge einer Zeichenfolge zu erhalten, können
Sie die
Längenfunktion hat tief verwenden. Möglicherweise sehen Sie einige C
plus Plus-Programme, die
die Größenfunktion verwenden , um
die Länge der Zeichenfolge zu ermitteln. Dies ist nur ein
Alias, der leer ist. Es liegt ganz bei
Ihnen, ob Sie Länge oder Größe
verwenden möchten. Wenn Sie
dieses Problem jetzt implementieren
möchten, ohne
diese vorgefertigte Funktion zu verwenden, wird
es ziemlich einfach sein. Sie müssen jedes Zeichen
des Arrays mit einer for-Schleife
durchlaufen und
dann ein Integral mit
0 inkrementiertem Zeichen
instanziiert haben . Auf diese Weise können Sie die Länge ohne diese
vorgefertigten Funktionen erhalten. Sie können auf die
Zeichen in einer Zeichenfolge zugreifen, wie in einem
Array von Autos, indem Sie die Indexnummer
in eckigen Klammern
beziehen. Um den Wert
eines bestimmten Zeichens zu ändern. String, beziehen Sie sich auf die
Indexnummer und verwenden Sie einfache Anführungszeichen, da dies ein Zeichen ist.
9. Schnur ändern: Hallo da. In dieser Vorlesung
werden wir darüber sprechen, wie wir den Fallstream ändern
können. Das Problem hier ist
, dass wir
alle Großbuchstaben in
Kleinbuchstaben umwandeln müssen und umgekehrt. Industrie. Ein neuer Ansatz besteht darin,
die Zeichenfolge zu iterieren und
die ISA pro
Pre-Build-Funktion zu verwenden , um festzustellen, ob jedes Zeichen in der
tatsächlichen Anwendung befindet oder nicht. Wenn es sich um Großbuchstaben handelt,
werden wir es mit der vorgefertigten
CO2-Funktion in
Kleinbuchstaben umwandeln . Und wenn es nicht in Großbuchstaben ist, wandelt es mit
zwei vorgefertigten Funktionen in Großbuchstaben um . Jetzt können wir dies auch ohne
diese vorgefertigten Funktionen tun , indem den Wert 32
addieren oder subtrahieren. Weil das der Unterschied in Zahlen zwischen einem Groß
- und Kleinbuchstaben ist. Zum Beispiel hat
der Buchstabe Großbuchstaben
einen Ascii-Wert von 65, und Kleinbuchstaben hat einen
Ascii-Wert von 97, was 65 plus 32 entspricht. Sie können dieses kleine
Teufel auch benutzen, um dieses Problem zu machen. Wenn der Interviewer
angibt, dass Sie keine vorgefertigten String-Funktionen verwenden
dürfen. Wenn wir uns den Code ansehen, haben
wir diese Hauptfunktion bei der wir einen STR-Stream deklarieren, gibt
auch den Standardbereich weil wir den Namespace std nicht
verwendet haben. Sie können also entweder
den benutzenden Namespace
std schreiben oder std sagen. Und diese beiden
Doppelpunkte vor Amy, STD-Mitglied, die du schreibst. In der nächsten Zeile haben wir die STR-Zeichenfolge
mit dieser Zeichenfolge direkt hier initialisiert. Und dann rufen wir die
Transformationsfunktion in diesem STR mit drei Iteratoren vom Anfang der SDR-Zeichenfolge bis zum Ende des
Verlaufs oder Strings auf, dann
werden wir nicht einatmen Der März nannte „The Change Case“
für jeden Charakter davon. Dies ist nur eine Möglichkeit, es
zu durchlaufen. In Zeile 16 die Change Case Funktionen nimmt
die Change Case Funktionen ein Zeichen und
es gibt ein Zeichen zurück, wie Sie in seiner Kopfzeile sehen können. Und es ist nur eine
If-Funktion,
die überprüft, ob das
Zeichen Großbuchstaben ist, dann gibt es Kleinbuchstaben zurück. Und wenn es nicht so ist,
dass es Kleinbuchstaben ist. In diesem Fall werden wir
die Großbuchstabenzelle zurückgeben die Großbuchstabenzelle nachdem wir die gesamte
Zeichenfolge mit dieser Funktion transformiert haben, es wird so ziemlich
jeden ersten Casey sein. Dann schreiben wir
es an der Ausgabe-Eingabeaufforderung. Und wie Sie sehen können, erhalten wir,
wenn
wir diesen Code ausführen, den
wir den umgekehrten Fall initialisiert haben. Ich habe bereits gesagt, dass Sie
den 32 kleinen Hack verwenden können den 32 kleinen Hack , um dieses Problem
ohne eingebaute Funktionen zu erledigen.
10. Wörter / Vokale zeichnen: Hallo Leute und willkommen
zurück zu Vortrag vier. In dieser Vorlesung werden wir darüber sprechen
, wie Sie in einer Schnur auf die
Vokale
zukommen können . Im Grunde eine größere Zeichenfolge , die Leerzeichen
zwischen Wörtern hat. So etwas wie Samples oder
Pablo's kann sein, wenn eine Auszeichnung ist. Wie das Problem klingt ,
ist, dass die Funktion
, die Sie schreiben
sollen ,
ein Argument erhält, das eine Zeichenfolge ist, und Sie müssen dann
die Anzahl der Vokale zurückgeben. Zum Essen von Wörtern. Dies ist das Problem,
über das
wir heute in dieser Vorlesung sprechen werden. Wie Sie sehen können, habe ich es bereits für Sie
codiert, aber wir werden laufen, wie wir es normalerweise tun. Loben Sie, zu besprechen,
was im Grunde alles tut, ist, dass wir normalerweise
von der Hauptfunktion ausgehen. Hier erklären wir eine
Zeichenfolge, die ich
SDR und Nike feet ABC Space genannt habe . Und jetzt haben wir zwei Funktionen, um die
Anzahl der Werte zu zählen, die es hat. erste Funktion erhält
das dritte Zeichen, gibt brillant zurück. Was es macht. Danke diesem Charakter. Oberteil. Zum Beispiel
wäre es ein Kleinbuchstaben. Es bringt es wieder in Großbuchstaben zurück. Wir können
die oberen Zähne makellos
und nicht auch in Kleinbuchstaben überprüfen , denn dann hätten wir hier
fünf Bedingungen mit dem
ODER-Operator dazwischen gehabt. Was wir tun, ist
dorthin zurückzukehren, den Charakter. Charakter. Charakter ist ein
Charakter wie dieser, E, I, O, U. irgendeiner dieser Sitze wahr? Dann kehren wir zu dieser Funktion zurück. Wie Sie sehen können, wird es von
einer anderen Funktion aufgerufen ,
heißt Count-Vokale. Dieser erhält einen
String-Parameter basierend auf TR. Initialisiert und
integriert, zählt. Der Wert 0. Dann
durchlaufen wir die Zeichenfolge durch jedes seiner Zeichen. Dann wenn der tote
Charakter vokal, dann heben wir das Konto auf. Am Ende geben wir es zurück. Dies ist eine sehr einfache Methode , um die Anzahl
der Vokalzeichenfolge zurückzugeben. Sprechen wir nun über die
Komplexität dieses Algorithmus. Nun, zunächst ist dieser
Raum linear, weil wir nicht mehr als
diese Behandlung selbst deklarieren. Dann
ist die Zeitkomplexität linear zu, da wir jedes der Zeichen aus
der Zeichenfolge
durchlaufen , sowohl Zeit als auch Raum und Ort. Dies sind lineare große O von n. Nun, um
zum nächsten Problem
weiterzugehen und die Wörter zu zählen. Dies geschieht, indem Sie
eine Funktion schreiben , die von einem Parameter
empfängt , der ein Stream ist, und dann eine Ganzzahl
zurückgibt. Clara Decker, jetzt wo
wir mit 0 initialisieren und ein Zeichen, das wir
Preform vorheriger Tod nennen ,
initialisiert mit Leerzeichen. Jetzt essen wir den Weg
durch den Stream , den wir
als Parameter erhalten. Wenn der aktuelle
Zeichenraum in der vorherigen
Lektion ist, erhöhen wir. Was heißt das? Nun, es bedeutet, dass wir
den Anfang eines neuen Wortes gefunden haben ,
weil das Zeichen, jetzt ist es nicht der Raum
im vorherigen Raum, früher ein neues Wort war, eins. Zuletzt werden wir das vorherige mit x von i
aktualisieren. Wenn wir in der
nächsten Iteration nachschauen. Aktuell, früher, daher
der eigentliche vorherige Bär. Anständige Orientierung. Wir werden
die Nummer jetzt zurückgeben. Danke, du kannst es nicht sehen. Wenn wir diese Funktion
aufrufen, gibt
sie zwei zurück. Weil unsere Zeichenfolge ABC Space D0 als abc angesehen
würde. Und dann sind das
keine tatsächlichen Worte. Aber wenn du
einen Satz tippst , den wir
keinen Sinn ergeben haben, wäre
es wert. jetzt über die
Komplexität dieses Algorithmus spreche, denke
ich, dass es ziemlich klar ist, dass dieser Raum in
Bezug auf die Eingabe gilt, weil
wir nichts anderes
als den Stream selbst deklarieren . Wir haben lineare
Raumkomplexität, Zeitkomplexität. Es wäre
auch linear, weil wir die zurückgebliebenen einmal durch
den Stream
essen , um den Zustand
und den vorherigen Wert zu überprüfen. Genau hier. Wir haben zwei
grundlegende Algorithmen besprochen , die auftauchen. Ein paar Fragen. Probleme beginnen. Sie sind sehr einfach, aber es ist sehr wichtig, mit
den sehr grundlegenden
zu beginnen , um
die Komplexität
zu verstehen und wie sie optimal gemacht werden können. Weil man dann
auf dem Fundament aufbauen kann, Tiefe. Sie müssen in Zukunft
komplexere Algorithmen und
Probleme lösen und verstehen . Das nächste Kapitel, über das wir sprechen werden, muss eine Zeichenfolge
umkehren, was eine häufiger
erfüllte Interviewfrage ist.
11. Schnur umgekehrt: Hallo Leute, willkommen zurück. In diesem Vortrag werden wir darüber
sprechen, wie man eine bestimmte Serie
rückgängig machen kann. Wie wirst du das machen? Problem besagt, dass
Sie angesichts
dieses Gens von der Eingabe, von der Tastatur oder einer Datei einfach den Wert geben, von der Tastatur oder einer Datei einfach den Wert geben, den ich die
Aufgabenmatrik Jeff Tapisserie
hart codiere, und das Problem
besteht darin, sie umzukehren. Wenn
wir zum Beispiel eine Zeichenfolge haben,
wenn Ihre Funktion mit idealerweise streamen
wir dazu neigen, auf
die Schulden zu streamen , würde
umgekehrte Reihenfolge. werden nicht darüber diskutieren,
wie wir
diese Funktion implementieren und welche
Komplexität jede Zelle hat, haben wir
zunächst eine Zeichenfolge
deklariert. Es heißt Willkommen auf den Quadraten. Dann rufen wir
diese Funktion einfach auf. Diese Funktion gibt nichts
zurück. Es ist eine ungültige
Rückgabetyp-Funktion. Wir initialisieren die
Länge des Streams iterieren
dann zur
Gesundheit des Streams. Was wir tun, ist, dass wir
dazwischen die
passenden Charaktere tauschen . Zum Beispiel, wenn ich sehe
oder wir
diese T-R-I-E lecker
r i n minus u,
o minus eins, minus eins, minus eins tauschen diese T-R-I-E lecker
r i n minus u,
o minus eins, . Da anständige Arrays auf
Nullbasis gezählt werden, werden
wir sprechen, um das erste Element zu
tauschen, das 0 ist, ein Element, das minus eins
ist, ein Null-basiert. Zum Beispiel die Zeichenfolge. Wir werden die
Absicht G minus eins nehmen. Es wird die eine
Indizierung dauern, dann n minus zwei, was dann tauscht
und dann tauscht. Punkte. Wir heizen mitten auf
der Straße, wir halten an. Dies ist im Grunde
der optimalste Weg , um diese Operation durchzuführen. Und das, Sie können sehen, ob ich heize, wir werden dieses
Gen umgekehrt erhalten. Sprechen wir nun über die
Weltraumkomplexität dieses Algorithmus. Zuallererst ist diese
Raumkomplexität lineare Begründung, da wir die
zeitliche Komplexität
nicht erhalten. N geteilt durch zwei, da die Hälfte des Arrays nicht mehr mit Zeichen
dazwischen übereinstimmt. Wie wir wissen, nur das
n und seine Macht. Die Big O-Notation der
Zeitkomplexität wäre ebenso wie die
Raumkomplexität linear zu diesem Algorithmus. In der nächsten Vorlesung werden
wir sehen, wie es gelingt zu überprüfen ob ein Wort oder eine Zeichenfolge ein Palindrom
ist. Benadryl, was bedeutet,
dass dieser Traum, du zuerst hast, derselbe ist. Lasst uns weitermachen und
darüber sprechen, wie wir das machen können. Die Komplexität dieses
Algorithmus wäre.
12. Palindrom prüfen: Hallo Leute und willkommen zurück
zur Kursvorlesung. Wir werden sehen, wie
können wir prüfen, ob es funktioniert hat? Was bedeutet, dass
eine Zeichenfolge ein Palindrom ist , bedeutet, dass es dasselbe ist. Es ist das Gleiche, wenn wir
es von links nach rechts lesen. Zum Beispiel
wäre eine BBA ein Benadryl weil es wahrscheinlich eine ABB-Form
wäre. Das wäre immer noch eine BBA. Dieser wäre auch ein
bisschen Drama, aber diese
würden nicht daran liegen, dass wir es von links
nach rechts über
die Halbwertszeit hinaus
lesen , am Anfang. Wiederholen Sie dies von rechts nach links. Wir haben zwei LC WE. Jetzt, da wir verstanden haben,
was das Problem ist, würden
Sie ein Interview führen. Der erste Schritt besteht darin, zu verstehen, was das
Problem einmal von Ihnen ist. Wir können darüber nachdenken,
wie wir es lösen können. Aber da wir gerade darüber gesprochen haben,
wie man eine Zeichenfolge umkehrt, ist
dies ein sehr ähnliches
Problem, das sehr leicht gemacht werden kann, wenn wir
den umgekehrten Algorithmus haben, da wir nur
überprüfen müssten , ob unser Stream sein würde
gleich der Rückseite davon. Bei p gleich
wäre es wahrscheinlich wahr. Aber jetzt werden wir
einen anderen Ansatz für dieses Problem verfolgen. Lösen Sie, um
als Parameterzeichenfolge zu fungieren. Und dann werden wir keinen Grad zurückgeben,
weil Sie
nur den Ausgang
dieses Gen prägen werden nur den Ausgang
dieses Gen prägen , das dieses Gen
als Parameter erhält. Der Parameter beginnt
mit den Anfangswerten 0 und
altern dann mit der Größe unseres Streams. Dann, während Index, Index, Index, dieser Fall XDR von
nicht gleich dem STR. Also der magische Charakter
von Anfang an, nicht die Szene, die wir drucken
werden. Die Zeichenfolge ist nicht ersichtlich. Zeichne mir die Rückkehr zu Funktion
h und del cross paths. Das bedeutet, dass das Alter nicht invertiert
ist, bedeutet,
dass der gesamte Stream dies zeichnen kann. Sie können sehen, ob ich ziehe, es schaut nach
jedem dieser Tricks aus. Also ein BPA, ein BB, CC, BB oder nicht. Komplexität. Komplexität
ist
heute leicht zu betrachten, aber weil wir diese
Napa-Konstante
außer dem Eingabestrom haben , wäre es der Fall, aber weil wir diese
Napa-Konstante
außer dem Eingabestrom haben,
wäre es der Fall, zwei geteilt durch zwei weil wir alle dieses Gen haben
müssen. Wir erreichten die Hälfte von h
wäre die While-Schleife mit IT. Komplexität ist lineares Instagram in
Bezug auf das Genaue, diese wären offensichtlich Topo ihn
davon abgehalten, es zu tun. Weil Sie immer noch die Theorie überprüfen
müssen,
um sicherzustellen, dass
alle Charaktere gleich
sind, damit Sie bestätigen
können, dass
Ihre Schüler
in der gleich
sind, damit Sie bestätigen
können, dass letzten Vorlesung dieses
Abschnitts, der nächsten Vorlesung, über die nächste Vorlesung verfügen. Wir werden prüfen, ob
zwei Strings Anagramme sind,
was bedeutet, dass Sie
dieselben Zeichen posten. Es gibt noch mehr. Sehen Sie, wie wir es tun können
, um der
optimalste Algorithmus zu sein.
13. Überprüfe, ob 2 Strings Anagramme sind: Willkommen zurück. In diesem letzten Vortrag
hier darüber, wie
kann man die gegebene Stärke überprüfen? Wörter? Das können Sätze sein. Das heißt, sie
bestehen aus Charakteren. Was meine ich mit Probe? Wir haben zwei Wörter, wie z.B. Hund. Hund wäre Anagramme , weil ein T1, 01. Dies wäre
mehr eine Vereinbarung , weil die Zählung
innerhalb dieser mit f eins g läuft, und dieses haben wir
zwei Anagramme von G. Das Problem fordert uns auf, die Funktion zu
schreiben, um zu prüfen, ob zwei Strings Anagramme sind
oder nicht. Wie Sie sehen können, wir
die Hauptfunktion indem wir jeden
dieser Strings initialisieren. Wir rufen eine
Funktion auf, die als
Parameter verwendet, dass zwei
Streams wahr sind. Wenn dies G ist Ich integriere
Kosinusfunktion, deklarieren
wir zwei
ganze Zahlen, die verknüpft sind. Wir werden zuerst
überprüfen, ob die Saiten die gleiche Länge
haben. Das bedeutet, dass sie nicht
dieselben Charaktere haben können. Da offensichtlich zwei Mengen von Zeichen
vor dem TPI des Sprechers nicht gleich sein können, werden
sie Strings sortieren. Die Sterne sortieren sie
nach Ascii-Werten sortieren sie in alphabetischer Reihenfolge. Dann werden wir drei
Gene gleichzeitig sein. Haben wir hier dann einen benutzt, aber wir hätten es benutzen können,
weil im Grunde das Gleiche. Wir wären nicht in dieser Funktion, diese Zeile, weil Hype bereits falsch boolean zurückgegeben wurde. Wir durchlaufen jedes dieser Gene und
überprüfen ihren Charakter,
sagen wir gleich, nicht gleich,
wir geben falsch zurück. Stattdessen erreichen wir das Ende
von ihnen, Gesprächsfiguren sind gleich
und wir können wahr zurückgeben. Wir setzen diese Funktion ein, die jeden Status eins bis zehn
zurückgibt. Wir können diese Ströme,
Gramm werden kartiert. Ansonsten können wir
sagen, dass sie es nicht sind. Wenn wir beispielsweise
diese beiden Strings sehen ,
das richtige Beispiel, können
Sie sehen, dass es sich um
n handelt . Wenn wir
den zweiten Stream ändern, würde es im Grunde
mit dieser Bedingung tun, falsch oder wir können sie sogar gleich groß
machen, verschiedene Buchstaben und die beiden, es sind immer noch schwarze Patienten, die
Sie
hier sehen können , weil sie
sie in alphabetischer Reihenfolge sortieren
und sehen würden sie in alphabetischer Reihenfolge , dass einer p ist, einer ist G. Am besten ist dies wenn Aussage Trend
hier, dreimal falsch. Sprechen wir nun über die
Komplexität des Programms. Saline bezieht sich auf die Komplexität des Raumes. Wir können das
erste Streaming in Betracht ziehen. Die Komplexität des Raums
wäre groß O von n plus m. Danke, dass ihr
bei mir geblieben seid. In diesem Abschnitt. Wir werden
mit dem nächsten Abschnitt fortfahren. Sehr wichtiges Thema in Bezug
auf Fragen zur Interviewcodierung. Sortieren. Entweder wenn wir über das Kinderzimmer sprechen
oder wie Sie sehen können, kann
es sehr nützlich sein, wenn
wir mit Streichern arbeiten. Also werden wir jetzt ihre
Komplexitätsektion vertuschen ihre
Komplexitätsektion .
14. STL: Hallo Leute und willkommen
zurück zu Vortrag zwei. In der zweiten Vorlesung sprechen
wir über die
Sortierfunktion, die in der
Standardbibliothek von C plus plus
verfügbar ist . Sie können es als einfache
Alternative verwenden , wenn
der Interviewer nicht wirklich versucht, Ihre Fähigkeit
zum Sortieren eines Arrays oder
einer Datenstruktur zu
testen , aber dies ist erforderlich , um den
Rest von dein Problem. Sie können versuchen,
diese Sortierfunktion zu verwenden. Und es ist ein Szenario, in dem
Sie Ihre Elemente sortieren müssen, aber Sie müssen den gesamten
Algorithmus nicht selbst
implementieren. Sortierung ist eine der
grundlegendsten von Funktionen bereitgestellten Daten. Es bedeutet offensichtlich,
die Daten auf eine
bestimmte Weise anzuordnen , die je nach Ihrer
Datenstruktur zunehmen
oder abnehmen kann oder welche
Vergleichsfunktion Sie auch
verwenden könnten welche
Vergleichsfunktion Sie auch
verwenden könnten. In komplexeren Umgebungen. Angenommen, Sie haben
Strukturen vom Typ Cat. Sie möchten sie
nach der Anzahl der
Schnurrhaare bestellen , die sie haben. Sie müssen
diese spezifische
Vergleichsfunktion implementieren . Sie können tatsächlich das dritte
Argument an diese Funktion übergeben. werden wir später sehen. Es wird sie grundsätzlich
nach Anzahl Schnurrhaare sortieren. Es gibt eine eingebaute Funktion. Wie ich bereits sagte, stammt
das C plus plus STL
aus der Standardbibliothek. Name dieser Funktion. Interne Nutzungsinteressen sind detaillierter über
jede Implementierung da der Interviewer
sogar SQ hat, wie diese Funktion implementiert wird wenn er sieht, dass Sie sie verwenden. Nun, es verwendet einen
Hybrid aus schneller Sortierung, Heap-Sortierung und Einfügesortierung. Abhängig von ein paar Faktoren. Standardmäßig verwendet es quicksort. Was
ist, wenn Quick Sort mehr
als n log n time unfaire
Partitionierung macht ? Es wechselt zur Heap-Sortierung. Die Array-Größe
wird sehr klein. Es wechselt erneut
zur Einfügungssortierung. Wenn wir uns diesen Code genau hier
ansehen, können
wir diese Funktion
genau hier in Aktion sehen. Sie können in der
Hauptfunktion sehen, die wir uns
unary angeschaut haben, dass wir ein
hartcodiertes Array initialisiert haben. Dann haben wir die Größe mit
der Größe der Operatoren bekommen. Dann verwenden wir diese
Funktion genau hier , die zwei Iteratoren benötigt. Also haben wir ihm ARR gegeben, das ist der Zeiger des
ersten Elements des Arrays. Dann ARR plus n, was das Ende des Arrays ist. Dann sortiert es es. Um es in Aktion zu sehen. Wir haben es auch nach dem
Sortieren
auf den Bildschirm gedruckt und wie Sie
hier sehen können , es zunehmend sortiert. Wie ich schon sagte, haben Ihre Verwandten diese
Sortierfunktion hinter sich, dritten
Vergleichsparameter, der die Elemente
auf eine andere Weise anordnen würde. Zeig dir das. Ich werde diese Sortierfunktion ,
Parameter und
Vergleichsfunktion
beibehalten, die die Elemente abnehmend
sortiert. Das nennt man „Greater Beat“. Es hat unsere abnehmende Veränderung verändert. Wir können natürlich Ihre eigene Funktion
hier
implementieren, damit Sie sich über die Hauptfunktion schreiben
können ,
die
zwei Parameter benötigt und einen booleschen Wert
zurückgibt ob welche Bedingung auch immer
du willst neu anordnen ist wahr. Dieses Jahr wäre sehr interessante und einfache
Möglichkeit , die Sortierung
in einem Interview zu umgehen. Wie gesagt, wenn der
Interviewer diese Schuld ist, neugierig, ob
Sie das Array selbst oder S2 nach einem bestimmten
Sortieralgorithmus sortieren können. Angesichts der zeitlichen Komplexität
durch seine Implementierung ist
es das n-fache Protokoll von n. Und das ist tatsächlich
die beste Komplexität ,
mit der Sie ein Array bestellen können. Nun, in den nächsten Vorträgen, werden
wir uns
einige Sortieralgorithmen genauer ansehen , die tatsächlich implementiert
sind. So wie sie arbeiten. Außerdem werden wir uns
ihre Komplexität ansehen. Sehen Sie sich einige Möglichkeiten an,
ein Array oder eine andere
Datenstruktur zu sortieren , die Sie möglicherweise haben.
15. Bubblesort: Hallo Leute und willkommen
zurück zu Vortrag drei. In dieser Vorlesung werden
wir über
den grundlegendsten
Algorithmus sprechen , der
ein Array sortiert , das Sie ganz einfach selbst implementieren
können . Es heißt Bubble Sort. Es hat nicht die beste
Zeit- und Raumkomplexität. Aber
das werden wir in einer Sekunde erreichen. Zuallererst muss ich über diesen Algorithmus
sagen, abgesehen von der Tatsache, dass es der einfachste
Sortieralgorithmus ist, wie er funktioniert, indem er
wiederholt
die benachbarten Elemente tauscht , wenn
sie falsch liegen bestellen. Sehen wir uns nun
dieses Beispiel an, damit wir uns besser
visualisieren können , als
wenn wir uns den Code ansehen. Wie ist der Algorithmus eigentlich
eine weiße Zelle? Wir werden das
Array 5142 in das bringen, was es tut. Grundsätzlich bezahlte die
ersten beiden Elemente. Und es sieht,
dass fünf größer als eins sind,
also tauscht es sie aus. Dann dauert es 545 ist
auch größer als vier, also tauscht es sie wieder aus. Als nächstes ist 525 größer als
zwei, also tauscht es sie aus. Und am Ende haben wir 58. Diese sind richtig positioniert, sodass keine Swaps vorgenommen werden. Dann geht es wieder vorbei. Elemente zwei mal zwei nehmen,
wie ich bereits sagte, benachbarte Elemente, paraphrasieren Sie sie, wenn sie in der falschen Reihenfolge sind, und wenn dies der Fall ist, tauscht sie aus, wenn nicht, tut es das nicht. Einer von vier ist in
der richtigen Reihenfolge,
also wird es nicht tauschen, wenn er in der richtigen Reihenfolge kommt
oder nicht,
weil vier größer als zwei sind also wird es nicht tauschen, wenn er in der richtigen Reihenfolge kommt oder nicht , also werden wir sie tauschen. 45 sind in der richtigen
Reihenfolge und dann sind
58 in der richtigen Reihenfolge. Schon wieder. Sie können an dieser Stelle sehen, dass
unser Array bereits sortiert ist, aber unser Algorithmus
weiß nicht , ob es noch
vollständig sortiert ist, da er zu diesem Zeitpunkt
nicht hätte tun können. Es braucht also eine andere
Hoffnung, dass es offensichtlich keine Elemente
tauscht, weil sie
bereits oder Dritter gesendet werden . Aber wie Sie
in der dritten Basis sehen können, braucht
es wieder die
Elemente Dubai, und es macht keine Swaps. Schauen wir uns nun den
Code für diesen Algorithmus an. Wie Sie in
der Hauptfunktion sehen können, deklarieren
wir, dass es sich normalerweise ein hartcodiertes Array mit
einigen Werten handelt. Als nächstes erklären wir ein Integral
und dieses Mal, um die Größe
unseres Arrays zu essen, die wir deklariert haben, verwenden
sie wieder in
der Größe des Operators. Und dann rufen wir
die Bubble-Sort-Funktion auf. Wie Sie sehen können, benötigt
es zwei
Parameter, unser Array, und es bewegt sich jetzt im Stack nach oben. Sie können sehen, dass es in
die Bubble-Sortierfunktion gelangt. Es gibt eine Lücke zurück, weil es nur das Array sortiert und
nichts zurückgibt. Für das erste Element
nimmt das Array darin, habe
ich gesagt, das zweite
Element ist die Größe davon. Jetzt werden wir
zwei Elemente deklarieren, I und j. Theta. Ich bin es einfach gewohnt, das Array zu
durchlaufen. Es geht so. Abfrage. Jedes Element des Arrays, wir gehen wieder von 0
nach n minus ich minus eins. Sie können ignorieren, weil
es auf Null basiert. Es geht im Grunde
vom ersten Element der Theorie zum n minus Punkt. Und dann überprüft es, ob ARR von j größer ist als
ARR von g plus eins. Was bedeutet, dass wir
ein größeres Element haben , das
vor einem kleineren Element liegt. Und wir können diesen SP1 in aufsteigender Reihenfolge für unser Array haben. Tauschen Sie die Adressen von
Elementen aus , die sich
vor diesen Indizes befinden. Anzeige, die die
Änderung schwanger macht. Und wenn wir zurückkehren,
um die Theorie zu drucken, können
Sie sehen, dass beim Ausführen des Programms
das sortierte Array
zunehmend mit der
Tatsache druckt , dass die zweite Schleife
auf n minus I iteriert Dafür gibt es einen Grund. Weil die Array-Elemente nach n minus ich schon sortiert habe. Denn wenn wir
darüber nachdenken, gehe ich zuerst von
0 nach n minus eins. Das Ende der Theorie
in der zweiten Schleife
geht also von 0 nach n
minus I minus eins, was auch n minus eins ist. Also geht es bis zum Ende. Es behält die Chance das letzte Element
auf der letzten Position ist. Iterieren Sie als Nächstes von 0
zum letzten Element. Und dann wird das
Kettenelement
auf den beiden n minus eins minus I iterieren , was eins sein wird, das ist n minus zwei. Also ohne das letzte Element. Im Grunde wird es
das zweitgrößte Element
aus dem Array durchsuchen und so weiter. So funktioniert der Algorithmus. Es ist ununterbrochen dreißiger Jahre, wo das größte Element, um
es am Ende der Theorie zu stellen. Am Ende verstehe ich, dass das
Ende noch nicht sortiert ist. Die erste Iteration wird nach dem größten und
größten Element suchen. Die zweite Iteration
für die zweitgrößte usw. erreicht das erste Element im
Array ist bereits sortiert. Wenn wir über die
Zeit- und Raumkomplexität
dieses Algorithmus sprechen würden , ist
die Raumkomplexität in Bezug auf
die Eingabe
linear , da wir dieses Array gerade hier
deklariert haben, und dann erklären wir
zwei Variablen, die drei iterieren, aber die als Konstanten betrachtet
werden. Die Raumkomplexität ist also
groß O von m und sie ist linear. Jetzt ist die
zeitliche Komplexität dieses Algorithmus groß O
von n bis zur Macht von zwei. Es ist also eine quadratische
Zeitkomplexität, da der Algorithmus für
jedes Element des Arrays iteriert. Eine weitere Iteration, um im Grunde
nicht wirklich an den ganzen Strahl zu gehen, aber du bekommst die Idee. Es neigt asymptotisch zu
einer quadratischen Komplexität. Jetzt haben wir wieder eine Swap-Funktion, über die ich
nicht einmal gesprochen habe. Was das bedeutet. Wie Sie sehen können, gibt es nichts
zurück, was
nötig ist , um Zeiger zu integrieren,
und es tauscht zwischen ihnen. Das ist ein sehr schneller und
einfacher Sortieralgorithmus , den Sie bei einem
Rennen verwenden können, das Sie zunehmend Englisch sortieren
wollten . Aber wissen Sie nur,
dass seine
zeitliche Komplexität quadratisch
ist und nicht die beste quadratisch
ist und nicht die beste
Art von Zeitkomplexität, die Sie beim Sortieren eines Arrays
haben können , was BASF
bereits sagen würde n log n. was BASF
bereits sagen würde n log n.
schlagen vor , diesen Algorithmus
jetzt zu
implementieren, da es
diesmal keine Komplexität ist, wie Sie in
der nächsten Vorlesung sehen können, gibt es bessere
Sortieralgorithmen , die Sie vielleicht lernen und tatsächlich
implementieren Sie während Ihres Interviews
, wenn Sie danach gefragt werden. Aber es ist eine Grundlage. Und das ist ein ziemlich
grundlegender Algorithmus. Es ist schön, zuerst
mit einem einfacheren
Sortieralgorithmus Kontakt aufzunehmen , um loszulegen.
16. Quicksort: Leute, willkommen zurück
bei Vortrag vier. In diesem Vortrag werden wir über Quicksort
sprechen. Quicksort ist ein weiterer
Sortieralgorithmus , der mit Arrays arbeitet. Und es ist effizienter
Algorithmus, dann schlage sortieren Aus der Sicht der Zeitkomplexität und der
Raumkomplexität vor. Im Gegensatz zu March in Richtung ist
Quicksort ein Algorithmus für Dividen
und Eroberung. Was es tut, es ist
nur ein großes Element und partitioniert das gegebene
Array um den Pivot herum. Viele verschiedene
Versionen von Quicksort
, dieses große Pivot auf
unterschiedliche Weise wäre , immer das
erste Element auszuwählen ist. Eine andere Möglichkeit wäre,
immer das letzte Element,
diesen Pivot, auszuwählen , wie wir es
bei unserer Implementierung tun werden. Das wirst du in einer Sekunde sehen. Dann können Sie ein
zufälliges Element auswählen ist Punkt. Der beste Weg wäre, den mittleren SPM
auszuwählen. Der
Quicksort für die Schlüsselverarbeitung ist Partition. Das Ziel der Partition. Angesichts eines Arrays und eines
Elements x von Array-Pivot. Was diese Partitionsfunktion
tut, ist, dass sie
x und ihre korrekte
Position in ein Array einfügt ,
was bedeutet, dass alle
kleineren Elemente
dann auf der linken Seite liegen würden. Und all die größeren
Elemente dann wird
es drauf sein, oder? Bei diesem Prozess sollte nur lineare Zeitkomplexität in
Anspruch genommen werden. Wir schauen uns den Code an und
versuchen ihn zu verstehen. Wir werden sehen, dass wir in
der Hauptfunktion
ein Array deklariert haben, da wir
diese hart codierten Werte immer tun. Dann nehmen wir seine Länge
unter Verwendung der Größe des Operators. Und dann rufen wir
eine Funktion namens quicksort auf, die
drei Parameter benötigt. Der erste Parameter
ist das Array. Der zweite Parameter, rosa Punkte,
die an den gebunden sind, die Sie sortieren möchten, in unserem Fall den ersten
Elementindex, der 0 ist. Das letzte Element,
dieser dritte Parameter, die Obergrenze, die Sie in unserem Fall sortieren
wollten, der letzte Elementindex, und das ist n minus eins. Wir haben auch ein paar
Sauerstoff-Trage-Funktionen erklärt. Eine von ihnen Drucktheorie. Die zweite tauscht
zwei Elemente mit Zeigern aus. Wenn wir nun zur
QuickSort Funktion gehen, QuickSort Funktion die von der Hauptfunktion aufgerufen
wird, werden
wir zuerst
prüfen, ob low kleiner ist
als dies getan wird, ob low kleiner ist denn später werden wir Rufen Sie
diese Funktion rekursiv in den linken und rechten
Subarrays des Pivots auf. Wir müssen also immer
darauf achten, dass die Untergrenze niedriger ist
als die höhere Anleihe. Dann geben Sie
den Wert der Verderbung unseres Arrays an. Und untere und obere Grenzen
sind der Partitionierungsindex. heißt, wo ist unser Pivot an der richtigen Position im
Array, das sortiert würde. In dieser Aussage, über die
wir gerade gesprochen haben. Die Position,
in der
alle Elemente links und
kleiner als er sind, und alle Elemente
darin sind größer als er. Es spielt keine Rolle,
wie ihre Reihenfolge ist, weil das Array
sortiert ist oder nicht. Es spielt keine Rolle.
Dieses Element befindet sich an der Spurposition
, an der diese Bedingung stattfindet. Und dann werden wir
diese Funktion
rekursiv unser Array nennen , die Low-Bundung und die
Pivot-Position minus eins. Und dann unser Array-Pivot-Index plus eine und dann höhere Grenze,
was bedeutet, dass wir
quicksort
rekursiv für das linke Sub-Array
und das rechte Subarray
des Pivots aufrufen quicksort
rekursiv für das linke Sub-Array und das rechte Subarray
des werden, der korrekt ist
an dieser Stelle positioniert. Mal sehen, was diese
Partitionsfunktion macht. Es benötigt auch drei Parameter wie die QuickSort Funktion. Wir erklären einen Pivot. Integral nimmt das letzte
Element, weil
wir, wie gesagt, die
Variation von QuickSort implementieren werden, bei der der Pivot als
letztes Element aus dem Array genommen wird. Dann erklären wir I, was o minus eins wäre,
minus eins, minus eins, denn das erste Element
unseres Arrays wäre 00
minus eins minus eins minus eins. Wir werden ein bisschen sehen, warum wir es minus eins und nicht 0
nehmen. Und dann werden wir ein anderes
Integral verwenden , um das gesamte Array zu
durchlaufen. Iteration durch
das gesamte Array. Wir sagen, ob ARR von g, also das aktuelle Element
aus der Iteration, kleiner
ist als der Pivot. Zuerst werden wir I erhöhen, dann tauschen wir ARR von I von j aus. Dann werden wir diese Farbstoffe fortsetzen, lineare Iteration
durch das Array. Und 28, wir finden einen Gegenstand, der kleiner ist
als unser Pivot. In diesem Fall, dem
letzten Element
des Unter-Arrays, in dem wir uns befinden, werden
wir es an den
Anfang des Arrays setzen. Am Anfang nun,
erster Index, der
noch nicht besetzt ist. Es stellt alle
Elemente, die
kleiner als unser Pivot sind , in
den Vordergrund des Arrays. Schließlich tauschen
wir ARR von I
plus eins mit unserem Pivot aus. Weil das der richtige
Ort im Array ist. Dort wäre es falsch, wenn das Array sortiert
wird, wir
geben einfach diesen Index zurück, das wäre der richtige Index. Jetzt können Sie sehen, dass
wir verstanden haben, wie die
Partitionsfunktion funktioniert. Und wir haben auch verstanden,
dass
wir nach der Kälte diese
Partitionsfunktion auch rekursiv auf dem linken und
rechten Untergrund zum Pivot genannt haben. Auf diese Weise sortieren Sie das Array. Wie Sie sehen können, haben
wir ein Array von Elementen dann 789,
One und Fünf. Wenn wir es laufen lassen. Die PrintArray-Funktion
sollte unser Array drucken. Dies können Sie
diese Sortierdaten sehen. Sprechen wir nun ein bisschen
über diese Algorithmen. Stabilitätsachtungen
sind nicht vorhanden. Eigentum. Zuallererst ist
Quicksort stabil? Die Standardimplementierung
ist nicht stabil. Jeder Sortieralgorithmus
kann jedoch stabil gemacht werden, indem Indizes als
Vergleichsparameter
betrachtet werden. Zweitens, Experte, die breite Definition
des In-Place-Algorithmus. Quicksort gilt als Sortieralgorithmus für
Mitarbeiter. C2c ist zusätzlicher Speicherplatz nur zum Speichern rekursiver
Funktionsaufrufe, aber nicht zum
Manipulieren der Eingabe. Wir können sagen, dass es eine
lineare Raumkomplexität aufweist. Sprechen wir über die
zeitliche Komplexität, um
wirklich zu sehen, wie effizient
dieser Algorithmus ist. Nun, obwohl es
besser ist als die Blasensortierung, die
Komplexität in der besten Zeit linear wäre. Aber im Durchschnitt und schlimmsten
Fall wäre quadratisch, wäre großes O von n
bis zur Macht von zwei. Quicksort-Muster in der
durchschnittlichen Zeitkomplexität, verschiedene n log n. Die Maskenkomplexität
ist immer noch n log n, aber die schlimmste Komplexität
ist immer noch quadratisch. N an die Macht von zwei. In Interviews
fragt Name Sie tatsächlich etwas über Wochen. Wenn nicht die vollständige Implementierung. Sie können Sie fragen, ob Sie wissen, wie
hoch die Komplexität der Zeit ist, ob Sie wissen, wie
die Partitionsfunktion funktioniert und wie viel
Zeitkomplexität ist. Was übrigens linear ist. Wie wir schon gesehen haben. Wir iterieren nur
durch das Array. Und er könnte sogar
die rekursiven Aufrufe in der
Schnellsortierfunktion sq die rekursiven Aufrufe in der
Schnellsortierfunktion wo es sich einen sehr guten
Sortieralgorithmus in einem Interview handelt. Und es ist ein sehr nützliches
Tool, mit dem Sie die Elemente eines
Arrays
sortieren können , das Sie haben. Wenn Sie nicht über
die STL-Sortierfunktion verfügen,
Blasensortieren , Blasensortieren. Wenn Sie
etwas Effizienteres wünschen, dieser Algorithmus perfekt zusammen.
17. Bäume: Hallo Leute und willkommen zurück in Abschnitt sechs dieses Kurses. In diesem Abschnitt
werden wir über die neue Datenstruktur
namens Dreier sprechen. Und im Gegensatz zu Arrays, verknüpften
Listen, Stacks und Warteschlangen,
bei denen es sich um lineare
Datenstrukturen handelt, sind
Bäume hierarchische
Datenstrukturen. Der oberste Knoten heißt
root of the tree. Die Elemente, die
sich direkt unter einem Element befinden, werden Kinder
genannt. D-Element direkt über
etwas wird als übergeordnetes Element bezeichnet. Zum Beispiel ist ein Kind
von f und f Elternteil einer in diesem Baum Schulden, die wir auf dem Bildschirm
gezogen haben, oder? Schließlich werden Elemente
ohne Kinder auch immer als Blätter bezeichnet. Sprechen wir jetzt darüber,
warum sollten wir Bäume benutzen? Nun, ein Grund
wäre, dass Sie Informationen speichern
wollten , die
natürlich die Erbstätigkeit in der Apotheke haben. Denken Sie darüber nach, wie Ihre Dateien auf Ihrem
PC oder Mac-Buch
organisiert sind , was auch immer Sie haben, den
Start vom Stammordner und gehen Sie
sie dann in einer Artikelreihenfolge durch. Schnelles System auf dem Computer. Diese
werden wahrscheinlich mit Bäumen implementiert. Außerdem bieten Bäume eine
moderate Achse und Suche. Das ist eine mit einem Vorhang verknüpfte Liste, aber langsamer als Arrays. Tree bietet auch moderates
Einfügen und Löschen. Schneller als Arrays, aber langsamere, dünnere, ungeordnete verknüpfte Listen. Wahrscheinlich auch Liste. Und im Gegensatz zu Arrays
haben Bäume keine Obergrenze
für die Anzahl der Knoten. Knoten werden mit Zeigern verknüpft. Es gibt also einen Vorteil
, wenn wir uns diese Seite ansehen , dass ein Baum und Sie speichern können. den Hauptanwendungen von Bäumen gehört die Manipulation von
Hierarchie-TO-Daten, Suche nach Informationen
erleichtern. Wir werden sehen, dass es
in einer der nächsten Vorträge durchquert . Manipulieren Sie sortierte Listendaten. Sie können als Workflow
zum Verfassen digitaler Bilder,
für visuelle Effekte und
Router-Algorithmen verwendet zum Verfassen digitaler Bilder, werden. Und auch die
mehrstufige Entscheidungsfindung des Landwirts, zum Beispiel Geschäftsschach. Aus
Sicht der Implementierung wird
der Baum
durch einen Zeiger
auf den obersten Knoten im Baum dargestellt . Der Baum ist leer,
dann ist der Wert dieses obersten Knotens bekannt,
der Root genannt wird. Ein Baumknoten enthält
folgende Teile. Zuallererst
enthält es Daten in enthält
dann Hinweise
auf seine Kinder. Wir können drei
Knoten mithilfe von Strukturen darstellen. Zum Beispiel bin ich genau hier
angehängt. Du siehst genau
, wovon ich rede. Aber wir werden mit der
Implementierung in C
plus etwas später fortfahren . Sprechen wir jetzt ein bisschen
mehr darüber, welche Arten von Bäumen es in der Programmierung gibt. Wie gesagt, drei in der
Informatik sind wie in der realen Welt. Der einzige Unterschied besteht darin, dass es in der
Informatik dies auf dem
Kopf mit Wurzel auf
der Oberseite
visualisiert Kopf mit Wurzel auf und Krankheiten verhindert die von der Wurzel
bis zu den Blättern des Baumes ausgehen. Baumdatenstruktur ist eine
nichtlineare Datenstruktur. Ein Baum kann mit
verschiedenen primitiven oder
benutzerdefinierten Datentypen dargestellt werden. Wie wir gerade mit dem
Entlader gesehen haben. Drei implementiert, können wir
auch Arrays,
verknüpfte Listen, Brillen oder in
anderen Arten von Datenstrukturen verwenden verknüpfte Listen, Brillen oder in . Es ist eine Sammlung von Knoten
, die
miteinander verwandt sind, um zu zeigen, dass die Relationsknoten mit Kanten verbunden
sind. Aber in der Praxis eher wie
starke Zeiger aufeinander. Die Arten von Bäumen
in Datenstrukturen. Zuallererst
gibt es den allgemeinen Baum
, den es keine
Beschränkung dafür gibt, der ihm auferlegt wird, in der
Luft, die den Baum gehalten hat. Im allgemeinen Baum
kann jeder Knoten eine unendliche
Anzahl von Kindern haben. Diese drei sind die Obermenge
aller anderen Arten von Bäumen. Jetzt werden wir auf
binäre Bäume übergehen, die im März viel nützlicher
sind, mehr über Interviewfragen,
nur weil sie eine
einfachere und
elegantere Struktur haben und sich leichter
Fragen bilden lassen. Die binären Bäume sind
die Art von Baum
, in dem jeder Elternteil
höchstens zwei Kinder haben kann. Die Kinder werden als f-Diagramm oder als richtiges Kind bezeichnet. Ntc ist einer der
am häufigsten verwendeten Bäume in bestimmten Einschränkungen und Eigenschaften, die binären Bäumen auferlegt
werden. Dies führt zu einer Reihe
anderer weit verbreiteter G-AVL-Baum für binäre
Suche. So weiter. Wir werden gerade
über diese Arten
von Bäumen sprechen. binäre Suchbaum ist also eine Erweiterung des Binärbaums , über den wir gerade gesprochen haben, aber er hat einige andere
Bearbeitungseinschränkungen. Beispielsweise muss der Wert
der linken untergeordneten Elemente
eines Knotens kleiner oder gleich dem Wert
seines übergeordneten Elements sein. Und der Wert des
rechten Kanals ist immer größer oder gleich
dem Wert seines übergeordneten Kanals. Diese Eigenschaft der binären
Suchbäume macht es für den
Suchvorgang geeignet. Intensiv. Wie bei jedem Knoten können wir genau
entscheiden, ob der Wert im
Ausgang zu Ihren Rechten liegt. Daher
heißt es Search Tree. Ein komplexerer
Baumart ist der AVL-Baum. Dass es sich um einen selbstbalancierenden
binären Suchbaum handelt. Der Name AVL ist auf dem
Namen seiner Lagerbestände angegeben. Erwachsener Sohn fühlte sich schüchtern. Dann ist dies der erste
dynamisch ausgeglichene Baum , der jemals im APR-Baum
implementiert wurde. Jedem Knoten wird ein
Ausgleichsfaktor zugewiesen, basierend auf dem berechnet wird , ob der Baum
ausgeglichen ist oder nicht. Wenn Sie einen Baum haben, unterscheidet sich die
Höhe der Kinder des Knotens höchstens um einen. Der gültige Ausgleichsfaktor, wenn die Arterien 10 n minus eins sind. Wenn der neue Knoten
80 im AVL-Baum ist, wird der Eintrag unsymmetrisch, dann wird die
Rotation durchgeführt, um sicherzustellen , dass der Baum ausgeglichen bleibt. Die gängigen Operationen wie Intuition der
Nachschlageeinfügung
benötigen in diesem AVL-Baum nur logarithmisch viel
Zeit und werden häufig für
Nachschlagevorgänge verwendet. Es gibt auch einige Bäume , die als NRV-Bäume bezeichnet werden. Die maximale Anzahl von Kindern sie hier haben können, ist
auf diese Variable beschränkt n. Der
binäre Baum ist ein Baum, wie Sie in der binären
heutigen Datenstruktur der beiden
untergeordneten Bäume bezeichnen , finden
Sie dass die am
häufigsten bei der Präsentation von n. Aber vollständige NRA-Bäume, deren Kinder eines Knotens entweder 0 oder vollständiger
Enter Retreat ist der Baum, in dem alle Standardwerte
auf dem gleichen Niveau sind. Für einige Eigenschaften
von binären Bäumen. Noch ein paar mathematische
Eigenschaften. Wir können sagen, dass die maximale
Anzahl von Knoten auf Ebene l eines binären Baumes
zwei bis zur Stärke von l beträgt ,
dann wieder von
seiner Konstruktion die maximale Anzahl von Knoten
im binären Baum der Höhe h plus zwei zur
Macht von h minus eins. Im binären Baum mit n Knoten, minimale mögliche Höhe
oder minimale Anzahl von Cs Logarithmus der Basis
zwei von n plus eins. Lassen Sie uns einen binären
Baum mit LDFs machen,
der mindestens zwei l plus
eine Variablen hat . Auch im binären Baum, in dem
jeder Knoten zwei untergeordnete Elemente hat, beträgt
die Anzahl der
Blattknoten immer eins mehr als Knoten
mit zwei Kindern. Dies ist ein breiter Überblick über
die Baumdatenstruktur. Diese sind
bei Interviewfragen sehr nützlich. Ist das Kommen zu einem
komplexeren Thema, das hier diskutiert werden soll. Viele Menschen, die
ich
kenne , waren nicht
so kurz auf Bäumen. Aber in diesem Kurs werden wir uns einige
Übungen mit ihnen,
Traversals usw.
ansehen , damit Sie sich besser für
Ihr Programmierinterview bereit fühlen. Vor allem in Bezug auf diese
Datenstruktur. Dann haben zwei Probleme Menschen,
Menschen, die in der Vergangenheit
interviewt wurden. Lasst uns jetzt zur nächsten
Vorlesung übergehen.
18. Traversals: DFS, BFS: Hallo Leute. In dieser zweiten Vorlesung werden
wir über
Baumtraversalen sprechen, genauer gesagt über
binäre Baumtraversalen. Wie du schon gesehen hast. Im Gegensatz zu linearen Datenstrukturen die Arrays,
verknüpfte Listen, Warteschlangen,
Stapel usw. sind , die nur eine logische
Möglichkeit haben, sie zu durchqueren. Bäume können auf verschiedene Arten durchquert
werden. Folgenden werden die allgemein zum Durchqueren der Bäume
verwendet. Wir werden über die Tiefe zuerst über die
Durchquerung sprechen, diese Vorlesung, die in Ordnung ist, was bedeutet, dass wir zuerst nach links gehen, notieren, dann die Wurzel und dann zum rechten Knoten. Vorbestellung, wir besuchen
zuerst die Wurzel, dann das linke Kind
und das rechte Kind. Nehmen wir an, wir haben Postorder,
was bedeutet, dass wir zuerst nach links gehen , dann nach rechts gehen und dann
schließlich zur Wurzel gehen. Es gibt auch ESA, Breadth-First Traversal
oder Level-Order-Traversal, die im Grunde genommen die Notiz
in der Reihenfolge ihrer
Ebenen ihrer Schichten
druckt . Der Traversal-Algorithmus in Ordnung wäre, zuerst
den linken Teilbaum zu durchqueren und dann in der Reihenfolge für
den linken Unterbaum aufzurufen. Dann besuche die Wurzelsehne, durchquere den rechten Teilbaum und rufe dann
nach dem richtigen Unterbaum auf. Um eins, wieder
besuchten wir zuerst das linke Kind
und das rechte Kind. Verwendungen von in Ordnung. Im Falle von binären Suchbäumen. Um die Traversal zu erreichen, gibt es Knoten
in nicht abnehmender Reihenfolge. Um Knoten eines
binären Suchbaums zu erhalten Viertel der
Variation der Inorder-Traversal
nicht zunimmt. Inorder Traversal kann
leicht verwendet werden. Die Vororder-Traversal
ist dem in
Ordnung befindlichen ziemlich ähnlich , außer
der Art, wie wir Dinge tun. Also besuchten wir zuerst
das Wurzelende in Richtung des linken Unterbaums und nannten
Vorbestellung der Lippen. Leslie, wir durchqueren
den rechten Teilbaum. Vorbestellung. Postorder
Traversal würde zuerst
den linken Teilbaum durchqueren, die Postorder des linken Unterbaums aufrufen, dann den rechten
Unterbaum umkehren und die Postorder davon aufrufen. Und so würden wir die Wurzel
besuchen. Sie sehen, dass eine Vorbestellung darin besteht,
eine Kopie des Baumes zu erstellen. Es wird auch verwendet, um Präfixausdruck für
einen Ausdrucksbaum zu erhalten. Traversal nach der Bestellung würde verwendet
werden, um einen Baum zu löschen, würde auch verwendet, um
den Postfix-Ausdruck
einer Ausdrucksbehandlung zu erhalten . Wenn wir uns jetzt den Code
ansehen würden, würde dies diese Tiefe-erste Durchquerung bewirken. Als erstes, die Hauptfunktion, werden
wir die Wurzel deklarieren, notieren dies mit einer
Struktur, die Knoten genannt wird, und wir haben es nach oben deklariert. Wir haben einen integrierten
Host die Daten und dann zwei Zeiger auf die Typnotiz, die
linke und rechte Kinder sind. Und auch ein Konstruktor, der integrale Testdaten
aufnimmt dann die Kinder
dieser Knoten zu wissen initialisiert. Also würden wir sagen, durchgesickert
oder nicht definitiv, aber nur um
es zu merken, keine Kinder. Zuerst deklarieren wir eine Wurzel
und dann geben wir sie übrig. Und wissen Sie, wenn zwei
Bitratennotizen von drei sind, sind dies nur Fehler,
was bedeutet, dass keine zwei Fehler auftreten. Und dann links, links
haben wir einen Knoten mit dem Wert Fluor, obwohl
sie versucht haben, den Wert von fünf zu notieren. Genau hier würde
unser Baum aussehen. Und dann rufen wir Vorbestellung, In-Order und Post-Order dieser Funktionen ein
Argument auf, das ist der Wurzelknoten, zum Beispiel mit
der Post-Order. Beachten Sie nicht, dass
wir natürlich rekursiv
nach den linken Kindern,
dann nach den richtigen Kindern rufen , und dann würden wir die Daten
drucken. Was das tun würde,
ist, dass es rekursiv links
aufgerufen wird , bis es zum Blatt
ankommt. Dann kehrt es von der
Rekursion zurück und bringt ihn nach rechts. Dann endlich ein Wurzelwert. Dann haben Sie auch in Ordnung,
Vorbestellung bereits eingestellt. Nur der Unterschied, es besteht
nur ein Unterschied in der Folge dieser
Anweisungen. In Ordnung. Überprüfen Sie erneut, ob der Knoten nicht null
ist, denn wenn dies bedeutet, dass Sie den Baum bereits fertig sind oder keine Kinder vorhanden sind. Wir rufen dann rekursiv die
Funktion für den linken Knoten auf. Dann werden wir drucken und dann werden wir rekursiv nach dem Recht
aufrufen. Die Vorbestellung. Offensichtlich. Wir überprüfen noch einmal, müssen diese Nano wissen. Zuerst drucken wir und rufen dann
rekursiv weit links auf. Und dann, um über
die Komplexität
dieser Algorithmen zu sprechen die Komplexität
dieser Algorithmen , kommen Sie auf die Bühne. Für alle Probleme sind
eigentlich serverseitig ansprechende Volt, weil
grundsätzlich iterieren. Notiz. Und der Hilfsraum, wenn Sie die Größe
eines Zustands für Funktionsaufrufe nicht berücksichtigen , dann ist er konstant, wir gehen eins. Sonst wäre es ein lineares
großes O von n.
Sprechen wir nun über die Überquerung des
binären Baumes der Ebene, die Breite-erste
Traversal ist. Es gibt also verschiedene Methoden. Wir werden über
die Methode sprechen , die eine Funktion verwendet
, um eine bestimmte Ebene zu drucken. Auch
hier wird größtenteils versucht, die Anzahl der
Knoten in der Levelreihenfolge von
links nach rechts auf Levels zu drucken . Zum Beispiel wäre für den
letzten Baum, den wir gesehen haben, die Durchquerung der Levelordnung
dafür 12345. Der Algorithmus würde darin bestehen, zwei Funktionen
zu implementieren. Eine besteht darin, alle
Knoten auf einem bestimmten Level zu drucken, also geben wir ihnen einen Apfel. Die andere Funktion besteht darin, die Durchquerung der
Ebenenreihenfolge
des Baumes zu drucken . Levelreihenfolge macht Sie das
Drucken auf Ebenen, um
Notizen auf allen Ebenen einzeln zu drucken ,
beginnend mit der Wurzel Wir würden die erste Reihenfolge der
Druckebene von drei tun. Gehe aus einer Höhe des
Baumes und drucke diese Ebene aus. Durchlaufen Sie
alle Ebenen und
rufen Sie die angegebene Ebene drucken auf. Lassen Sie zwei Argumente nehmen, den Baum und diese
Ebene, und drucken Sie es aus. Die Druckfunktion, die angegebene Ebene
drucken. Wir prüfen, ob der Baum bekannt ist, dann würde er zurückkehren. Wenn das Level eins wäre, würde
es
auf die Welt bringen. Und es würde
rekursiv die
Ebene des rechten und linken
Baumes mit Stufe minus eins erhalten . Wie Sie genau hier sehen können, haben wir die Funktion erstellt, um
eine neue Knotenfunktion zu erstellen eine neue Knotenfunktion , die die
Höhe des Baumes zurückgibt. Die beiden Funktionen
, über die wir gesprochen haben. Wie gesagt,
nimmt die Funktion zur Reihenfolge der
Druckebene das Argument, die Wurzel. Dann berechnen wir mit der Höhenmethode die
Höhe des Baumes. Iterieren Sie während
der gesamten Höhe und bewältigen Sie die Stufe der Wurzel I, die Nummer des
Levels ist, auf dem wir uns derzeit befinden. Und rosa gegeben Level ist eine
Funktion, die das Level
und die Notiz prüft, ob
die Wurzel null ist. Wenn ja, wird es zurückkehren. Wenn der Level eins ist, wird der Root-Node ausgegeben. Denn wenn wir
auf der ersten Ebene sind, bedeutet das, dass wir an den Wurzeln sind, wir würden es einfach
rekursiv ausdrucken und alles nennen. Aber wenn wir uns auf einer niedrigeren Ebene befinden, bin
ich nicht die Root-Ebene, sondern Downloads, wir werden diese Funktion
rekursiv
für links und rechts aufrufen. Beachten Sie mit dem Level minus eins. Daher der zweite Parameter. Also denke ich, dass das
ziemlich einfach ist. Auch hier können Sie für
den Baum sehen, den wir auf dem Bildschirm
gezeigt haben, dass die
Durchquerung der Levelreihenfolge 12345 ist, die wir bereits herausgefunden haben. Wieder hier. Die Komplexität für diesen
Algorithmus ist linear. In Bezug auf die
Zeitkomplexität groß O von n, da wir alle
Knoten einmal rekursiv durchlaufen, ist
DC so ziemlich die Möglichkeit, den binären Suchbaum zu durchqueren. Und sie sind sehr nützlich
zu wissen, weil sie dir mehr
Morbidität in einem Baum
geben werden . Und sie werden Ihre Verkäufe
sicherstellen wenn sie sich mit drei
Fragen in einem Programmiergespräch befassen. Lasst uns nun
zum nächsten Vektor übergehen.
19. Suche nach sum: Hallo Leute und willkommen
zurück zu diesem Kurs. In dieser Vorlesung werden
wir über
die drei Probleme sprechen , die manchmal in einer
Interviewfrage auftreten
können. Das heißt, nach
Kindern eine Eigenschaft
im binären Baum zu suchen . Das bedeutet, dass
Sie
bei einem binären Baum eine Funktion schreiben sollten, die true zurückgibt, wenn der Baum die Eigenschaft
erfüllt,
dass der
Datenwert für jeden Knoten gleich der
Summe von Theta sein muss , die in
links verwendet wird und richtige Kinder. Betrachten Sie, dass Datenwert 0 ist. Vorerst Kinder. Zum Beispiel. Wenn wir einen Baum hätten
, der die Wurzel hätte, wären die linken Kinder acht und die richtigen
Kinder wären zwei. Das wäre ein gültiger Baum. Und so weiter unten, wenn dieses Kind zwei Kinder haben
muss, also versuchen Sie die linke Hand zumindest, dass ihre Daten in einigen acht
sein sollten, und so weiter für den gesamten Baum. Der Algorithmus, den wir uns hier nähern, besteht darin, den gegebenen binären Baum zu
durchqueren. Und für jeden Knoten sollten
wir rekursiv prüfen, ob der Knoten, dann sagten diese
beiden Kinder, von
den Kindern eine Eigenschaft ist . Wenn ja, dann gibt true
else false zurück. Das ist ziemlich einfach. Lassen Sie uns nicht in
den Code einspringen und sehen, wie wir das auf einer
spezifischeren technischen Ebene tun
können. In Ordnung, hier haben wir
bereits
ein paar Dinge erklärt , die uns
bei der
Implementierung des Baumes helfen würden . Also haben wir eine
Struktur deklariert, die Knoten ist. Und dann erklärten wir, dass ein ganzer Baum eine
Eigenschaft von root zwei ist. Dann werden wir drucken , dass die Bedingung
erfüllt ist, sonst falsch. Also werden
wir im Grunde
eine Funktion implementieren , die
East einige Eigenschaften genannt wird. Es nimmt den Parameter den
Wurzelknoten und gibt eine Ganzzahl zurück, die genauso gut ein boolescher Wert
gewesen sein könnte, denn wenn
Sie entweder 0 oder eins zurückgeben dann in diese Funktion springen, wir erklären zwei
Variablen als Hilfsvariablen , die uns helfen werden, uns die rechten
und linken Werte der untergeordneten
Elemente des Knotens zu
merken , die wir derzeit
mit der Iteration befinden. Dann wenn der Knoten, dass wir
ehrlich sind oder seine Kinder oder nein sind, dann werden wir einen zurückgeben. Weil das bedeutet, dass wir das Ende
erreicht haben und es ist okay, weil alles bis zu diesem Zeitpunkt überprüft wurde , um wahr zu sein. Andernfalls werden Sie auch
feststellen, dass die meisten
dieser Algorithmen mit
dem Basisfall dieser
Baumalgorithmen beginnen . Erstens, unser rekursiv und zweitens, beginnen Sie mit dem Basisfall, also dem Endfall. Nun, wir haben hier mehrere
Szenarien. Wenn der linke Knoten nicht null ist, die Daten darin,
also die Zahl, werden die Daten darin,
also die Zahl, die er
enthält, dem linken Beta-Integral gegeben , das wir hier deklariert haben. Dann werden
wir wieder für den richtigen Knoten dasselbe tun. Und dann werden wir prüfen,
ob die Knotendaten, also ist die Zahl, die der
Knoten, den wir gerade mit der Iteration der Summe der
linken und rechten Kinder
entspricht. Und auch rekursiv
die gleiche Funktion für den
linken Knoten und den rechten Knoten genannt . Wir werden
das Gleiche rekursiv für beide Kinder
des Knotens überprüfen . Dann werden wir
einen zurückgeben, was bedeutet, dass es wahr ist. Und unsere drei Nullen, mit dieser Bedingung
, die wir überprüfen, werden wir
sonst 0 zurückgeben. Was das bedeutet, ist rekursiv mit dem Kostenstapel
aufzurufen. Und wenn es
vom Call-Stack zurückkehrt, wird
es diesen treffen. Wenn alle ECM-Eigenschaften true
zurückgeben, wie Sie hier
mit den End-Anweisungen sehen können, müssen
alle wahr sein, damit diese if-Anweisung
auschecken und zurückgibt. Auf diese Weise werden wir
diesen Zustand im gesamten
Baum mit einer
rekursiven Funktion überprüfen diesen Zustand im gesamten . Sprechen Sie jetzt über die
Komplexität dieses Algorithmus, wie Sie in
fast allen Baumalgorithmen sehen werden . Linear aus
Zeitsicht und konstant von diesem Basispunkt aus haben wir nur zwei Integrale
deklariert. Aber aus der Sicht durchlaufen Sie den gesamten Baum. Das ist also lineares großes O von n. Vielen Dank, dass ihr in diesem Tutorial mit
mir am Ende
geblieben seid und
wir sehen uns im nächsten.
20. Summe aller Knotenpunkte: Hallo Leute und willkommen
zurück zu diesem Kurs. In dieser Vorlesung werden wir
über ein anderes Baumproblem sprechen. Lassen Sie uns sie manchmal bei der
Berechnung der Summe aller
Knoten in einem binären Baum geben. Ich denke, der Titel ist
ziemlich selbsterklärend. Was Sie tun müssen, wenn Sie dieses
Problem haben, ist,
einen Algorithmus zur Ermittlung
der Summe aller Elemente
im binären Baum bereitzustellen einen Algorithmus zur Ermittlung . Grundsätzlich müssen Sie alle Integrale
zusammenfassen , die von
allen Knoten in einem binären
Baum gehalten werden , der Ihnen gegeben wird. Wie üblich werden wir uns
diesem Algorithmus mit Rekursion nähern diesem Algorithmus mit Rekursion wie wir es normalerweise
bei drei Problemen tun. Schauen wir uns den Code an , um zu sehen, wie wir dieses Problem
machen würden. Wir haben eine Struktur erklärt. Beachten Sie, dass er
Induktor hält, ist der Schlüssel und auch die linke und
rechte des Knotens, die beibehalten werden. Indem Sie ihnen einen Zeiger
auf die Knotenstruktur geben. Wir haben genau hier einen Baum gezeichnet. Und dann haben wir von einem
Integral deklariert und ihm unseren Funktionsaufruf
zugewiesen , der das Integral
zurückgeben soll. Integral ist die Summe
aller Knoten im gegebenen Baum, nur
T Parameter, den
diese Funktion annimmt, ist der
Wurzelknoten unseres Baums. Zeiger auf den Knoten. Offensichtlich. Es sieht so aus, als ob root null ist, dann sollten wir 0 zurückgeben. Wie in drei
Rekursionsalgorithmen und -methoden üblich, beginnen
wir mit dem Basisfall, was passiert, wenn
der Boden diese Wärme aufruft? Wenn root nein ist, erreichten
wir das Ende. Es gibt also keine Notiz mehr , weil wir
diese Funktion rekursiv aufrufen , bis
uns die Knoten ausgehen. Wenn das nicht der Fall ist. Wenn wir also keine Route erreicht haben, sollten
wir den Stammschlüssel zurückgeben,
was bedeutet, dass der Wert, den die Root innerhalb des behält, weil
Sie die Struktur sehen können.
Der Schlüssel ist der integrierte, den
dieser Knoten enthält. Wir fügen auch den
rekursiven Verlauf
dieser Funktion für das linke
und rechte Kind der Wurzel hinzu,
was bedeutet, dass wir uns darauf befinden. Der aktuelle Anruf, natürlich rekursiv das Gericht, wird für die linken Kinder
aufgerufen. Und dann
wurde die Hinrichtung ohne Rückkehr begonnen. 0 IS gibt seinen Wert zurück und ruft
dann erneut rekursiv für jeden von ihnen auf. Ich glaube, du hast verstanden,
wie das läuft. Jetzt sprechen wir von der
Komplexität dieser gepackten Reihe. Nun, die Zeitkomplexität
ist linear, da wir durch
den gesamten Baum
iterieren,
ziemlich intuitiv ist , dass wir jeden Knoten durchlaufen
müssen, damit wir
herausfinden können , welchen Wert er uns selbst treu ist
. Und dann ist die Platzkomplexität konstant, da wir keine anderen Elemente als
die
verkauften Standards von Carsten
deklarieren anderen Elemente als , aber es ist ein großes O von eins. Danke Leute, und wir werden
uns in der nächsten Vorlesung sehen .
21. Vergewissere dich, ob alle leaves auf der gleichen Ebene liegen: Hallo Leute und willkommen
zurück zu diesem Kurs. In diesem Vortrag
werden wir über
weitere drei Probleme sprechen , die in eine
Interviewumgebung gebracht werden
könnten. Das heißt, um zu überprüfen, ob alle Blätter in einem Baum auf dem
gleichen Niveau sind. Bei diesem Problem werden wir Sie bitten, einen binären Baum
zu geben, Sie müssen nur überprüfen,
ob alle Knoten verlässt, also die Knoten, die
keine Kinder haben. Diejenigen, die sich
auf der unteren Ebene befinden, auf derselben Ebene oder nicht, stellen sich
im Grunde vor, dass die
Wurzel auf Ebene eins ist, unmittelbare Kinder
auf Stufe zwei sind und so weiter. Bis Sie die Leaf Level gefunden haben, es üblich ist, werden wir uns
diesem Algorithmus mithilfe von Rekursion nähern . Nun besteht die Idee darin, zuerst die
Ebene des obersten linken Blattes zu finden und es in einer Variablen zu speichern. Und wir werden diese Variable verwenden. Vergleichen Sie dann das Niveau aller
anderen Blätter mit dem Schuldenniveau. Wenn es das Gleiche ist,
kehren wir zurück, um sonst falsch zu enden. Wir durchqueren den gegebenen binären
Baum in einer Vorbestellung. Das Niveau, das wir im Auge behalten, werden
wir am besten für alle
Anrufe als Argument sein. Der Wert dieses
Arguments wird in einer anderen Funktion
mit 0 initialisiert ,
um anzuzeigen, dass erstens, wenn er noch nicht gesehen wird, Wert
erstens, wenn er noch nicht gesehen wird,
in der Ebene liegt. Finden Sie zuerst ein Blatt oder eine Ebene
nachfolgender Blätter in Vorbestellung wird mit diesem Level-Argument verglichen
. Werfen wir einen
Blick auf den Code. Wir haben die Knotenstruktur
und den Konstruktor dafür deklariert . Und in der Hauptfunktion, drei für uns
konstruiert. Und dann haben wir eine
Funktion, die
Check genannt wird , die die
Wurzel unseres Baumes nimmt. Und was es tut, ist, dass es
Level in Leaf mit
0 initialisiert und den
Code zu dieser Prüfung zurückgibt, eine Funktion, die die Wurzel unseres Baumes,
dann die Ebene und die
Blattebene als
Parameter dann die Ebene und die
Blattebene verwendet die beide mit 0
initialisiert werden. Wie Sie in dieser
Überprüfung bis zur Funktion sehen können. Der Basisfall ist, wenn wir eine Wurzel
haben, das ist jetzt. Und dann sollten wir wahr zurückkehren. Dann sind die Kinder
des Knotens, den wir
gerade sind, beide null. Es bedeutet, dass wir an einem Blattknoten
angekommen sind. Und dann prüfen wir, ob es
das erste Mal ist , wenn wir am Leaf-Knoten
ankommen. Wie wir das machen, ist zu
prüfen, ob die Blattebene 0 ist, wie Sie hier sehen können, er wird als Referenz
übergeben, sodass der Wert davon erhalten bleibt. Derjenige, wenn wir
das Leaf Level nennen, ist 0. Es bedeutet, dass es
das erste Mal , dass wir auf ein Blatt stoßen, wir weisen dieser Blattebene zu, die Ebene, auf der wir uns gerade
befinden. Wenn wir diese if-Anweisung nicht
eingeben, geben
wir außerdem Level zurück, der der Blattebene
entspricht. Was das bedeutet, ist, dass
wir direkt am Blatt sind. Was ist jetzt der Erste, wenn
wir Recht haben, sollten wir
zurückgeben, ob das Level
gleich der Blattebene ist. Die Blatthöhe ist das tatsächliche Niveau des
ersten Blattes, auf dem wir angekommen sind. Alle unsere Blätter müssen auf dem gleichen Niveau
sein. Deshalb behalten wir
diese Variable genau hier im Hinterkopf. Wenn wir dann diese if-Anweisung beenden,
was bedeutet, wenn es kein
Blatt ist,
in dem wir uns befinden , geben wir rekursive Aufrufe dieser Funktion für den linken und rechten Knoten zurück. Weil wir
gerade am Knoten sind , ist das kein Leaf und Xist,
was bedeutet, dass wir uns
an einem Elternknoten befinden. Wir müssen
diese Funktion für beide
Kinder rekursiv aufrufen und
das Level erhöhen. Unter
Berücksichtigung der Blatthöhe ist
es auch die unterste Ebene des ersten Blattes, ist
es auch die unterste Ebene des dem wir
je begegnet sind. Wie ich bereits sagte, werde
ich das betonen. Schon wieder. Wir erinnern uns an
diese Schulden auf Blattniveau,
die Höhe des ersten Blattes
, dem wir begegnet sind. Und das ist die Referenz
, die wir überprüfen werden. Darüber hinaus werden Inode-nächste
Blätter, denen wir wegen der Komplexität
dieses Algorithmus
begegnen werden . Auch hier ist die
Raumkomplexität konstant. Dadurch nutzen wir keinen
zusätzlichen Speicherplatz größer von einem. Und dann ist die
Zeitkomplexität linear. Während wir den gesamten
Baum durchqueren, um zuerst
die Höhe des ersten Blattes zu finden und dann alle
anderen Blätter so
zu überprüfen , dass sie auf dem ersten Blatt,
dem wir begegnen
, das gleiche Niveau haben . Vielen Dank, dass ihr euch
dieses Tutorial angeschaut habt und wir sehen uns
im nächsten Abschnitt.
22. Das Problem mit ausgewogenen Klammern: Hallo Leute und willkommen
zurück zu diesem Kurs. In diesem Vortrag werden
wir über
das Problem sprechen , das sehr oft in einer
Interviewfrage gegeben wird. Das heißt, mit einem Stapel nach
ausgeglichenen Klammern
in einem Ausdruck zu suchen . Nun, das ist mit einem Stack erledigt, aber der Interviewer handelt
möglicherweise nicht. Du hast dieses Problem erledigt, wenn du das heute Abend
benutzt
hast, hast du das selbst herausgefunden. Das Problem gibt dir eine Zeichenfolge. Das ist ein Ausdruck, und Sie
müssen ein Programm schreiben, um zu untersuchen, ob
die Paare und die Reihenfolge der Klammern, in diesem Ausdruck
korrekt sind, die Klammern
derzeit normal oder quadratisch sein können. Zum Beispiel werde ich
jetzt zwei verschiedene Eingänge auf den Bildschirm
legen . Sie können also sehen, dass
der erste
ausgeglichen ist und der
zweite nicht. Sie können
die eckige Klammer schließen,
bevor Sie die normale da es nicht
die natürliche Reihenfolge gibt. Was der Algorithmus wäre,
um uns Deck zu deklarieren, das
Zeichen enthält, und dann
den Ausdruck zu durchqueren , dass
Sie diese Zeichenfolge erhalten, im Grunde durchlaufen. In Dendrit zwei Szenarien. Erstens, wenn das aktuelle
Zeichen, das Sie in
diesem Moment
durchlaufen , die Klammer
startet, normale Klammer starten, geschweifte Klammer starten oder die
quadratische Klammer starten, dann können Sie
es auf dieses Deck. Das zweite Szenario ist wenn die aktuelle Klammer
, in der Sie
sich gerade mit Iteration befinden , eine schließende Klammer
ist. Wieder eine schließende
normale Klammern, eckige Klammer
schließen, geschweifte Klammer schließen. Dann komm von diesem Deck. Im Moment pumpen Sie das obere Element
und Sie werden sehen
, was die
letzte offene Klammer ist. Und wenn der Pop-Charakter, also die letzte offene Klammer
die passende
Startklammer ist , dann ist es in Ordnung. Die Klammern sind nicht ausgeglichen. also nach dem vollständigen Traversal eine
Startklammer gibt, Wenn es also nach dem vollständigen Traversal eine
Startklammer gibt, die dieses Deck
zulässt, ist es nicht ausgeglichen, weil
in unserer Saite
geöffnete Klammern vorhanden sind, die ich nicht nahe
am Ende des Ausdruck. Schauen wir uns die
Codes schnell an. Wir haben eine Hauptfunktion
und lesen
einen Ausdruck ausüben , der
wie das Starten der geschweiften Klammer, Starten der geschweiften Klammer, das
Starten der normalen Klammer, Ende der normalen Klammer
und die geschweifte Klammer aussieht. Das ist also okay. Dann beginne die quadratische Klammer und
endet die quadratische Klammer. Dies sollte ein ausgeglichener
Ausdruck sein, da es keine Klammern gibt, die
in der falschen Reihenfolge gelassen und geöffnet oder geschlossen werden. Jetzt haben wir eine Funktion namens, wir deklarieren die Funktion, die unsere Klammern als Balanced
bezeichnet , dass wir sehen werden, dass sie einen Parameter
hat, diese Zeichenfolge. Wir deklarieren einen Stack, da wir bereits erklärt ,
warum das den
Daten-Char enthält. Dann deklarieren wir ein
Hilfsdiagramm namens X. Für int i von 0 bis zur
Länge des Ausdrucks. Wir iterieren im Grunde
mit dieser Schleife jedes Zeichen des angegebenen
Ausdrucks. Wir nehmen jedes Zeichen
nacheinander und überprüfen, welche Art
von Klammer diese sind. Zuerst müssen wir sehen, ob diese Klammer
derzeit im Quadrat steht, normal ist und mit Typ eins
beginnt. Wenn ja, können wir es in
unseren Stack schieben und dann fahren
wir fort, da wir mit dem Rest
der Loop-Ausführung nicht
weitermachen müssen . Andernfalls können
wir prüfen, ob der
Stapel leer ist, wenn die Klammer
nicht startet . Und wenn der Stapel leer ist, sollten
wir false zurückgeben. Weil es bedeutet, dass es
sich um eine schließende Klammer handelt. Ist es nicht möglich Klammer zu
starten, denn
wenn es gewesen wäre, wäre
die Ausführung nicht
genau hier, im Moment. Es ist eine schließende Klammer
und der Stapel ist leer. Was heißt das? Das bedeutet, dass wir
zu einer schließenden Klammer gekommen sind , die keine übereinstimmende
Startklammer davor hat. Es ist also kein gültiger
Ausdruck von Klammern. Wenn das nicht der Fall ist, haben
wir eine Switch-Anweisung, die
auf dem Charakter basiert , den wir
gerade in unserem Ausdruck haben. Wir haben also verschiedene Fälle. Der Fall, wenn unser Charakter eine schließende normale Klammer
ist, werden
wir es tun. In unserem Hilfszeichen x der obere Teil des Stapels. Und dann werden wir die Spitze des Stapels platzieren, da
wir ihn nicht mehr brauchen. Und dann werden wir den Wert überprüfen,
der darin enthalten war. Wenn der Wert, der gesehen wurde, handelte
es sich um eine geschweifte Startklammer oder eine quadratische Startklammer. Dann sollten wir
false zurückgeben, wenn wir zu
einer normalen Endklammer kamen und eine offene Liste auflisten,
also ist die übereinstimmende Klammer
nicht der gleiche Typ wie EDs. Und dann sollten wir kaputt gehen. In den anderen Fällen, wenn es sich um eine geschweifte
Klammer handelt, die endet,
ist die anfängliche
passende Klammer in Ordnung. Die anderen beiden Typen, es ist nicht okay, also
sollten wir falsch zurückgeben. Dann nochmal, wenn es sich um eine quadratische
Endklammer handelt und passende Klammer normal oder geschweift
ist. Auch hier ist es kein
gültiger Ausdruck, also sollten wir
false zurückgeben und dann break. Das gleiche Verfahren gilt auch, bei dem wir
unseren
Hilfscharakter die Spitze
des Stapels einsetzen unseren
Hilfscharakter die Spitze
des und dann platzieren wir ihn. Wenn wir mit
der Iteration fertig sind , sollte unser
Stack leer sein. Es sollte also keine
Klammern mehr geöffnet sein, da das bedeutet, dass sie keine passenden
Endklammern haben. Wenn der Stack geleert wird
, bedeutet das, dass alle Märkte
übereinstimmen. Und der Ausdruck ist gültig. Wenn die Zeichenfolge
am Ende der Ausführung nicht leer ist, bedeutet dies, dass einige Elemente darin enthalten
sind. Und wie Sie bereits gesehen
haben, drücken wir nur
Starttypen von Klammern ein. Und das bedeutet, dass
darin
Startklammern übrig sind , die
keine übereinstimmenden Endklammern haben. Und das bedeutet, dass dies
kein gültiger Ausdruck ist. Diese Funktion wird also
in einer if-Anweisung aufgerufen. Wenn diese Funktion also genau hier
ist,
was bedeutet, dass diese Funktion true zurückgibt, können
wir zurückgeben, dass
der Ausdruck, wir erhalten, ein
ausgeglichener Ausdruck ist. Sonst ist es nicht ausgeglichen. Wie Sie sehen können,
Wissensbeispiel, wenn wir den Code ausführen, können
Sie sehen, dass
er ausgeglichen ist, also ist es ausgeglichener Ausdruck. Sprechen wir nun über die
Komplexität dieses Algorithmus. Die Komplexität dieses Algorithmus aus einer Zeitsicht, dieser linear, wenn wir unseren
Ausdruck einmal durchlaufen. Das ist also großes O von n. Jetzt ist die Raumkomplexität
auch linear, da wir
einen Stapel deklariert haben , der so
viel wie die gesamte Zeichenfolge halten kann. Im schlimmsten Fall, in dem die Zeichenfolge
auf Startklammern enthalten ist. Sie können dies effizienter machen , wo
Sie sich nicht einmal
an dieses Deck erinnern. Und statt dieses Decks kannst
du dich an einige Zahlen erinnern. Zum Beispiel einige Variablen,
die Sie inkrementieren, wenn Sie eine Startklammer und ein Dekrement
treffen, wenn Sie eine Endklammer treffen. Das ist eine fortschrittlichere Lösung. Vielleicht versuchen Sie es zu
Hause oder suchen Sie danach. Aber die grundlegende Lösung
für diese Probleme, dieses und dieses
sollten Sie wirklich auswendig verstehen
und kennen. Aber danke, dass du bis zum Ende
bei diesem Tutorial geblieben bist. Wir sehen uns das nächste Mal.