Zurück zu [[gf_informatik:suchen_und_sortieren#lineare_suche|Lineare Suche]]

Weiter zu [[gf_informatik:suchen_und_sortieren:sortieren|Sortieren]]

<blockquote>Fast is better than slow.
<cite>[[https://about.google/company-info/philosophy/?hl=en#:~:text=3.%20Fast%20is%20better%20than%20slow.|Google]]</cite>
</blockquote>

==== Binäre Suche ====

{{ :gf_informatik:binary_search.jpeg?nolink&400|}}

=== Aufgabe B1: Suchen in einem Wörterbuch / Lexikon ===

Zu zweit oder dritt: Eine Person wählt in einem Wörterbuch oder Lexikon heimlich einen Eintrag, der auf einer Seite rechts oben steht. Das Buch wird geschlossen und eine andere Person versucht mit möglichst wenigen Suchschritten (1x Blättern ist ein Schritt), den Begriff zu finden. Es ist dabei verboten, auf die Markierungen mit den Anfangsbuchstaben an der Seite des Buches zu schauen.

Überlegt euch verschiedene Strategien, wie ihr vorgehen könnt. Welche Strategie benötigt die wenigsten Schritte?

  * Wie oft musst du blättern (bzw. die Seiten aufteilen), bis du das Wort gefunden hast?
  * Wie oft müsstest du durchschnittlich mit der linearen Suche blättern?
  * Wieviele Positionen (Finger zwischen den Seiten) musst du dir merken?

=== Algorithmus ===

Ist ein Datensatz nicht sortiert, macht eine lineare Suche Sinn. Ist dieser aber bereits sortiert, so gibt es viel effizientere Suchalgorithmen, wie die hier beschriebene **binäre Suche**:

Wir teilen den Suchbereich ungefähr in der Mitte. Ist der Begriff zufälligerweise gleich dort, haben wir den Eintrag gefunden; ist der Begriff kleiner als das gefundene Element, suchen wir in der ersten Hälfte, sonst in der zweiten Hälfte weiter, bis genau ein einziges Element übrig bleibt. An dieser Stelle befindet sich der gesuchte Begriff, wenn er überhaupt vorhanden ist. Falls nicht, würde er an dieser Stelle eingefügt werden.

{{:gf_informatik:binary_search.png?nolink&400|}}

Bei der Suche im Wörterbuch suchen wir zu Beginn nur die richtige Seite - wir teilen den Suchbereich, indem wir die Mitte der verbleibenden Seiten wählen und den ersten Eintrag der Seite anschauen. Sind wir auf der richtigen Seite, wiederholen wir dasselbe mit den einzelnen Einträgen.

#### Aufgabe B2: Binäre Suche berechnen

  1. Eine Broschüre hat 7 Seiten und du möchtest mithilfe der binären Suche eine bestimmte Seite finden. Wie viele Seiten musst du maximal aufschlagen? Tipp: Zeichne auf einem Blatt vor dir 7 Striche, die die Seiten repräsentieren.
  1. Wie sieht es mit einer Broschüre mit 15 oder 31 Seiten aus? Wie mit einem Buch mit 255 Seiten?
  1. Erkennst du einen (mathematischen) Zusammenhang zwischen der Anzahl Seiten und der Anzahl Aufschlagen?
  1. Stelle dir vor, es gäbe ein Telefonbuch für alle 8 Milliarden Menschen, wobei jede Person eine einzelne Seite hätte. Ist eine Seite 0.1mm dick, so wäre dieses Telefonbuch ca. 800km dick, was ungefähr der Distanz Romanshorn - London entspricht. Wie viele Seiten musst du maximal aufschlagen, um eine beliebige Person auf einer einzelnen Seite zu finden?

<nodisp 1>
++++Lösung|

   1. Für **7** Seiten sind **3** Halbierungen nötig, bis nur noch eine Seite übrig bleibt. Das heisst, im schlechtesten Fall **3 mal aufschlagen**:
      1. Die mittlere (4.) Seite aufschlagen $\rightarrow$ eine Hälfte fällt weg, drei Seiten in der anderen Hälfte bleiben übrig.
      1. Die mittlere der drei Seiten aufschlagen $\rightarrow$ eine Hälfte fällt weg, eine Seite in der anderen Hälfte bleibt übrig.
      1. Zu dieser einen Seite blättern. 
   1. Für **15** Seiten sind **4** Halbierungen nötig. Bei **31** Seiten max. **5 mal blättern**. Und bei **255** Seiten max. **8 mal**.
   1. In einem Buch mit $2^n - 1$ Seiten musst du maximal $n$ mal blättern. Du hast Exponentialrechnung eventuell noch gar nicht in der Mathematik behandelt - aber du kannst dir vorstellen, dass die Seitenzahl sehr viel stärker wächst als die Anzahl Halbierungen.
   1. $2^{33}-1 = 8589934591$, also $33\times$ blättern.

++++
</nodisp>

Binäre Suche ist also ein äusserst leistungsfähiger Algorithmus, um in einer sortierten Liste ein gewünschtes Element zu finden. Der Suchaufwand wächst nur [[https://www.equestionanswers.com/c/images/log2n.gif|logarithmisch]]: Verdoppelt sich die Seitenzahl, so wächst der Aufwand nur um //eine// Halbierung; bei der linearen Suche würde sich der Aufwand auch verdoppeln.

Allerdings funktioniert die Binärsuche nur, wenn die Sortierung unserem Such-Schlüssel entspricht. Den Namen zu einer gewünschten Telefonnummer zu finden, ist beispielsweise im klassischen Telefonbuch nicht möglich: die Nummern sind in keiner bestimmten Reihenfolge, wir müssten das ganze Telefonbuch linear durchsuchen, um die gewünschte Nummer zu finden. `tel.search.ch` verwendet dazu einen zweiten, invertierten Index, bei dem die Namen nach Telefonnnummer sortiert abgespeichert werden.
#### Aufgabe B3: Binäre Suche in Python

Komplettiere folgenden Code und teste ihn aus. Wir merken uns zwei Variablen, `links` und `rechts`, die den Suchbereich abstecken: `links` ist die Position des kleinsten Elements, `rechts` die Position des grössten Elements, das noch in Frage kommt. Zu Beginn ist `links` natürlich null, und `rechts` ist der Index des letzten Elements (also `len(l) - 1`).

++++Mehr Hinweise|
In der `while`-Schleife manipulieren wir nun diese Positionen, indem wir eine Position in der Mitte der beiden auswählen: `mitte = ...`. Das Element in der Mitte (`l[mitte]`) können wir nun mit dem gesuchten Element vergleichen. Was tun wir, wenn das Mitte-Element genau der Suche entspricht? Wenn das gesuchte Element kleiner oder grösser als das in der Mitte ist, müssen `links` oder `rechts` angepasst werden - aber wie genau?

Beachte:
  * Zeichne die Suche auf Papier auf, um keine Verwirrung mit den Positionen entstehen zu lassen.
  * Um eine Ganzzahl-Division (ohne Rest) durchzuführen, benützen wir in Python den `//` Operator:

<code python>
print(11 // 2)
>>> 5
</code>
++++

<nodisp 1>
[[gf_informatik:suchen_und_sortieren::binaersuche:anleitung|Vollständige Erklärung und Anleitung]]
</nodisp>

<bottom-exercise id="b3" timeout="5" showsolution>
<template data-type="starter">
def binary_search(l, v):
    """Gibt den Index des gesuchten Elements in l zurück, None,
       wenn das Element nicht existiert."""
    links = 0
    rechts = len(l) - 1
    while links <= rechts:
        # TODO: Dein Code hier!
        pass
    return None

# Test
print(binary_search(['A','C','D','G','J','N','Q','X'],'J')) # output must be: 4
</template>
<template data-type="solution">
def binary_search(l, v):
    links = 0
    rechts = len(l) - 1
    
    while links <= rechts:
        mitte = (links + rechts) // 2
        element = l[mitte]
        print(f'Besuche {mitte} ({element}) im Intervall {links}-{rechts}')
        if element == v:
            return mitte  # Gefunden!
        if v < element:
            # Links weitersuchen
            rechts = mitte - 1
        else:
            # Rechts weitersuchen
            links = mitte + 1
            
    return None  # Nichts gefunden

print(binary_search(['A','C','D','G','J','N','Q','X'],'J')) # output must be: 4
</template>
<template data-type="test">
assert binary_search(['A','C','D','G','J','N','Q','X'],'B') is None
assert binary_search(['A','C','D','G','J','N','Q','X'],'A') == 0
assert binary_search(['A','C','D','G','J','N','Q','X'],'C') == 1
assert binary_search(['A','C','D','G','J','N','Q','X'],'D') == 2
assert binary_search(['A','C','D','G','J','N','Q','X'],'G') == 3
assert binary_search(['A','C','D','G','J','N','Q','X'],'J') == 4
assert binary_search(['A','C','D','G','J','N','Q','X'],'N') == 5
assert binary_search(['A','C','D','G','J','N','Q','X'],'Q') == 6
assert binary_search(['A','C','D','G','J','N','Q','X'],'X') == 7
assert binary_search(['A','C','D','G','J','N','Q','X'],'Z') is None
</template>
</bottom-exercise>

#### Aufgabe B4: Binäre Suche für 079

<bottom-exercise id="b4" timeout="5" zip="https://bottom.ch/ksr/1m/null79.py.zip" showsolution>
<div slot="prompt">
Kannst du nun die Funktion für die binäre Suche selbständig, also <em>ohne nachzuschauen</em>, schreiben und diese auch verwenden, um in Listen zu suchen? Versuche es:

<ul>
  <li>Schreibe selbständig deine Funktion <code>binary_search(l, v)</code>: Sie soll die Position von <code>v</code> in der Liste <code>l</code> zurückgeben. Wenn nichts gefunden wird, soll die Funktion <code>None</code> zurückgeben.
  <li>Definiere unter einer Variable namens <code>name</code> den gesuchten Namen, also <code>Lyanna</code>.
  <li>Jetzt suchst du mit <code>index = binary_search(names, name)</code> nach dem Index von <code>name</code> in der Liste <code>names</code>.
  <li>Unter dem gleichen Index findest du in <code>numbers</code> die dazugehörige Telefonnummer.
  <li>Gib einen Satz im Format <code>Die Telefonnummer von ... ist ...</code> aus.
  <li>Dein Code sollte so aufgebaut sein, dass du nur die Variable <code>name</code> ändern musst, damit ein neuer, korrekter Satz ausgegeben wird.
</ul>
</div>
<template data-type="starter">
from null79 import names, numbers

def binary_search(l, v):
    """Gibt den Index des gesuchten Elements in l zurück, None,
       wenn das Element nicht existiert."""
</template>
<template data-type="solution">
from null79 import names, numbers

def binary_search(l, v):
    left = 0
    right = len(l) - 1
    
    while left <= right:
        middle = (left + right) // 2
        element = l[middle]
        if element == v:
            return middle  # Gefunden!
        if v < element:
            # Links weitersuchen
            right = middle - 1
        else:
            # Rechts weitersuchen
            left = middle + 1
            
    return None  # Nichts gefunden

name = 'Lyanna'
index = binary_search(names, name)
if index is None:
    print('Du weisch immer no nüt')
else:
    telnr = numbers[index]
    print('Die Nummer von ' + name + ' lautet ' + telnr + '!')
</template>
<template data-type="test">
assert binary_search(['A','C','D','G','J','N','Q','X'],'D') == 2
assert binary_search(['A','C','D','G','J','N','Q','X'],'Z') is None
assert binary_search(names,'Lyanna') >= 0
</template>
</bottom-exercise>

#### Aufgabe B5: Zeitmessung mit linearer und binärer Suche

<bottom-exercise id="b5" timeout="120" zip="https://bottom.ch/ksr/1m/null79.py.zip" showsolution>
<div slot="prompt">
Vergleiche die lineare Suche mit der binären Suche. Hierzu kannst du von Aufgabe B4 ausgehen:
<ul>
  <li>Behalte nur die Listen und die Definition der Funktion <code>binary_search()</code>.
  <li>Ergänze die Datei um die Funktion <code>linear_search(l, v)</code> (am besten, du schreibst du sie selbst hin, anstatt sie zu kopieren).
  <li>Definiere eine neue Funktion <code>stopwatch(algo, name)</code>. Sie hat zwei Argumente:
  <ul>
    <li><code>algo</code> ist der Name der Suchfunktion (Suchalgorithmus), die verwendet werden soll (also <code>binary_search</code> oder <code>linear_search</code>, ohne die Klammern des Funktionsaufrufs).
    <li><code>name</code> ist der Name, nach dem gesucht werden soll.
    </ul>
  <li>Die Funktion soll mit dem gewünschten Algorithmus im Telefonbuch suchen und die Zeit für die Suche messen (<code>import time</code>, siehe auch Aufgabe A5). Am Ende soll die Funktion einen Text in folgender Form ausgeben: "Die Telefonnummer von ... lautet .... Die Suche dauerte ... Sekunden."
  <li>Rufe nun die Funktion vier mal auf: Für <code>Annina</code> und <code>Lyanna</code> – jeweils mit der linearen und mit der binären Suche.
</ul>
</div>
<template data-type="starter">
from null79 import names, numbers

def binary_search(l, v):
    """Gibt den Index des gesuchten Elements in l zurück, None,
       wenn das Element nicht existiert."""
    # TODO implementieren

def linear_search(l, v):
    """Gibt den Index des gesuchten Elements in l zurück, None,
       wenn das Element nicht existiert."""
    # TODO implementieren

def stopwatch(algo, name):
    """Ruft die Funktion algo auf und misst die Zeit der Ausführung."""

stopwatch(binary_search, 'Annina')
</template>
<template data-type="solution">
from null79 import names, numbers
import time

def binary_search(l, v):
    left = 0
    right = len(l) - 1
    
    while left <= right:
        middle = (left + right) // 2
        element = l[middle]
        if element == v:
            return middle  # Gefunden!
        if v < element:
            # Links weitersuchen
            right = middle - 1
        else:
            # Rechts weitersuchen
            left = middle + 1
            
    return None  # Nichts gefunden

def linear_search(l, v):
    for i in range(len(l)):
        if l[i] == v:
            return i
    return None

def stopwatch(algo, name):
    start = time.time()
    index = algo(names, name)
    telnr = numbers[index]
    elapsed = time.time() - start
    print(f'Die Nummer von {name} lautet {telnr}! Die Suche dauerte {elapsed:.2n}s.')

stopwatch(linear_search, 'Annina')
stopwatch(binary_search, 'Annina')
stopwatch(linear_search, 'Lyanna')
stopwatch(binary_search, 'Lyanna')
</template>
</bottom-exercise>



#### Aufgabe B6: Nach Telefonnummern suchen.
Was passiert, wenn du statt nach Telefonnummern statt nach Namen suchst? Funktioniert die Binärsuche? Weshalb nicht? Was müssten wir ändern, damit sie funktioniert?

<nodisp 1>
++++Lösung:|
Die Liste muss **sortiert** sein, damit wir Binärsuche verwenden können. Das Telefonbuch ist aber nach Namen sortiert, nicht nach Telefonnummern. Wir müssten ein Kopie anfertigen und beide Listen nach Telefonnummer sortieren.
++++
</nodisp>

#### Aufgabe B7: Mehrere Suchresultate (optional).
In Aufgabe A6 wird die Funktion für die lineare Suche abgeändert für den Fall, dass das gesuchte Element mehrmals in der Liste vorkommt. Die neue Funktion gibt nicht nur die erste Position des gesuchten Elements zurück, sondern sie gibt eine Liste mit allen Positionen zurück, in denen das gesuchte Element vorkommt. Erstelle eine Funktion `binary_search2(li, el)` welche ebenso funktioniert. Du kannst natürlich davon ausgehen, dass die Liste sortiert ist. Teste deine Funktion zum Beispiel wie folgt:
<code python>
def binary_search2(li, el):
   # dein Code hier!

my_list = ['A','A','C','E','E','E','E','E','G','G','G','G']
print(binary_search2(my_list,'A')) # Erwartete Ausgabe: [0, 1]
print(binary_search2(my_list,'B')) # Erwartete Ausgabe: None
print(binary_search2(my_list,'C')) # Erwartete Ausgabe: [2]
print(binary_search2(my_list,'D')) # Erwartete Ausgabe: None
print(binary_search2(my_list,'E')) # Erwartete Ausgabe: [3, 4, 5, 6, 7]
print(binary_search2(my_list,'F')) # Erwartete Ausgabe: None
print(binary_search2(my_list,'G')) # Erwartete Ausgabe: [8, 9, 10, 11]
print(binary_search2(my_list,'H')) # Erwartete Ausgabe: None
</code>

<nodisp 1>
++++Lösung|
<code python>
def binary_search2(li, el):
    results = []
    left = 0
    right = len(li)-1
    while left <= right:
        mid = (left + right) // 2
        if li[mid] == el:
            while li[mid] == el:
                mid -= 1
            mid += 1
            while mid < len(li) and li[mid] == el:
                results.append(mid)
                mid += 1
            return results
        elif li[mid] < el:
            left = mid + 1
        else:
            right = mid -1
    return None
</code>
++++
</nodisp>

#### Aufgabe B8: Rekursion (optional)

<bottom-exercise id="b8" timeout="5" zip="https://bottom.ch/ksr/1m/null79.py.zip" showsolution>
<div slot="prompt">
Bei der binären Suche gehen wir ja wie folgt vor:
<ul>
  <li>Index in der Mitte des Suchintervalls wählen.
  <li>Element in der Mitte auslesen.
  <li>Ist <code>element == suche</code> sind wir fertig.
  <li>Andernfalls wiederholen wir die Suche mit einem kleineren Teilintervall (zurück zu Schritt 1):
    <ul>
      <li>Ist <code>suche &lt; element</code>, so ist das neue Suchintervall die linke Hälfte.
      <li>Andernfalls ist <code>element &lt; suche</code>, das neue Suchintervall ist die rechte Hälfte.
    </ul>
</ul>

<p>Schreibe eine neue Funktion, <code>binaere_suche_rekursiv(l, suche, links, rechts)</code>. Die Funktion codiert die obigen Schritte &ndash; statt einer <code>while</code>-Schleife soll die Funktion sich im Schritt 4 selber wieder aufrufen. Dieses Verfahren heisst <strong>Rekursion</strong>. Was sind die Startparameter für <code>links</code> und <code>rechts</code>?

<p>Rekursion eignet sich für viele Probleme, die sich mit <em>Divide &amp; Conquer</em> (<em>Teile &amp; Herrsche</em>) lösen lassen: Probleme, die wir für den trivialen Fall mit einem Element lösen können, und die wir effizient von einem grösseren in ein kleineres Problem überführen können.
</div>
<template data-type="starter">
from null79 import names, numbers

def binaere_suche_rekursiv(l, suche, links=None, rechts=None):
    """Gibt den Index des gesuchten Elements in l zurück,
       None, wenn das Element nicht existiert."""
</template>
<template data-type="test">
assert binaere_suche_rekursiv(names, 'Lyanna', links=0, rechts=len(names)) >= 0
assert binaere_suche_rekursiv(names, 'Lyanna') >= 0, "Aufruf ohne links / rechts sollte auch funktionieren"
</template>
<template data-type="solution">
from null79 import names, numbers

def binaere_suche_rekursiv(l, suche, links=None, rechts=None):
    """Gibt den Index des gesuchten Elements in l zurück,
       None, wenn das Element nicht existiert."""
    # Falls links und rechts nicht angegeben werden, sind sie None
    # Wir setzen sie so, dass sie die ganze Liste umfassen:
    links = links or 0
    rechts = rechts or len(l) - 1

    # Links ist grösser als rechts - nicht gefunden.
    if links > rechts:
        return None
    
    # 1: Intervall halbieren
    mitte = (links + rechts) // 2
    # 2: Element in der Mitte auslesen
    element = l[mitte]
    # 3: Element gefunden?
    if element == suche:
        return mitte
    # 4: Rekursion
    if suche < element:
        rechts = mitte - 1
    else:
        links = mitte + 1
    return binaere_suche_rekursiv(l, suche, links, rechts)

from null79 import names, numbers
print(f'Die Telefonummer von Lyanna ist {numbers[binaere_suche_rekursiv(names, "Lyanna")]}.')
</template>
</bottom-exercise>




----
Weiter zu [[gf_informatik:suchen_und_sortieren:sortieren|Sortieren]]