Hashing und assoziative Arrays
Mitschrift gibts hier als PDF und hier gibts die TeX-Sourcen, leider als PDF weil man wohl keine .TeXs hochladen darf. Originale gibts auf Anfrage bei kirchner at cl dot uni minus heidelberg dot de. Wird das Package "listings" verwendet, das gibts bei http://tug.ctan.org/tex-archive/macros/latex/contrib/listings/
Tipp- und sonstige Fehler dürfen gerne verbessert und erneut hochgeladen werden, oder gebt mir per Email Bescheid, dann pflege ich die Korrektur ein :)
Ich Finde dein Aufschrieb sollte ins Wiki übetragen werden, das bietet auch alles, was du mit Latex machen kannst. Die Bäume kannst du z.B. mit Latex zeichnen, einen pro Seite und diese dann in eine png Datei umwandeln. Wie sowas geht kann man z.B. in den Quellen von doxygen oder mediawiki selbst nachlesen. Oder man zoomt rein und macht einen Screenshot :-)
Hashtabelle mit linearer Verkettung
Pessimistischer Ansatz: Kollisionen treten häufig auf, deshalb wird unter jedem Hashindex gleich eine Liste angelegt, in der Einträge aufgenommen werden können.
Implementation in Python
HashNode ist eine Hilfsdatenstruktur, die Schlüssel und Wert speichert und mit Hilfe von next eine verkettete Liste realisiert
class HashNode:
def __init__(self,key,data,next):
self.key = key
self.data = data
self.next = next # Verkettung!
Die eigentliche Hashtabelle wird in der Klasse HashTable implementiert:
class HashTable:
def __init__(self):
self.capacity = ... # Geeignete Werte siehe unten
self.size = 0
self.array = [None]*self.capacity
In Python wird der Zugriffsoperator [ ] für eine Datenstruktur wie folgt (innerhalb einer Klasse) implementiert:
def __setitem__(self, key, value)
so dass im Programmtext dann folgende Syntax möglich ist: a[key] = value (schreibender Zugriff auf a[key]). Analog wird der lesende Zugriff value = a[key] wie folgt umgesetzt:
def __getitem__(self, key, value)
Implementierung der __setitem__-Funktion in der HashTable-Klasse:
def __setitem__(self, key, value):
index = hash(key) % self.capacity
node = self.array[index]
while node is not None:
if node.key == key:
# Element key ist schon in der Tabelle
#Überschreibe die Daten mit dem neuen Wert
node.data = value
return
# Kollision des Hashwerts, probiere nächsten Key aus
node = node.next
# Kein Element hatte den richtigen Schlüssel.
# ==>Es gibt diesen Schlüssel noch nicht
# Füge also ein neues Element in die Hashtabelle ein
self.array[index] = HashNode(key, value, self.array[index])
# Der alte Anfang der Liste wurde der Nachfolger des neu eingefügten
# ersten Elements
self.size += 1
Und die Implementierung der __getitem__ Funktionen:
def __getitem__(self, key):
index = hash(key) % self.capacity
node = self.array[index]
while node is not None:
if node.key == key: # Gefunden!
return node.data
node = node.next
raise KeyError(key)
Wahl der Kapazität
In der C++ Standardbibliothek (Klasse std::hash_map) wird die Hashtabelle häufig mit Hilfe der linearen Verkettung imlementiert. Dabei wird capacity immer als Primzahl gewählt, wobei sich aufeinanderfolgende Kapazitäten immer ungefähr verdoppeln:
53, 97, 193, 398, 769, ...
Gcc hashtable.cc (Primzahlen) GCC Hash Implementation
Das hat zur Folge, dass hash(key) % self.capacity alle Bits von h benutzt (Eigenschaft aus der Zahlentheorie). Die Kapizität wird vergrößert, wenn size == capacity erreicht wird. Analog zum dynamischen Array werden die Daten dann aus dem alten Array (self.array) in ein entsprechend vergrößertes neues Array kopiert.
Hashtabelle mit offener Adressierung (offenes Hashing)
Optimistischer Ansatz: Kollisionen werden nicht so häufig auftreten.
Idee
Wenn array[index] durch Kollision bereits vergeben ist, probiere einen anderen Index aus.
- Das Array enthält pro Element höchstens ein (key,value)-Paar
- Das Array muss stets mindestens einen freien Platz haben (sonst gäbe es beim Ausprobieren anderer Indizes eine Endlosschleife). Es gilt immer self.size < self.capacity. Dies war bei der vorigen Hash-Implementation mit linearer Verkettung nicht notwendig (aber im Sinne schneller zugriffszeiten trotzdem wünschenswert).
Vorgehen bei Kollisionen
Sequentielles Sondieren
Probiere den nächsten Index: index = (index+1) % capacity
- Vorteil: einfach
- Nachteil: Clusterbildung
Clusterbildung heißt, dass sich größere zusammenhängende Bereiche bilden die belegt sind, unterbrochen von Bereichen die komplett frei sind. Beim Versuche des Einfügens eines Elements an einen Platz, der schon belegt ist, muss jetzt das ganze Cluster sequentiell durchlaufen werden, bis ein freier Platz gefunden wird. Damit entspricht die Komplexität der Suche der mittleren Länge der belegten Bereiche, was sich entsprechend in einer langsamen Suche widerspiegelt.
Doppeltes Hashing
Bestimme einen neuen Index (bei Kollisionen) durch eine 2. Hashfunktion.
Das doppelte Hashing wird typischerweise in der Praxis angewendet und liegt auch der Python Implementierung des Datentyps Dictionary (Syntax {'a':1, 'b':2, 'c':3} zugrunde.
Eine effiziente Implementierung dieses Datentyps ist für die Performance der Skriptsprache Python extrem wichtig, da z.B. beim Aufruf einer Funktion der auszuführunde Code in einem Dictionary unter dem Schlüssel Funktionsname nachgeschlagen wird oder die Werte lokaler Variablen innerhalb einer Funktion ebenfalls in einem Dictionary zu finden sind.
Für die Implementierung in Python werden wieder die obigen Klassen HashNode (das Attribut next kann allerdings jetzt entfernt werden) und HashTable benötigt, es folgen die angepassten Implementationen von __setitem und __getitem__:
def __setitem__(self, key, value):
h = hash(key)
index = h % self.capacity
while True:
if self.array[index] is None or self.array[index].key is None:
# das Feld ist frei (1. Abfrage)
# oder das Feld ist als frei markiert (2. Abfrage)
self.array[index] = HashNode(key, value)
self.size +=1
return
if self.array[index].key == key:
# Es gibt diesen Schlüssel schon,
# überschreibe die Daten
self.array[index].data = value
return
# Letzter Fall: Kollision => neuer Index durch 2. Hashfunktion
index = (5*index+1+h) % self.capacity
h = h >> 5
Die vorgestellte Implementierung orientiert sich an Pythons interner Dictionary Implementierung, der zugehörige Quelltext (mit ausführlichem Kommentar) findet sich unter dictobject.c Python Implementation (SVN)
Komplexität des offenen Hashings
- Annahme: uniformes Hashing, das heißt alle Indizes haben gleiche Wahrscheinlichkeit
- Füllstand <math>\alpha = \frac{\text{size}}{\text{capacity}}</math>
- Erfolglose Suche (d.h. es wird entweder ein neues Element eingefügt oder ein KeyError geworfen): Untere Schranke für die Komplexität ist <math>\Omega\left(\frac{1}{1-\alpha}\right)</math> Schritte (= Anzahl der notwendigen index-Berechnungen).
- Erfolgreiche Suche <math>\Omega\left(\frac{1}{\alpha}\ln\left(\frac{1}{1-\alpha}\right)\right)</math> Schritte.
| <math>\alpha</math> | 0.5 | 0.9 |
|---|---|---|
| erfolglos | 2.0 | 10 |
| erfolgreich | 1.4 | 2.6 |
Wahl der Kapazität
In Python wird capacity Aufgrund der obigen Beobachtung so gewählt, dass <math>\alpha \leq 2/3</math>. Falls <math>\alpha</math> größer werden sollte, verdopple die Kapazität und kopiere das alte array in das neue Array (analog zum dynamischen Array)
In Python werden die Kapazitätsgrößen als Zweierpotenzen gewählt, also 4,8,16,32,..., so dass h % self.capacity nur die unteren Bits von h benutzt.
Anwendung von Hashing
- Hashtabelle, assoziatives Aray
- Sortieren in linearer Zeit (Übungsaufgabe 6.2)
- Suchen von Strings in Texten: Rabin-Karp-Algorithmus
- ...
Rabin Karp Algorithmus
In Textverarbeitungsanwendungen ist eine häufig benutzte Funktion die Search & Replace Funktionalität. Die Suche sollte in O(len(text)) möglich sein, aber ein naiver Algorithmus braucht O(len(text)*len(searchstring))
Naive Implementierung der Suche
def search(text, s):
M, N = len(text), len(s)
for k in range(M-N):
if s==text[k:k+N]: # O(N), da N Zeichen verglichen werden müssen
return k
return -1 #nicht gefunden
Idee des Rabin Karp Algorithmus
Statt Vergleichen s==text[k:k+N], die O(N) benötigen da N Vergleiche der Buchstaben durchgeführt werden müssen, Vergleiche die Hashs von Suchstring und dem zu untersuchenden Textabschnitt: hash(s) == hash(text[k:k+N]). Dabei muss natürlich hash(s) nur einmal berechnet werden, wohingegen hash(text[k:k+N]) immer wieder neu berechnet werden muss. Damit der Vergleich O(1) sein kann, ist es deswegen erforderlich, eine solche Hashfunktion zu haben, die nicht alle Zeichen (das wäre O(N) ) einlesen muss, sondern die vorhergehende Hashfunktion mit einbezieht.
Eine solche Hashfunktion heißt Running Hash und funktioniert analog zum Sliding Mean.
Die Running Hash Funktion berechnet in O(1) den hash von text[k+1:k+1+N] ausgehend vom hash für text[k:k+N].
Idee: Interpretiere den Text als Ziffern in einer base d Darstellung:
<math>h_k = \text{text}[k]\cdot d^{N-1} + \text{text}[k]\cdot d^{N-2} + \cdots + \text{text}[k+N-1]</math>
Für die Basis 10 (Dezimalsystem) ergibt sich also
<math>h_k = \text{text}[k]\cdot {10}^{N-1} + \text{text}[k]\cdot {10}^{N-2} + \cdots + \text{text}[k+N-1]</math>
Daraus folgt
<math>h_{k+1} = 10\cdot h_k - \text{text}[k]\cdot {10}^{N} + \text{text}[k+N]</math>
Die Komplexität dieses Updates ist O(1), falls man <math>{10}^{N}</math> vorberechnet hat.
In der Realität wählt man dann d=32 und benutzt noch an einigen Stellen modulo Operationen, um die Zahlen nicht zu groß werden zu lassen.
Implementation
def searchRabinKarp(text, s):
ht, hs, dN = 0, 0, 1
M, N = len(text), len(s)
d, q = 32, 33554393
#q ist eine große Primzahl, aber so,
#dass d*q < 2**32 (um Überlauf zu vermeiden)
#Initialisierung
for k in range(N):
ht = (ht*d + ord(text[k])) % q
#ord() gibt die ASCIInummer des übergebenen Zeichens zurück
ds = (hs*d + ord( s[k] )) % q
dN = (dN*a) % q
#Die Variablen sind jetzt wie folgt initialisiert:
#ht = hash(text[0:N])
#hs = hash(s)
#dN = (d**N) % q
#Hauptschleife
k = 0
while k < M-N:
if hs == ht and s==text[k:k+N]:
return k # serch string an Position k gefunden
if k+N < M:
ht = (d*ht - dN * ord(text[k]) + dN*q + ord(text[k+N]) ) % q
k +=1
return -1 # search string nicht gefunden
