2.1 Binäre Suche

Abstraktion

Wir abstrahieren nun von unserem Beispiel mit den englischen Vokabeln und versuchen, die Aufgabenstellung und das Prinzip der binären Suche genauer zu verstehen. Wir haben ein Array $A$ der Größe $n$ gegeben. Es ist sortiert, es gilt also $A [0] \leq A [1] \leq \dots \leq A [n - 1]$ . Lassen Sie sich von dem mathematischen Symbol $\leq$ nicht täuschen. Es muss sich bei den Elementen $A [i]$ nicht um Zahlen handeln. Ganz generell kommen die Elemente aus einem Universum $U$ , auf dem eine lineare Ordnung definiert ist. Ohne jetzt definieren zu wollen, was das genau bedeutet, sei nur dies gesagt: die Elemente lassen sich vergleichen. In englishVocabulary.txt beispielsweise haben wir Strings gegeben, die wir alphabetisch (Mathematiker würden sagen: lexikographisch) vergleichen können.

Des Weiteren haben wir einen Suchwert $x$ gegeben. Ziel ist es, die Position $i$ mit $A [i] = x$ zu finden oder zu dem Schluss zu kommen, dass $x$ im Array $A$ nicht vorkommt. Hierfür führen wir zwei Indizes $l$ und $u$ , welche für lower bound und upper bound stehen. Für diese gilt immer $\begin{array}{r} (1) & A [l] \leq x < A [u] \end{array}$ gilt. Wir wählen anfangs $l = - 1$ und $u = n$ , wobei wir die Konvention im Hinterkopf haben, dass $A [i] = - \infty$ für $i < 0$ und $A [i] = \infty$ für $i \geq n$ .

Konvention: 2.1.1

A [i] = - \infty

für alle

i < 0

und

A [i] = \infty

für alle

i \geq n

. Insbesondere also

A [- 1] = - \infty

und

A [n] = \infty

Mit diesen "Randwerten" ist

A

immer noch sortiert; allerdings müssen wir bei der Implementierung aufpassen, diese Array-Position nicht anzufassen. Die binäre Suche bildet nun das (abgerundete) arithmetische Mittel zwischen

l

und

u

, nämlich

m := ⌊ \frac{l + u}{2} ⌋

und schaut nach, ob

A [m]

kleiner oder größer als

x

oder im Besten Fall gleich

x

ist. Wenn

x < A [m]

gilt, setzen wir

u := m

; wenn

A [m] \leq x

gilt, dann setzen wir

l := m

; in jedem Fall gilt

(1)

auch für die neuen Schranken

l

und

u

. Wir wiederholen diesen Schritt, bis

u = l + 1

gilt. In diesem Falle gilt entweder

A [l] = x

und wir haben

x

gefunden, oder aber

\begin{matrix} (2) & A [l] < x < A [l + 1], \end{matrix}

woraus wir schlussfolgern können, dass

x

gar nicht in

A

vorkommt. In der Praxis würden wir natürlich sofort abbrechen, wenn

A [m] = x

gilt; für eine theoretische Worst-Case-Analyse spielt dies allerdings keine Rolle.

Algorithmus 2.1.2 (Binäre Suche, Pseudocode)

Gegeben ein sortiertes Array $A [0. . n - 1]$ und einen Key $x$ .

binarySearch(Array A, key x):
    l := -1, u := len(A)
    while u - l > 1: 
        m := (l+u)/2 
        if A[l] <= x then 
            l = m 
        else 
            u = m 
    return l

Um zu zeigen, dass der obige Code korrekt ist, müssen wir erst genau formulieren, was wir denn von der binären Suche erwarten:

Theorem 2.1.3 Die Funktion binarySearch(A,x) gibt den eindeutigen Index $j \in {- 1, 0, \dots, n - 1}$ zurück, für den $A [j] \leq x < A [j + 1]$ gilt.

Hinweis: Ob die Aussage im Theorem das beschreibt, was Sie wollen, ist eventuell Geschmackssache. Eine Variante wäre zum Beispiel, zu verlangen, dass der Algorithmus $n$ zurückgibt, falls $x$ größer ist als alle Elemente in dem sortieren Array. Dafür müssten wir den Pseudocode etwas modifizieren.

Extremfälle: Falls $x$ kleiner ist als alle Elemente in $A$ , so behauptet das Theorem, dass binarySearch den Wert $- 1$ zurückgibt, weil ja per Konvention $A [- 1] = - \infty$ gilt und somit $A [- 1] = - \infty < x < A [0]$ . Falls $x$ größer als alle Elemente in $A$ ist, soll binarySearch den Wert $n - 1$ zurückgeben, da dann $A [n - 1] < x < A [n] = \infty$ gilt. Falls $A$ ein leeres Array ist, also $n = 0$ gilt, dann ist ${- 1, \dots, n - 1} = {- 1}$ und es $- 1$ ist die korrekte Antwort, weil $- \infty = A [- 1] < x < A [0] = A [n] = \infty$ ist. Falls $x$ nicht im Array ist, gilt $A [j] < x < A [j + 1]$ , was dann auch zertifiziert, dass $x$ nicht im Array vorhanden ist.

Beweis des Theorems. Wir formulieren eine Schleifeninvariante; das ist eine Behauptung über den Zustand der Variablen im Code. Wir zeigen, dass die Schleifeninvariante nach $i$ Schleifendurchläufen gilt; $i = 0$ heißt dabei vor dem ersten Schleifendurchlauf; dann zeigen wir, dass aus ihrer Gültigkeit in Zeile 9 die Korrektheit folgt, also die Behauptung im Theorem. Um die Schleifeninvariante zu formulieren, definieren wir

\begin{array}{r} (3) & l_{i} := der Wert von l, nachdem i Schleifendurchläufe durchlaufen worden sind \\ (4) & u_{i} := der Wert von u, nachdem i Schleifendurchläufe durchlaufen worden sind . \end{array}

Es gilt also $l_{0} = - 1$ und $u_{0} = n$ .

Schleifeninvariante. Es gelten $\begin{aligned} l_{i} & < u_{i} und \\ A [l_{i}] & \leq x < A [u_{i}], \end{aligned}$ für jedes $i$ , sofern die Schleife mindestens $i$ mal durchlaufen wird.

Beweis. Wir verwenden Induktion über $i$ . Im Basisfall haben wir $i = 0$ und befinden wir uns vor dem ersten Schleifendurchlauf. Es gelten $l_{0} = - 1$ und $u_{0} = n$ ; somit gilt schon einmal $l_{0} < u_{0}$ (auch falls $n = 0$ !); da nach Konvention $A [l_{0}] = - \infty$ und $A [u_{0}] = + \infty$ gilt, gilt auch $A [l_{0}] \leq x < A [u_{0}]$ . Die Invariante gilt also für $i = 0$ .

Sei nun $i \geq 0$ . Wir nehmen per Induktionshypothese an, dass die Invariante nach dem $i$ -ten Durchlauf, also zu Beginn des $(i + 1)$ -ten gilt, und müssen zeigen, dass sie auch nach dem $(i + 1)$ -ten gelten wird. Wir können nach Induktionshypothese also davon ausgehen, dass

\begin{aligned} l_{i} & < u_{i} und \\ A [l_{i}] & \leq x < A [u_{i}], \end{aligned}

gelten. Nun sei $m := ⌊ \frac{l_{i} + u_{i}}{2} ⌋$ . Da es einen $i$ -ten Durchlauf gibt, gilt $u_{i} - l_{i} \geq 2$ und somit $l_{i} < m < u_{i}$ . Wie in Zeile 5 des Codes müssen wir zwei Fälle unterscheiden:

Fall 1: $A [m] \leq x$ . In diesem Fall gelten dann per Zeile 6 des Codes $l_{i + 1} = m$ und $u_{i + 1} = u_{i}$ und somit

\begin{aligned} (Annahme dieses Falles) & A [l_{i + 1}] & \leq x \\ (weil u_{i + 1} = u_{i} und Induktionshypothese) & x & < A [u_{i + 1}] \\ (weil l_{i + 1} = m < u_{i} .) & l_{i + 1} & < u_{i + 1} \end{aligned}

Die Invariante gilt also auch für $i + 1$ .

Fall 2: $A [m] > x$ . In diesem Fall gelten dann per Zeile 8 des Codes $l_{i + 1} = l_{i}$ und $u_{i + 1} = m$ und somit

\begin{aligned} (weil l_{i + 1} = l_{i} und Induktionshypothese) & A [l_{i + 1}] & \leq x \\ (Annahme dieses Falles) & x & < A [u_{i + 1}] \\ (weil l_{i + 1} = m < u_{i} .) & l_{i + 1} & < u_{i + 1} \end{aligned}

Per Induktion gilt die Behauptung für alle $i \geq 0$ , sofern es überhaupt einen $i$ -ten Schleifendurchlauf gibt. $◻$

Aus dem Beweis der Invariante folgt auch, dass $u_{i + 1} - l_{i + 1} \leq u_{i} - l_{i} - 1$ ; der Abstand schrumpft also in jedem Schritt um mindestens $1$ . Daher gibt es nur endlich viele Durchläufe, sagen wir $t$ viele. Nach dem $t$ -ten Durchlauf gelten:

\begin{array}{r} (weil sonst die Schleife weiterlaufen würde) & u_{t} = l_{t} + 1 \\ (wegen der Invariante) & A [l_{t}] \leq x < A [u_{t}] \end{array}

Für den return-Wert $j = l_{t}$ gilt also $A [j] \leq x < A [j + 1]$ , wie behauptet. $◻$

Theorem 2.1.4 (Laufzeit der binären Suche). Auf einem Array der Länge $n$ tätigt binarySearch(array,x) maximal $⌈ \log (n + 1) ⌉$ Schleifendurchläufe.

Der etwas sperrige Ausdruck $⌈ \log (n + 1) ⌉$ hat eine ganz einfache Interpretation: es ist die Anzahl der Bits in der Binärdarstellung von $n$ (wenn wir $0$ als leeren String mit null Bits darstellen).

Beweis. Wir betrachten den Wert $d_{i} := u_{i} - l_{i} - 1$ und wie er sich im Verlauf der Ausführung verändert; die Werte $l_{i}$ und $u_{i}$ sind wie oben in ( $3$ ) und ( $4$ ) im Beweis des vorherigen Theorems definiert.

Behauptung. Sei $i \geq 0$ . Wenn es überhaupt einen $(i + 1)$ -ten Schleifendurchlauf gibt, dann gilt

\begin{array}{r} d_{i + 1} \leq ⌊ \frac{d_{i}}{2} ⌋ \end{array}

Beweis. Betrachten wir wieder die if-Bedingung in Zeile 5 und die beiden Möglichkeiten. Wenn Zeile 6 aufgerufen wird, dann gilt

\begin{aligned} l_{i + 1} & = ⌊ \frac{l_{i} + u_{i}}{2} ⌋ \\ u_{i + 1} & = u_{i} \end{aligned}

und somit

\begin{aligned} (5) & u_{i + 1} - l_{i + 1} - 1 & = u_{i} - ⌊ \frac{l_{i} + u_{i}}{2} ⌋ - 1 \end{aligned}

Falls Zeile 8 aufgerufen wird gilt

\begin{aligned} l_{i + 1} & = l_{i} \\ u_{i + 1} & = ⌊ \frac{l_{i} + u_{i}}{2} ⌋ \end{aligned}

und somit

\begin{aligned} (6) & u_{i + 1} - l_{i + 1} - 1 & = ⌊ \frac{l_{i} + u_{i}}{2} ⌋ - l_{i} - 1 \end{aligned}

Nun ist immer $(6) \leq (5)$ , denn:

\begin{aligned} (6) & = ⌊ \frac{l_{i} + u_{i}}{2} ⌋ - l_{i} - 1 \\ \leq \frac{l_{i} + u_{i}}{2} - l_{i} - 1 \\ = u_{i} - \frac{u_{i} + l_{i}}{2} - 1 \\ \leq u_{i} - ⌊ \frac{u_{i} + l_{i}}{2} ⌋ - 1 = (5) . \end{aligned}

Es genügt also zu zeigen, dass $(5) = ⌊ \frac{u_{i} - l_{i}}{2} ⌋ - 1$ ist. Zeigen wir das. Wir unterscheiden zwei Fälle: ob $u_{i} + l_{i}$ (und ebenso $u_{i} - l_{i}$ ) gerade oder ungerade ist.

Fall 0: $u_{i} + l_{i}$ ist gerade. Dann ist

\begin{aligned} (5) & = u_{i} - ⌊ \frac{u_{i} + l_{i}}{2} ⌋ - 1 = u_{i} - \frac{u_{i} + l_{i}}{2} - 1 \\ (da u_{i} - l_{i} - 1 ungerade ist) & = \frac{u_{i} - l_{i}}{2} - 1 = ⌊ \frac{u_{i} - l_{i} - 1}{2} ⌋ \end{aligned}

Fall 1: $u_{i} + l_{i}$ ist ungerade. Dann ist

\begin{aligned} (5) & = u_{i} - ⌊ \frac{u_{i} + l_{i}}{2} ⌋ - 1 = u_{i} - \frac{u_{i} + l_{i} - 1}{2} - 1 \\ (da u_{i} - l_{i} - 1 gerade ist) & = \frac{u_{i} - l_{i} - 1}{2} - 1 = ⌊ \frac{u_{i} - l_{i} - 1}{2} ⌋ \end{aligned}

In jedem Fall gilt also $d_{i + 1} = u_{i + 1} - l_{i + 1} - 1 \leq (5) = ⌊ \frac{u_{i} - l_{i} - 1}{2} ⌋$ und somit haben wir die Behauptung. $◻$

Rekapitulieren wir: der Wert $d_{i}$ ist am Anfang, also für $i = 0$ , gleich $n - (- 1) - 1 = n$ . In jedem Schritt halbiert und rundet er sich ab:

\begin{array}{r} d_{i + 1} \leq ⌊ \frac{d_{i}}{2} ⌋ . \end{array}

Wenn er nach $t$ Schritten den Wert $0$ erreicht, gilt $d_{t} = u_{t} - l_{t} - 1 = 0$ , also $u_{t} - l_{t} = 1$ , und die Schleife bricht ab. Die Zahl $t$ der Schleifendurchläufe ist also gleich der Anzahl der Halbierung-und-Abrundungsschritte, die der Wert $d_{i}$ durchläuft. Die Funktion $f : x \mapsto ⌊ \frac{x}{2} ⌋$ hat eine ganz einfache Interpretation:

Beobachtung. Sei $x \in N^{+}$ eine positive ganze Zahl. Dann erhalten wir $f (x)$ , indem wir $x$ in Binärdarstellung schreiben und die rechteste Stelle löschen. In diesem Zusammenhang stellen wir die Zahl $0$ als leeren String dar, also als Bitstring der Länge null.

Wie oft müssen wir, beginnend bei $n$ , die rechteste Stelle löschen, bis wir eine leere Zahl (also die Null) erhalten? So oft, wie $n$ Stellen hat. Wie viele Stellen hat die Zahl $n$ in Binärdarstellung? Genau $⌈ \log_{2} (n + 1) ⌉$ viele (wobei $0$ durch den leeren String repräsentiert wird). Wir folgern: auf einem Array der Länge $n$ startet der Wert $d_{i}$ bei $d_{0} = n$ und es gilt $d_{i + 1} \leq f (d_{i})$ . Die Länge der Binärdarstellung von $d_{i}$ schrumpft also in jedem Schleifendurchlauf um mindestens $1$ , und somit haben wir nach höchstens $t = ⌈ \log_{2} (n + 1) ⌉$ Durchläufen $d_{t} = 0$ und somit das Ende erreicht. $◻$

Als Beispiel nehmen wir die Binärzahl $(111001)_{2} = (57)_{10}$ . Wenn wir $f$ wiederholt anwenden, erhalten wir

\begin{array}{r} 111001 \overset{f}{\mapsto} 11100 \overset{f}{\mapsto} 1110 \overset{f}{\mapsto} 111 \overset{f}{\mapsto} 11 \overset{f}{\mapsto} 1 \overset{f}{\mapsto} 0 \end{array}

was in Dezimalschreibweise der Halbier-und-Abrunde-Sequenz

\begin{array}{r} 57 \mapsto 28 \mapsto 14 \mapsto 7 \mapsto 3 \mapsto 1 \mapsto 0 \end{array}

entspricht. Auf einem Array mit $57$ Elementen tätigt binarySearch also maximal sechs Schleifendurchläufe.

Implementierung in Python

Schreiben wir nun eine kleine Funktion in Python, die binäre Suche implementiert.

def binarySearch (data, x):
    lower = -1
    upper = len(data)  
    while (upper - lower > 1):
        lookup = (upper + lower) // 2
        if (data[lookup] <= x):
            lower = lookup 
        else:
            upper = lookup 
        # end if  
    return lower

Python-Programme sind oft sehr kurz, weil Sie im Gegensatz zu Java keine großen Typendeklarationen machen müssen und Fehlerbehandlung gänzlich ausblenden können. Daher eignet sich Python wunderbar, um Algorithmen quick and dirty zu implementieren. Verwenden Sie aber Python bitte nicht, um die Steuerungssoftware eines Atomkraftwerks zu schreiben!

Übungsaufgabe 2.1.1 Kopieren Sie den Python-Code in eine Datei binarySearch.py und speichern Sie die Datei in einem sinnvollen Verzeichnis, beispielsweise home/AuK/code/binarySearch/. Speichern Sie auch englishVocabulary.py dort ab. Fügen Sie die folgende Zeile an den Anfang der Datei binarySearch.py ein:

from englishVocabulary import wordlist_sorted, wordlist_unsorted

Öffnen Sie eine Konsole und starten Sie das Python-Programm im Repl-Modus:

~/AuK/code/binarySearch $ python3 -i binarySearch      
binarySearch(wordlist_sorted, "yak")
57885
wordlist_sorted[57885]
'yak'

Geben Sie per Hand ein sortiertes Array ein, also beispielsweise data = [1,4,9,16,25] und spielen damit rum.

Testen Sie Grenzfälle wie Suchwörter, die kleiner sind als alle Einträge oder solche, die größer sind als alle. Was geschieht bei leeren Arrays?

Übungsaufgabe 2.1.2 Schreiben Sie eine Funktion linearSearch, die das Array in linearer Suche durchgeht und dadurch auch auf unsortierten Arrays funktioniert.

Testen Sie sie auf der unsortierten Wortliste wordlist_unsorted, die ebenfalls englishVocabulary.py definiert ist.

Laufzeit mesen

Mit Python können Sie recht einfach die Laufzeit Ihrer Funktionen messen. Um das Ihnen noch leichter zu machen, habe ich ein kleines Modul timeMyPrograms.py geschrieben. Kopieren Sie die Datei in Ihren Verzeichnis .../code/binarySearch und fügen Sie oben in binarySearch.py die Code-Zeile

from timeMyPrograms import *

ein. Dann können Sie die Laufzeit wie folgt messen:

~/AuK/code/binarySearch $ python3 -i binarySearch
binarySearch(wordlist_sorted, "processor")
39136
measure_alg(binarySearch, wordlist_sorted, "processor")
1.2775002687703818e-05

Ganz allgemein können Sie mit measure_alg(alg, p_1, p_2, ..., p_n) die Laufzeit des Aufrufs von alg(p_1, p_2, ..., p_n) empirisch messen. Beachten Sie, dass die Zahl 1.2775002687703818e-05 die Floating-Point-Schreibweise ist für

\begin{array}{r} 1.2775002687703818 \times 10^{- 5} . \end{array}

Die Laufzeit beträgt also eine gute hunderttausendstel Sekunde.

Übungsaufgabe 2.1.3 Messen Sie empirisch die Laufzeit Ihrer Implementierungen von binarySearch und linearSearch. Um welchen Faktor unterscheiden sie sich?

Implizite binäre Suche

Binäre Suche taucht auch oft auf, ohne dass explizit ein Array vorliegt. Beispielsweise, wenn wir die ganzzahlige Wurzel einer Zahl berechnen wollen:

\begin{aligned} i n t S q r t : N & \to N \\ n & \mapsto ⌊ \sqrt{n} ⌋ \end{aligned}

Wir wollen hier explizit nicht auf die bereits vorhandene Bibliotheksfunktion math.sqrt zurückgreifen. Diese arbeitet insbesondere mit Floating-Point-Zahlen und liefert daher auch schnell falsche Ergebnisse:

~/AuK/code/binarySearch $ python3 -i binarySearch      
def sqrtInt(n): return math.floor(math.sqrt(n))                        
sqrtInt(16):
4
n = 3**40
sqrt(n*n) - n
-33 # Ouch!

Wir müssen es also selbst implementieren. Denken wir nach: $i n t S q r t (n)$ ist die größte ganze Zahl $k$ mit $k^{2} \leq n$ . Daher der folgende Algorithmus:

def intSqrt(n):
    k = 0
    while (k*k <= n):
        k = k+1
    return k-1

Übungsaufgabe 2.1.4 Experimentieren Sie mit der Funktion intSqrt. Wie weit kommen Sie mit vertretbarer Laufzeit? Was ist der Zusammenhang zwischen $n$ und der Laufzeit von intSqrt?

Was ist die Größe einer ganzen Zahl?

Die Laufzeit von intSqrt(n) ist ungefähr proportional zu der Anzahl der Schleifendurchläufe und somit zu $\sqrt{n}$ selbst. Das klingt jetzt gar nicht so schlecht. Nehmen wir aber als Beispiel einmal die Zahl $n := 2^{60}$ . Offensichtlich ist $\sqrt{n} = 2^{30}$ . Dies ist ungefähr eine Milliarde. Unser Algorithmus braucht also eine Milliarde Schleifendurchläufe. Auf einem schnellen Rechner und mit der C-Implementierung ginge das vermutlich in erträglicher Zeit über die Bühne. Ein zeitgenössisches Macbook (Stand Herbst 2023) mit einem Apple M2 Pro Prozessor hat 12 CPU-Kerne, von denen jeder bis zu 3,5 GHz hat. Seien wir unrealistisch optimitisch und nehmen an, ein Schleifendurchlauf von intSqrt bräuchte einen Prozessortakt, und darüberhinaus ist alles perfekt parallelisierbar (also auf die 12 CPU-Kerne) verteilbar, so dass das Macbook pro Sekunde $12 \cdot 3.5 \cdot 10^{9} =$ 42 Milliarden Durchläufe schafft.

In diesem (unrealistisch optimistischen) Szenario würde intSqrt(2**80) also $\frac{\sqrt{2^{80}}}{42 \cdot 10^{9}} \approx 31$ Sekunden dauern. intSqrt(2**100) bereits tausendmal so lange, also fast einen halben Tag. Ist das gerechtfertigt? Ist 2**100 eine "große" Zahl? Fragen wir Python:

2**100                        
1267650600228229401496703205376

Das passt wunderbar auf eine Zeile. Gemessen an der Anzahl an Stellen, die wir brauchen, um diese Zahl zu repräsentieren, ist sie recht klein. Im Allgemeinen bemisst man die Größe einer Zahl (im Kontext von Algorithmen) als ihre Bitlänge, also die Anzahl der Bits in ihrer Binärdarstellung. Wie bereits weiter oben diskutiert hat die Zahl $n$ die Bitlänge

\begin{array}{r} ⌈ \log_{2} (n + 1) ⌉ \end{array}

Anders herum gesagt: eine $k$ -stellige Zahl $n$ (in Bits) ist mindestens $2^{k - 1}$ und höchstens $2^{k} - 1$ . Die Funktion intSqrt(n) benötigt also mindestens

\begin{array}{r} \sqrt{2^{k - 1}} = 2^{\frac{k - 1}{2}} \end{array}

Schleifendurchläufe. Somit ist die Laufzeit exponentiell in der Bitlänge $k$ . Intuitiver ausgedrückt: wenn wir die Bitlänge um 2 Bits erhöhen, dann verdoppelt sich die Laufzeit.

Quadratwurzel mit binärer Suche

Wenn wir ein Array mit den Quadratzahlen $A = [0, 1, 4, 9, 16, . . ., m^{2}]$ gegeben haben, dann können wir für eine Eingabezahl $0 \leq n \leq k^{2}$ per binärer Suche das größte $k$ lokalisieren, für das $A [k] \leq n$ gilt. Da $A [k] = k^{2}$ , so gilt dann eben auch $k = s q r t I n t (n)$ .

~/AuK/code/binarySearch $ python3 -i binarySearch.py                        
array = [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]                        
binarySearch(array, 48)
6

Wir können also mittels binärer Suche die Quadratwurzel berechnen. Natürlich müssen (dürfen) wir das Array $A$ nicht explizit konstruieren (das würde zu viel Zeit und Platz beanspruchen). Wir müssen also eine implizite binäre Suche durchführen, in welcher der Array-Zugriff

        if (data[lookup] <= x):

durch einen Funktionsaufruf ersetzen.

Übungsaufgabe 2.1.5

Schreiben Sie in Python eine Funktion intSqrt (n), die die Funktion $n \mapsto ⌊ \sqrt{n} ⌋$ berechnet. Ihre Funktion soll ohne Probleme die Quadratwurzel hundertstelliger Zahlen berechnen können.

Übungsaufgabe 2.1.6 Messen Sie die Laufzeit Ihres Algorithmus mit measure_alg (intSqrt, 2**100), beispielsweise.

Legen Sie eine Tabelle an: wie entwickelt sich die empirisch gemessene Laufzeit mit der Bitlänge der Eingabezahl? Tip: Sie müssen schon sehr große Zahlen eingaben (tausendstellige, zehntausendstellige), um die Laufzeit zu "spüren".

Wenn Sie die Bitlänge verdoppeln, wie verändert sich die Laufzeit?

Untere Schranken

Übungsaufgabe 2.1.7

Ich habe Ihnen einen speziellen Algorithmus vorgestellt, der das gegenwärtige Suchareal in jedem Schritt halbiert. Ist dies optimal? Versuchen Sie zu beweisen, dass man im Schlimmsten Fall auch $⌈ \log_{2} (n + 1) ⌉$ Schritte benötigt.

Formulieren Sie in Gedanken die binäre Suche als Spiel . Bob kennt das Array $A$ . In jedem Schritt fragt Alice einen index $i$ an und Bob antwortet mit $A [i]$ . Alice will möglichst schnell den Wert $x$ finden, und Bob will dies verzögern.
Tun Sie so, als wäre Bob ein adaptiver Gegner. Das heißt, er kann sich das Array $A$ Schritt für Schritt während des Spiels ausdenken. Er muss aber immer konsistent antworten, d.h. wenn Alice sowohl die Indizes $i < j$ angefragt hat, müssen Bobs Antworten die Bedingung $A [i] < A [j]$ erfüllen.
Zeigen Sie, dass Sie den adaptiven Bob durch einen nicht-adaptiven Bob ersetzen können (also durch ein Array $A$ , dass von vornherein feststeht), so dass Alice dennoch nicht schneller zum Ziel kommt (hier ist es wichtig, dass Alice deterministisch ist, also keinen Zufall verwenden darf).