Suchen in Listen und Hashtabellen - TU Bergakademie Freiberg

Kapitel 12: 

Suchen in Listen und Hashtabellen 

Einführung in die Informatik 

Wintersemester 2007/08 

Prof. Bernhard Jung 

Übersicht 

• Einleitung 

• Lineare Suche 

• Binäre Suche (in sortierten Listen) 

• Hashverfahren 

• Python Dictionaries – eine Implementierung von Hashtabellen 

Literatur 

• G. Saake & K.-U. Sattler. Algorithmen und Datenstrukturen. dPunkt Lehrbuch. 2006. 

• R. Sedgewick. Algorithmen. 2. Auflage. Addison Wesley. 2002. 

• W. Küchlin, A. Weber: Einführung in die Informatik. 

• Donald Knuth. The Art of Computer Programming, Volume 3: Sorting and Searching, 

Third Edition. Addison-Wesley, 1997. 

• Algorithmus der Woche. http://www-i1.informatik.rwth-aachen.de/~algorithmus/ 

Prof. B. Jung Einführung in die Informatik, WS 2007/08 TU Bergakademie Freiberg 

1

Suchen - Problemstellung 

• Gegeben ist eine Menge von 

n Datensätzen 

z.B. n = 1000, 10000, 100000, … 

• Jeder Datensatz kann i.a. mehrere 

Attribute umfassen 

dann wird nach dem Datensatz mit einem 

bestimmten Attribut, dem Schlüssel gesucht 

Schlüssel wird im folgenden als eindeutig 

angenommen 

d.h. Suche liefert entweder ein oder kein 

Ergebnis (erfolgreicher/erfolgloser Fall) 

• Schlüssel kann Zahl, oder auch 

Zeichenkette sein 

• Beispiele 

Suche Eintrag in Telefonbuch 

Suche CD oder Buch in Regal 

Persnr Name Rang Raum 

----------------------------------------- 

2125 Sokrates C4 226 

2126 Russel C4 232 

2127 Kopernikus C3 310 

2133 Popper C3 52 

2134 Augustinus C3 309 

2136 Curie C4 36 

2137 Kant C4 7 

Beispiel für Mitarbeiter-Datenbank 

einer Universität. 

Beispiel-Suchaufgabe: 

Suche den Mitarbeiter mit Persnr 

(Schlüssel) = 2136 

CD-Sammlung 


Suchen in Sequenzen 

–Lineare Suche 

• Problem 

Gegeben: Liste L mit n Werten, Suchwert k 

• (Liste kann sortiert sein, muss aber nicht) 

Gesucht: Index i des Elements von L, so dass L[i] == k; 

falls k nicht in L enthalten: Rückgabe von NO_KEY 

• Vorgehensweise 

durchsuche Liste von vorne nach hinten, bis Element gefunden 

NO_KEY = -1 

def linSearch(liste, k): 

for i in range(len(liste)): 

if liste[i] == k: return i 

return NO_KEY 

>>> linSearch([2,1,4,6,5,9,6,3], 6) 

3 

>>> linSearch(['a','x','y','zz','cc','c'], 'c') 

5 

>>> linSearch([1,2,3],4) 

Prof. -1 B. Jung Einführung in die Informatik, WS 2007/08 TU Bergakademie Freiberg 

2

Suchen in Sequenzen – Lineare Suche 

• Analyse der Zeitkomplexität 

Sequenz wird von vorne nach hinten durchsucht, bis Element gefunden 

Erfolgreiche Suche: 

 

• bester Fall: gesuchter Schlüssel ist erster in Liste 1 Vergleich 

• schlechtester Fall: gesuchter Schlüssel ist letzter in Liste n Vergleiche 

• durchschnittlicher Fall: gesuchter Schlüssel ist in Mitte (n+1)/2 Vergleiche 

Erfolglose Suche: 

• alle Elemente der Liste werden gestestet n Vergleiche 

Anzahl Vergleiche 

Bester Fall 

Schlechtester Fall 

Durchschnittl. Fall (erfolgreiche Suche) 

Durchschnittl. Fall (erfolglose Suche) 

1 – "proportional zu 1" 

n – "proportional zu n" 

(n+1)/2 – "proportional zu n" 

n – "proportional zu n" 

Zeitkomplexität gilt auch, falls Sequenz sortiert ist! 

Für sortierte Sequenzen gibt es aber bessere Verfahren … 


Suchen in sortierten Sequenzen – Binäre Suche 

• Problem (wie bei Suche in unsortierten Sequenzen) 

Gegeben: Sortierte Liste L mit n Werten, Suchwert k 

Gesucht: Index i des Elements von L, so dass L[i] == k; 

falls k nicht in L enthalten: Rückgabe von NO_KEY 

• Motivation: Suche durch "Intervallhalbieren" 

Suche in Telefonbuch z.B. durch sukzessives Halbieren des Suchbereichs: 

• Schlage Telefonbuch in Mitte auf 

• Überprüfe, in welcher Hälfte sich der Eintrag befindet (halbiert Suchbereich) 

• Wiederhole mit dieser Hälfte, bis Seite gefunden 

• Vorgehensweise 

überprüfe Element in Mitte der Liste (Index m = len(L) / 2) 

falls L[m] == k gefunden 

falls L[m] < k suche in erster Hälfte der Liste, d.h. L[0:m] 

falls l[m] > k suche in zweiter Hälfte der Liste, d.h. L[m+1:n] 

Suche erfolglos, falls Suchbereich leer slice-Notation 

>>> l = [1,2,3,4] 

>>> l[0:2], l[3:4] 

Prof. B. Jung Einführung in die Informatik, WS 2007/08 

([1, 2], [4]) 

TU Bergakademie Freiberg 

3


def binSearch(liste, key): 

l = 0 

# left end 

r = len(liste) - 1 # right end 

while l


Analyse 

• Wie lange muss man höchstens suchen? 

Gegeben: Liste mit n Einträgen 

Gesucht: Anzahl der höchstens benötigten Suchschritte (Vergleiche) 

• Anders herum: 

Gegeben: k Suchschritte (Vergleiche) 

Gesucht: Anzahl der Einträge, die durchsucht werden können 

• mit 1 Vergleich: 2 Einträge 

• mit 2 Vergleichen: 4 Einträge 

• mit 3 Vergleichen: 8 Einträge 

• … 

• mit k Vergleiche: 2 k Einträge 

• Nochmal: Wie lange muss man höchstens suchen? 

 

Suche in Liste der Länge n benötigt höchstens log 2 

n Vergleiche 



Analyse 

Anzahl Vergleiche 

Bester Fall 

Schlechtester Fall 

Durchschnittl. Fall (erfolgreiche Suche) 

Durchschnittl. Fall (erfolglose Suche) 

1 – "proportional zu 1" 

≈ log n – "proportional zu log n" 




5

Suchen in sortierten Sequenzen 

Vergleich lineare und binäre Suche 

• lineare Suche 

Maximale Anzahl der Vergleiche: n 

Durchschnittliche Anzahl der Vergleiche: n/2 

funktioniert auch bei unsortierten Listen 

• Binäre Suche 

Maximale und durchschnittliche Anzahl Vergleiche: ca. log 2 n 

Verfahren 

10 

10 2 

10 3 

10 4 

Lineare Suche (n/2) 

≈ 5 

≈ 50 

≈ 500 

≈ 5000 

Binäre Suche (log 2 n) 

≈ 3.3 

≈ 6.6 

≈ 9.9 

≈ 13.3 

durchschnittliche Anzahl Vergleiche der Suchverfahren 


Hashverfahren 

• Anwendung von Hashing: Verfahren für dynamisch veränderliche 

Menge von Objekten mit effizienten Grundoperationen (sog. 

Wörterbuchoperationen) 

Suchen, Einfügen, Löschen 

• Vermeidet Probleme bisheriger Verfahren: 

lineare Suche: ca. n/2 Vergleiche 

binäre Suche: ca. log 2 n Vergleiche 

stattdessen: Suche in konstanter Zeit möglich (durchschnittlicher Fall) 

• Möglicher Nachteil von Hashtabellen 

Reihenfolge der Elemente nicht definiert 

damit auch wird auch Sortieren nicht unterstützt 


6

Einfaches Beispiel für Hashtabelle 

Index 

0 

1 

2 

3 

4 

5 

6 

7 

8 

9 

Eintrag 

42 

96 

119 

einfache Hashtabelle, 

Hashfunktion: h(i) = i mod 10 

Grundprinzip von Hashverfahren 

• Datensätze werden in einem Feld/Array 

mit Indexwerten 0 .. n-1 gespeichert 

Positionen auch als "Buckets" bezeichnet 

• Eine Hashfunktion h bestimmt für ein 

Element e den Index h(e) 

• Die Hashfunktion h sollte die Elemente 

möglichst "gut", d.h. mit möglichst wenigen 

Kollisionen auf die Buckets verteilen 

Kollision liegt vor, wenn Hashfunktion 

mehrere Element auf denselben Bucket 

abbildet 

• verschiedene Varianten des 

Hashverfahrens unterscheiden sich bei der 

Behandlung von Kollisionen 


Hashfunktion 

• Hashfunktion bildet "Objekte" auf ganze Zahlen ab 

z.B. Integer, Zeichenketten 

• Hashfunktion für Integer 

h(i) = i mod N, mit N Größe der Hashtabelle 

N sollte (große) Primzahl sein und nicht zu nahe an Zweierpotenz liegen 

• um eine möglichste gute Gleichverteilung zu erreichen, d.h. 

Minimierung von Kollisionen 

• Hashfunktionen für andere Datentypen 

float: z.B. (Mantisse+Exponent) mod N 

string: Verwendung von Ascii/Unicode-Wert 

• Hashfunktion sollte immer effizient zu berechnen sein (konstante Zeit)! 


7

Hashtabelle: Veranschaulichung 

U 

(Universum der Schlüssel) 

K 

(Aktuelle Schlüssel) 

h(k 4 ) 

k 4 

k 1 

h(k 1 ) 

h(k 2 )=h(k 5 ) 

k 2 

k 5 

k 3 

h(k 3 ) 

Durch die Hashfunktion h werden Schlüssel (von Datensätzen) auf Indices der Hashtabelle 

abgebildet. Im Beispiel kommt es zu einer Kollision zwischen von Hashwerten von k 2 

und k 5 


Strategien zur Behandlung von Kollisionen: 

Direkte Verkettung 

K 


k 2 

k 5 

k 2 

k 3 

k 3 

k 5 

• Beim Verfahren der direkten Verkettung werden Kollisionen aufgelöst, 

indem jeder Tabellenplatz einen Zeiger auf eine verkettete Liste enthält 

• Zeitkomplexität für Suche, n = Anzahl der aktuellen Schlüssel: 

schlechtester Fall: Proportional zu n 

(wenn alle Schlüssel auf selben Tabellenplatz abgebildet werden) 

bester Fall: konstante Zeit (wenn keine Kollisionen vorkommen) 


8


Open Hashing 

• Beim Open Hashing werden alle Einträge in der Hashtabelle 

gehalten 

• d.h. es können maximal m Elemente gespeichert werden, wobei m 

Größe der Hashtabelle 

• Ist eine Komponente der Tabelle schon belegt (Kollision), so wird ein 

freier Platz für einen weiteren Eintrag gesucht 

verschiedene Strategien, wo neuer freier Eintrag gesucht wird 

z.B. lineare Verschiebung: nächster freier Eintrag 

z.B. double Hashing: Einsatz einer zweiten Hash-Funktion 



Open Hashing mit linearer Verschiebung 

K 


k 1 

k 2 

k 3 

• Falls h(k) bereits durch einen anderen Schlüssel besetzt ist, wird 

versucht, k in den Adressen h(k) + 1, h(k) + 2, . . . unterzubringen 

• Präziser gesagt, wird folgende Hashfunktion verwendet: 

h'(k, i) = ( h(k) + i ) mod m mit i = 0, 1, 2, . . . ,m − 1. 


9


Open Hashing mit linearer Verschiebung 

h(k) = k mod 5 

falls h(k) belegt, probiere (h(k) + 1) mod 5 

falls auch belegt, probiere (h(k) + 2) mod 5 

… 

Bem.: Beim Open Hashing können maximal N Elemente gespeichert werden, 

mit N Größe der Hashtabelle 



Open Hashing mit Double Hashing 

K 


k 1 

k 2 

k 3 

• Im Fall einer Kollision wird die Verschiebung durch eine zweite 

Hashfunktion erreicht 

• Präziser gesagt, wird folgende Hashfunktion verwendet: 

h'(k, i) = ( h 1 (k) + i • h 2 (k) ) mod m mit i = 0, 1, 2, . . . ,m − 1. 


10

Vergleich zum Open Hashing: Typische Füllmuster bei 

linearer Verschiebung und Double Hashing 

Typisches Füllmuster bei linearer Verschiebung 

Typisches Füllmuster bei double Hashing 

Beobachtung: Kürzere Ketten bei double Hashing 

im Durchschnitt etwas weniger Vergleiche notwendig bei vollen Hashtabellen 


Hashing - Ladefaktor 

• Ladefaktor für eine Hashtabelle T ist definiert als n/m, wobei n die Anzahl 

der gespeicherten Schlüssel und m die Kapazität der Tabelle ist 

• Theoretische Untersuchungen und praktische Messungen haben ergeben, 

dass der Ladefaktor einer Hashtabelle den Wert 0.8 nicht überschreiten 

sollte (d.h. die Hashtabelle darf höchstens zu 80% gefüllt werden) 

• Ist der Ladefaktor 0.8, so treten beim Suchen im Durchschnitt weniger als 3 

Kollisionen auf (double hashing) 

durchschnittlicher Fall: Suche in konstanter Zeit 

• Bei einem höheren Ladefaktor steigt die Zahl der Kollisionen rasch an 

steigt Ladefaktor auf > 0.8 an, dann sollte Tabellengröße erhöht werden 


11

Suchen in sortierten Sequenzen und Hashtabellen 

Vergleich lineare und binäre Suche 

Verfahren 

10 

10 2 

10 3 

10 5 

10 4 ≈ 16.6 

Lineare Suche (n/2) 

≈ 5 

≈ 50 

≈ 500 

≈ 5000 

≈ 50000 

Binäre Suche (log 2 n) 

≈ 3.3 

≈ 6.6 

≈ 9.9 

≈ 13.3 

Hashtabelle mit Ladefaktor ≤ 0.8 

(≤ 3) 

≤ 3 

≤ 3 

≤ 3 

≤ 3 

≤ 3 

durchschnittliche Anzahl Vergleiche der Suchverfahren 


Python Dictionaries 

• Kollektion von Schlüssel-Wert Paaren (Assoziatives Array) 

Zugriff über Schlüssel 

implementiert als Hashtabelle 

>>> tel = {'jack': 4098, 'sape': 4139} 

>>> type(tel) 

Erzeugung eines Dictionary 

 

>>> tel['guido'] = 4127 

Hinzufügen eines Elements 

>>> print tel 

{'sape': 4139, 'guido': 4127, 'jack': 4098} 

>>> tel['jack'] 

4098 

>>> del tel['sape'] 

Löschen eines Elements 

>>> print tel 

{'guido': 4127, 'jack': 4098} 

>>> tel.keys() 

alle Schlüssel als Liste 

['guido', 'jack'] 

>>> tel.has_key('guido') 

Test, ob Schlüssel in 

True 

Liste enthalten ist 

>>> 'guido' in tel 

True Prof. B. Jung Einführung in die Informatik, WS 2007/08 TU Bergakademie Freiberg 

12

Python Dictionaries 

• eigentlich keine Reihenfolge in Dictionaries definiert 

• trotzdem kann über Elemente iteriert werden: 

iteritems(): Iteration über Tupel (key, value) 

iterkeys(): Iteration über Schlüssel 

itervalues(): Iteration über Werte 

• siehe auch: help(dict) 

>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'} 

>>> for k, v in knights.iteritems(): 

print k, v 

gallahad the pure 

robin the brave 

>>> for k in knights.iterkeys(): 

print k 

gallahad 

robin 


13

Suchen in Listen und Hashtabellen - TU Bergakademie Freiberg

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.

Template löschen?

Als Template speichern?