Binäre Suche

aus Wikipedia, der freien Enzyklopädie
Wechseln zu: Navigation, Suche

Die binäre Suche ist ein Algorithmus, der auf einem Feld (also meist „in einer Liste“) sehr effizient ein gesuchtes Element findet bzw. eine zuverlässige Aussage über das Fehlen dieses Elementes liefert. Voraussetzung ist, dass die Elemente in dem Feld entsprechend einer totalen Ordnungsrelation angeordnet („sortiert“) sind. Der Algorithmus basiert auf einer einfachen Form des Schemas Teile und Herrsche, zugleich stellt er auch einen Greedy-Algorithmus dar. Ordnung und spätere Suche müssen sich auf denselben Schlüssel beziehen.

Algorithmus[Bearbeiten]

Zuerst wird das mittlere Element des Felds überprüft. Es kann kleiner, größer oder gleich dem gesuchten Element sein. Ist es kleiner als das gesuchte Element, muss das gesuchte Element in der hinteren Hälfte stecken, falls es sich dort überhaupt befindet. Ist es hingegen größer, muss nur in der vorderen Hälfte weitergesucht werden. Die jeweils andere Hälfte muss nicht mehr betrachtet werden. Ist es gleich dem gesuchten Element, ist die Suche beendet.

Gesucht ist das Element mit dem Schlüssel G.
(Indizes und Rechnungen in grün; \ ganzzahlige Division.)

In der zu untersuchenden Hälfte (und erneut in den folgenden Hälften) wird genauso verfahren: Das mittlere Element liefert wieder die Entscheidung darüber, ob und wo weitergesucht werden muss. Die Länge des Suchbereiches wird so von Schritt zu Schritt halbiert. Spätestens wenn der Suchbereich auf ein einzelnes Element geschrumpft ist, ist die Suche beendet. Dieses eine Element ist entweder das gesuchte Element, oder das gesuchte Element kommt nicht vor.

Der Algorithmus zur binären Suche wird entweder als Iteration oder Rekursion implementiert. Um ihn verwenden zu können, müssen die Daten bereits sortiert und in einer Datenstruktur vorliegen, in der „direkt“ auf das n-te Element zugegriffen werden kann. Auf einer einfachen verketteten Liste würde die Effizienz verloren gehen (siehe aber Skip-Liste).

Komplexität[Bearbeiten]

Um in einem Feld mit n Einträgen ein Element zu finden bzw. festzustellen, dass dieses sich nicht im Feld befindet, werden maximal \lceil \log_2 n \rceil Schritte benötigt. Somit liegt die binäre Suche, in der Landau-Notation ausgedrückt, in der Komplexitätsklasse O(\log\ n). Damit ist sie deutlich schneller als die lineare Suche, welche allerdings den Vorteil hat, auch in unsortierten Feldern zu funktionieren. In Spezialfällen kann die Interpolationssuche schneller sein als die binäre Suche.

Erwartungswert der Komplexität[Bearbeiten]

In einer Suchmenge aus 2^n Elementen geht jeder Schritt mit der Zweiteilung der Suchmenge einher. Die Wahrscheinlichkeit das Suchargument aus einer Menge von 2^{n-k} Elementen zu finden ist dann \frac 1 {2^{n-k+1}}. Ist man durch sukzessive Halbierung der Suchmenge am letzten Element angelangt, braucht man immer noch eine weitere Abfrage, also einen weiteren Schritt, um festzustellen ob dies das Suchargument ist. Insgesamt ist dann die Wahrscheinlichkeit für das Ereignis \omega_k, das Suchargument erst im k-ten Schritt zu finden:

P(\omega_1) = \frac 1 {2^n}
P(\omega_k) = \prod_ {i = 0}^{k-2}  (1 - \frac 1 {2^{n-i}})\frac 1 {2^{n-k+1}}; 2 \le k\le {n+1}.

Die Komplexität C(N) als Anzahl der benötigten Schritte bis zum Abbruch der Suche in einer Menge aus N Elementen ist eine Zufallsvariable X mit P(X(\omega_k)= k) = P(\omega_k) und für deren Erwartungswert gilt:

\sum_{k=1}^{n+1} {kP(X(\omega_k)= k)} = \frac 1 {2^n} + \sum_{k=2}^{n+1}\prod_{i=0}^{k-2} 
(1 - \frac 1 {2^{n-i}})\frac k {2^{n-k+1}} \le \sum_{k=1}^{n+1} \frac {k} 
{2^{n-k+1}} = \frac 1 2 \sum_{k=1}^{n+1} \frac {k} {2^{n-k}} = \frac 1 {2^{n+1}} 
\sum_{k=1}^{n+1}k2^k.

Daraus folgt für N \le 2^n (s. auch Reihe (Mathematik))

Erwartungswert von C(N) \le \sum_{k=1}^{n+1} {kP(X(\omega_k)= k)} \le \frac 1 {2^{n+1}} (n{2^{n+2}} + 2) = 2n + \frac 1 {2^n} und somit wieder von der Komplexitätsklasse O(\log\ n).

Ähnliche Verfahren und Varianten[Bearbeiten]

Intervallschachtelung[Bearbeiten]

Hauptartikel: Intervallschachtelung

Das hier beschriebene binäre Suchverfahren kann als eine (endliche) Ausprägung der Intervallschachtelung aus der mathematischen Analysis angesehen werden.

Binärer Suchbaum[Bearbeiten]

Hauptartikel: Binärer Suchbaum

Der Such-Algorithmus entspricht auch der Suche in einem binären Suchbaum, wenn man das Array als solchen interpretiert: das mittlere Element ist die Wurzel, die Mitten der so entstehenden Hälften die Wurzeln der entsprechenden Teilbäume und so fort. Der aus dieser Interpretation resultierende Binärbaum ist sogar balanciert. Teilt man nicht in der Mitte, so ist das Ergebnis immer noch ein binärer Suchbaum, jedoch ist er u. U. nicht mehr balanciert.

Die große Überlegenheit des binären Suchbaums gegenüber der binären Suche im Array liegt erstens im besseren Verhalten bei Einfügungen und Löschungen, bei denen im Mittel ein linearer Aufwand anfällt. Bei Bäumen gibt es auch in diesen Fällen Implementierungen mit garantiert logarithmischer Laufzeit. Dort ist auch die Speicherverwaltung einfacher, da Änderungen nicht das ganze Array betreffen, sondern sich mit dem Entstehen oder Verschwinden eines Elementes direkt verbinden lassen. Zweitens können Bäume besser als das Array an Häufigkeiten angepasst werden. Wenn aber das Array schon fertig sortiert ist und sich dann nicht mehr ändert und Zugriffswahrscheinlichkeiten keine Rolle spielen sollen, ist das Array ein gutes Verfahren.

Binäre Suche und totale Quasiordnung[Bearbeiten]

Da das Array als endlicher Definitionsbereich einer Funktion angesehen werden kann, die natürlich nicht notwendigerweise injektiv sein muss, lässt sich das Vorkommen von Duplikaten leicht über die Funktionswerte regeln. Und wenn die Ordnungsrelation von vornherein schon keine Totalordnung, sondern nur eine totale Quasiordnung ist, ist es ggf. sparsamer, die Äquivalenzklassen vor dem Vergleichen zu bilden, als alle möglichen Duplikate im Array zu halten.

Beispiel

In einer Sammlung von Schlüsselwörtern soll zwar Groß- und Kleinschreibung zulässig sein, die Schlüsselwörter sollen sich aber in ihrer Bedeutung nicht unterscheiden.

Interpolationssuche[Bearbeiten]

Hauptartikel: Interpolationssuche

Bei der Interpolationssuche wird das Array nicht mittig geteilt, sondern per linearer Interpolation die Position des gesuchten Elementes abgeschätzt. Sind die Schlüssel in etwa äquidistant verteilt, so kann das gesuchte Element in nahezu konstanter Zeit gefunden werden. In einem ungünstigen Fall wird die Laufzeit jedoch linear. Abgesehen davon muss der Definitionsbereich sich für eine lineare Interpolation eignen.

Quadratische Binärsuche[Bearbeiten]

Hauptartikel: Quadratische Binärsuche

Bei der quadratischen Binärsuche versucht man die Vorteile der Interpolationssuche mit denen der normalen Binärsuche zu kombinieren und mittels Interpolation in jeder Iteration den Suchraum auf ein Intervall der Länge \sqrt n zu verkleinern.

Verschiedene Implementierungen[Bearbeiten]

In zahlreichen Programmiersprachen ist dieser Algorithmus in den Klassenbibliotheken verfügbar. In Java beispielsweise als java.util.Arrays.binarySearch und java.util.Collections.binarySearch, in Python als das Paket bisect und in C++/STL als std::binary_search im "algorithms" header.

Als Rückgabewert wird die Feldposition zurückgegeben, an der der gesuchte Eintrag gefunden wurde. Konnte der Eintrag nicht gefunden werden, wird meist die Position zurückgegeben, an der er stehen müsste, jedoch z.B. negativ - als Hinweis auf „wurde nicht gefunden“. Nachfolgende Implementierungen geben jedoch in diesem Fall nur "0" oder "-1" zurück („wurde nicht gefunden“).

Bei großen Feldern kann die Berechnung der Mittenposition

 Variable: Mitte = (Links + Rechts) DIV 2 

bei der Addition zu einem Überlauf führen, weshalb oft stattdessen

 Variable: Mitte = Links + ((Rechts - Links) DIV 2) 

implementiert wird.

Jedes der folgenden Beispiele bedarf einer Überarbeitung. Näheres ist auf der Diskussionsseite angegeben. Hilf mit, ihn zu verbessern, und entferne anschließend diese Markierung.

C[Bearbeiten]

Beispiel in C (iterativ):

/**
 * Binäre Suche auf dem Array M nach dem Eintrag suchwert
 *
 * @param M :          zu durchsuchendes Feld
 * @param eintraege :  Anzahl der Feldelemente
 * @param suchwert :   gesuchter Eintrag
 * @return >= 0: Index des gesuchten Eintrags
 *         <  0: nichts gefunden
 */
int binary_search(const int M[], const int eintraege, const int suchwert)
{
    const int NICHT_GEFUNDEN = -1 ;
    int mitte;
    int links = 0;                      /* man beginne beim kleinsten Index */
    int rechts = eintraege - 1;         /* Arrays-Index beginnt bei 0 */
 
    /* Solange die zu durchsuchende Menge nicht leer ist */
    while (links <= rechts)   
    {
        mitte = links + ((rechts - links) / 2); /* Bereich halbieren */
 
        if (M[mitte] == suchwert)       /* Element suchwert gefunden? */
            return mitte;
        else
            if (M[mitte] > suchwert)
                rechts = mitte - 1;     /* im linken Abschnitt weitersuchen */
            else /* (M[mitte] < suchwert) */
                links = mitte + 1;      /* im rechten Abschnitt weitersuchen */
            /* end if */
        /* end if */
    }
 
    return NICHT_GEFUNDEN;
}

Python[Bearbeiten]

Rekursives Verfahren in Python:

 def binaersuche_rekursiv(werte, gesucht, start, ende):
    if ende < start:
        return 'nicht gefunden'
    mitte = (start + ende)/2
    if werte[mitte] == gesucht:
        return mitte
    elif werte[mitte] < gesucht:
        return binaersuche_rekursiv(werte, gesucht, mitte+1, ende)
    else:
        return binaersuche_rekursiv(werte, gesucht, start, mitte-1)

Haskell[Bearbeiten]

Beispiel in der funktionalen Programmiersprache Haskell (rekursiv):

data SearchResult = NotFound Integer | Found Integer deriving (Eq, Ord, Show)
 
bsearch :: Ord a => a               -- hiernach wird gesucht
                 -> (Integer -> a)  -- zu durchsuchende Folge, monoton
                 -> Integer         -- Indexuntergrenze (einschließlich)
                 -> Integer         -- Indexobergrenze (ausschließlich)
                 -> SearchResult
bsearch dest s lo hi
    | s lo > dest = NotFound lo
    | hi <= lo    = NotFound lo
    | otherwise   = go lo hi 
    where
        -- Invarianten: lo < hi, lo ist immer klein genug, hi ist immer zu groß.
        -- Wir suchen den *größten* Index, der klein genug ist.
        go lo hi
            | lo + 1 == hi = if s lo == dest then Found lo else NotFound hi
            | dest < s mid = go lo mid
            | otherwise    = go mid hi
            where mid = (lo+hi)`div`2

Weblinks[Bearbeiten]