Binäre Suchalgorithmus, Interview-Kuchen
Ein binärer Suchalgorithmus findet ein Element in einem sortierten Array in der Zeit.
Eine Brute-Force-Suche würde zu Fuß durch die ganze Reihe. Zeit im schlimmsten Fall nehmen.
Lassen Sie uns sagen, dass wir eine sortierte Reihe von Zahlen haben. Um eine Zahl mit einer binären Suche finden wir:
- Beginnen Sie mit der mittleren Zahl: ist es größer oder kleiner als unsere Zielnummer? Da das Array sortiert ist, das sagt uns, wenn das Ziel in der linken Hälfte oder der rechten Hälfte unserer Reihe sein würde.
- Wir haben geteilt effektiv das Problem in zwei Hälften. Wir können „ausschließen“ die ganze Hälfte des Feldes, die wir kennen nicht die Zielnummer enthalten.
- Wiederholen Sie den gleichen Ansatz (von der Mitte ausgehend) auf das neue Halb Größe Problem. Dann tun Sie es wieder und wieder, bis wir entweder die Zahl oder „ausschließen“ den ganzen Satz finden.
Wir können dies tun rekursiv oder iterativ. Hier ist eine iterative Version:
public static boolean binarysearch (int Ziel, int [] nums) < // see if target appears in nums // we think of floorIndex and ceilingIndex as "walls" around // the possible positions of our target, so by -1 below we mean // to start our wall "to the left" of the 0th index // (we *don't* mean "the last index") int floorIndex = -1; int ceilingIndex = nums.length; // if there isn't at least 1 index between floor and ceiling, // we've run out of guesses and the number must not be present while (floorIndex + 1 < ceilingIndex) < // find the index
auf halber Strecke zwischen Boden und Decke // verwenden wir Integer-Division, so dass wir nie einen „halben Index“ int Abstand = ceilingIndex erhalten - floorIndex; int halfDistance = Abstand / 2; int guessIndex = floorIndex + halfDistance; int guessValue = nums [guessIndex]; if (guessValue == Ziel) < return true; > if (guessValue> target) < // target is to the left, so move ceiling to the left ceilingIndex = guessIndex; > sonst < // target is to the right, so move floor to the right floorIndex = guessIndex; > > Return false; >
Wie wussten wir die Zeit, Kosten für die binäre Suche war? Der einzige nicht-ständige Teil unserer Zeitkosten ist die Anzahl, wie oft unsere while-Schleife läuft. Jeder Schritt unserer while-Schleife schneidet den Bereich (diktiert durch floorIndex und ceilingIndex) in der Hälfte, bis unser Angebot nur ein Element übrig bleiben.
Die Frage ist also, „wie oft müssen wir unsere ursprüngliche Array-Größe (n) in zwei Hälften teilen, bis wir bis hinunter zu 1 bekommen?“
Wie viele \ frac ‚s gibt es? Wir wissen noch nicht, aber wir können die Zahl x nennen.
Jetzt sind wir für x lösen.
Nun, um die x aus dem Exponenten zu erhalten. Wie machen wir das? Logarithmen.
Daran erinnern, dass \ log_ Mittel „welche Macht müssen wir 10 erhöhen, um auf 100 zu bekommen?“ Die Antwort ist 2.
Also in diesem Fall, wenn wir die \ log_ von beiden Seiten nehmen.
Die rechte Seite fragt: „Welche Kraft müssen wir 2, erhöhen 2 zu bekommen ^ x?“ Nun, das ist nur x.
Also da ist es. Die Anzahl der Male müssen wir teilen n in der Hälfte erhalten bis zu 1 log_n wird. So ist unsere Gesamtzeit Kosten
Achtung: wir können nur binäre Suche verwenden, wenn die Eingabe-Array bereits sortiert ist.
Pass-Interviews mit meinem freien 7-Tages-Crash-Kurs
Ich werde Ihnen den richtigen Weg für Denk lehre heikel algorithmische Codierung Interviewfragen brechen Sie noch nie gesehen haben.
Eine vorherige Informatik Ausbildung erforderlich-ich werde Sie schnell beschleunigen aufstehen, alle allzu akademische Sachen zu überspringen.
Kein Spam. Ein-Klick abmelden, wenn Sie es hassen.
Du bist in! Gehen Sie zu Ihrem E-Mail-Posteingang jetzt 1 Tag zu lesen!