Algorithmen und Datenstrukturen
D2. Suche in Strings 1
Marcel L¨ uthi
Universit¨ at Basel
22. Mai 2019
1Folien angelehnt an Vorlesungsfolien von Sedgewick & Wayne https://algs4.cs.princeton.edu/lectures/52Tries-2x2.pdf
Algorithmen und Datenstrukturen
22. Mai 2019 — D2. Suche in Strings
aaFolien angelehnt an Vorlesungsfolien von Sedgewick & Wayne https://algs4.cs.princeton.edu/lectures/52Tries-2x2.pdf
D2.1 Einf¨ uhrung D2.2 Tries
D2.3 Zeichenbasierte Operationen
D2.1 Einf¨ uhrung
Erinnerung: Symboltabellen
Abstraktion f¨ ur Schl¨ ussel/Werte Paar Grundlegende Operationen
I Speichere Schl¨ ussel mit dazugeh¨ orendem Wert.
I Suche zu Schl¨ ussel geh¨ orenden Wert.
I Schl¨ ussel und Wert l¨ oschen.
Typische Beispiele
I DNS - Suche IP-Adresse zu Domainnamen
I Telefonbuch - Suche Telefonnummer zu Person / Adresse
I W¨ orterbuch - Suche ¨ Ubersetzungen f¨ ur Wort
Ubersicht ¨
Worst-case Average-case Implementation suchen einf¨ ugen suchen (hit) einf¨ ugen Rot-Schwarz B¨ aume 2 log
2(N) 2 log
2(N) 1 log
2(N) 1 log
2(N)
Hashtabellen N N 1 1
I Frage: Geht es noch schneller?
I Antwort: Ja, wenn wir nicht ganzen String vergleichen m¨ ussen.
Symboltabelle f¨ ur Strings
c l a s s S t r i n g S T [ V a l u e ]:
def S t r i n g S T ()
def put ( key : String , v a l u e : V a l u e ) - > N o n e def get ( key : S t r i n g ) - > V a l u e
def d e l e t e ( key : S t r i n g ) - > N o n e def k e y s () - > I t e r a t o r [ S t r i n g ]
Normale Symboltabellen Operationen, aber mit fixem Typ String
als Schl¨ ussel
Symboltabelle f¨ ur Strings
c l a s s S t r i n g S T [ V a l u e ]:
def S t r i n g S T ()
def put ( key : String , v a l u e : V a l u e ) - > N o n e def get ( key : S t r i n g ) - > V a l u e
def d e l e t e ( key : S t r i n g ) - > N o n e def k e y s () - > I t e r a t o r [ S t r i n g ]
def k e y s W i t h P r e f i x ( s : S t r i n g ) - > I t e r a t o r [ S t r i n g ] def k e y s T h a t M a t c h ( s : S t r i n g ) - > I t e r a t o r [ S t r i n g ] def l o n g e s t P r e f i x O f ( s : S t r i n g ) - > S t r i n g
Mittels Tries lassen sich viele n¨ utzliche, zeichenbasierte
Suchoperationen definieren.
D2.2 Tries
Tries
Trie Von Retrieval.
I Ausgesprochen wie try
I Zeichen (nicht Schl¨ ussel werden in Knoten gespeichert)
I Jeder Knoten hat R Knoten (also einen pro m¨ oglichem Zeichen)
Quelle: Sedgewick & Wayne, Algorithmen, Abbildung 5.19
Erinnerung: Alphabet
Abstraktion Alphabet macht Code unabh¨ angig von Alphabet.
c l a s s A l p h a b e t :
def _ _ i n i t _ _ ( s : L i s t [ c h a r ]) def t o C h a r ( i n d e x : Int ) - > c h a r def t o I n d e x ( c : C h a r ) - > int def c o n t a i n s ( c : C h a r ) - > b o o l e a n def R () - > int # R a d i x
Name Radix (R) Bits (log
2(R )) Zeichen
BINARY 2 1 0 1
DNA 4 2 A C G T
ASCII 128 7 ASCII Characters
EXTENDED ASCII 256 8 EXTENDED ASCII
UNICODE 1’114’112 21 UNICODE
Repr¨ asentation der Knoten
Quelle: Sedgewick & Wayne, Algorithmen, Abbildung 5.21
c l a s s N o d e : v a l u e = N o n e
c h i l d r e n = [ N o n e ] * R # R : R a d i x v o n A l p h a b e t
Suche in Trie
Dem Zeichen entsprechenden Link folgen
I Erfolgreiche Suche:
Endet an Knoten mit definiertem Wert I Erfolglose Suche:
Endet an Knoten mit undefiniertem Wert (null)
Quelle: Sedgewick & Wayne, Algorithmen, Abbildung 5.20
Suche in Tries
def get ( node , key , d ):
if ( n o d e == N o n e ):
r e t u r n N o n e if d == len( key ):
r e t u r n n o d e
c = a l p h a b e t . t o I n d e x ( key [ d ])
r e t u r n get ( n o d e . c h i l d r e n [ c ] , key , d + 1)
Einf¨ ugen in Trie
Dem Zeichen entsprechenden Link folgen
I Erfolgreiche Suche:
Wert neu setzten I Erfolglose Suche:
Neuen Knoten erzeugen.
Quelle: Sedgewick & Wayne, Algorithmen, Abbildung 5.22
Einf¨ ugen in Trie
def put ( node , key , value , d ):
if n o d e == N o n e :
n o d e = N o d e ( a l p h a b e t . r a d i x ()) if d == len( key ):
n o d e . v a l u e = v a l u e r e t u r n n o d e
c = a l p h a b e t . t o I n d e x ( key [ d ])
n o d e . c h i l d r e n [ c ] = put ( n o d e . c h i l d r e n [ c ] , key , value , d + 1)
r e t u r n n o d e
L¨ oschen von Schl¨ usseln
I Schl¨ ussel finden und Knoten l¨ oschen.
I Rekursiv alle Knoten mit nur null-Werten und null-links l¨ oschen
Quelle: Sedgewick & Wayne, Algorithmen, Abbildung 5.26
L¨ oschen von Schl¨ usseln
def d e l e t e ( node , key , d ):
if n o d e == N o n e : r e t u r n N o n e if d == len( key ):
n o d e . v a l u e = N o n e e l s e :
c = a l p h a b e t . t o I n d e x ( key [ d ])
n o d e . c h i l d r e n [ c ] = d e l e t e ( n o d e . c h i l d r e n [ c ] , key , d + 1) if n o d e . v a l u e != N o n e :
r e t u r n n o d e
n o n N u l l C h i l d r e n = [ c for c in n o d e . c h i l d r e n if c != N o n e ] if len( n o n N u l l C h i l d r e n ) > 0:
r e t u r n n o d e e l s e :
r e t u r n N o n e
Implementation und Beispielanwendung
Jupyter Notebook: Tries.ipynb
Analyse: Form des Tries
Theorem
Die verkettete Struktur (Form) eines Trie ist nicht abh¨ angig von
der Schl¨ usselreihenfolge beim L¨ oschen/Einf¨ ugen: F¨ ur jede
gegebene Menge von Schl¨ usseln gibt es einen eindeutigen Trie.
Analyse: Einf¨ ugen
Theorem
Die Anzahl der Arrayzugriffe beim Suchen in einem Trie oder beim Einf¨ ugen eines Schl¨ ussels in einen Trie ist h¨ ochstens 1 plus der L¨ ange des Schl¨ ussels.
Theorem
Die durchschnittliche Anzahl der untersuchten Knoten bei einer
erfolglosen Suche in einem Trie, der aus N Zufallsschl¨ usseln ¨ uber
einem Alphabet der Gr¨ osse R erstellt wird, betr¨ agt ∼ log R (N).
Take-Home Message
Auch in riesigen Datenmengen k¨ onnen wir mit wenigen Vergleichen
jeden Wert finden.
Speichereffiziente Variante: Tern¨ are Suchtries
Ein Problem mit Tries
I In jedem Knoten wird ein Array der Gr¨ osse R gespeichert I Beispiel Unicode (utf-16): R = 2 16 = 65536.
L¨ osung:
I Speichere Zeichen c sowie Wert im Knoten I Jeder Knoten hat 3 Kinder:
I Kleiner c (linker Teilbaum) I Gleich c (mittlerer Teilbaum) I Gr¨ osser c (rechter Teilbaum)
Bentley, Jon L., and Robert Sedgewick. ”Fast algorithms for
sorting and searching strings.”1997.
Speichereffiziente Variante: Tern¨ are Suchtries
Beispiel:
Quelle: Sedgewick & Wayne, Algorithmen, Abbildung 5.28
I Bei ¨ Ubereinstimmung wird Suche mit n¨ achstem Zeichen im mittleren Teilbaum weitergef¨ uhrt.
I Suche ist erfolgreich, wenn Wert in Endknoten der Suche
M. L¨uthi (Universit¨at Basel) Algorithmen und Datenstrukturen 22. Mai 2019 23 / 36
Tries versus Hashing
Hashing:
I Muss ganzen Schl¨ ussel anschauen
I Etwa gleiche Kosten f¨ ur erfolgreiche und erfolglose Suche I Performance h¨ angt von Hashfuktion ab
I Keine ordnungsbasierten Operationen Tries:
I Nur f¨ ur Strings geeignet
I Macht nur so viele Vergleiche wie gerade ben¨ otigt werden
I Erfolglose Suche ben¨ otigt nur ein paar Zeichenvergleichen
I Flexible zeichenbasierte Operationen werden unterst¨ utzt
D2.3 Zeichenbasierte Operationen
Zeichenbasierte Operationen
Schl¨ ussel Wert
by 4
sea 6
sells 1
she 0
shells 3
shore 7
the 5
Pr¨ afix matching Pr¨ afix: sh: Schl¨ ussel, she, shells, shore
Wildcard matching .he: Schl¨ ussel, she, the L¨ angstes Pr¨ afix Anfrage: shellsort
Schl¨ ussel: shells
Pr¨ afix¨ ubereinstimmung
Beispielanwendung: Autocomplete
Zeichenbasierte Operationen
c l a s s S t r i n g S T : def S t r i n g S T ()
def put ( key : String , v a l u e : V a l u e ) - > N o n e def get ( key : S t r i n g ) - > V a l u e
def d e l e t e ( key : S t r i n g ) - > N o n e def k e y s () - > I t e r a t o r [ S t r i n g ]
def k e y s W i t h P r e f i x ( s : S t r i n g ) - > I t e r a t o r [ S t r i n g ]
def k e y s T h a t M a t c h ( s : S t r i n g ) - > I t e r a t o r [ S t r i n g ]
def l o n g e s t P r e f i x O f ( s : S t r i n g ) - > S t r i n g
Warmup: Alle Schl¨ ussel zur¨ uckgeben
I Traversieren des Baumes
I Bei jedem Knoten mit Wert 6= null, Schl¨ ussel merken
M. L¨uthi (Universit¨at Basel) Algorithmen und Datenstrukturen 22. Mai 2019 29 / 36
Pr¨ afix¨ ubereinstimmung
I Subtrie mit Pr¨ afix finden
I Alle Schl¨ ussel von diesem Subtrie zur¨ uckgeben
Quelle: Sedgewick & Wayne, Algorithmen, Abbildung 5.24
Pr¨ afix¨ ubereinstimmung
def k e y s ( n o d e ):
r e t u r n k e y s W i t h P r e f i x ( node , " " ) def k e y s W i t h P r e f i x ( node , r e f i x ):
q u e u e = []
c o l l e c t ( get ( node , prefix , 0) , prefix , q u e u e ) r e t u r n q u e u e
def c o l l e c t ( node , prefix , q u e u e ):
if n o d e == N o n e : r e t u r n
if n o d e . v a l u e != N o n e : q u e u e . a p p e n d ( p r e f i x )
l a b e l e d C h i l d r e n = [( a l p h a b e t . t o C h a r ( p ) , c h i l d )
for ( p , c h i l d ) in e n u m e r a t e ( n o d e . c h i l d r e n ) if c h i l d != N o n e ]
for ( char , c h i l d ) in l a b e l e d C h i l d r e n :
c o l l e c t ( child , p r e f i x + char , q u e u e )
L¨ angstes Pr¨ afix
I Beispielanwendung: Routing, LZW-Kompression
”128”
”128.112”
”128.112.055”
”128.112.055.15”
”128.112.136”
”128.112.155.11”
”128.112.155.13”
”128.222”
”128.222.136”
Anfrage:
longestPrefixOf(”128.112.136.11”) = ”128.112.136”
longestPrefixOf(”128.112.100.16”) = ”128.112”
longestPrefixOf(”128.166.123.45”) = ”128”
L¨ angstes Pr¨ afix
I Nach Anfragestring suchen
I L¨ angster Schl¨ ussel auf dem Weg dahin speichern.
Quelle: Sedgewick & Wayne, Algorithmen, Abbildung 5.25
L¨ angstes Pr¨ afix
def l o n g e s t P r e f i x O f ( node , s ):
l = s e a r c h ( node , s , 0 , 0) r e t u r n s [0: l ]
def s e a r c h ( node , s , d , l e n g t h ):
if n o d e == N o n e : r e t u r n l e n g t h if n o d e . v a l u e != N o n e :
l e n g t h = d if d == len( s ):
r e t u r n l e n g t h
c = a l p h a b e t . t o I n d e x ( s [ d ])
r e t u r n s e a r c h ( n o d e . c h i l d r e n [ c ] , s , d +1 , l e n g t h )
Quiz: Wildcard matching
I Wie implementieren wir Wildcard matching?
Quelle: Sedgewick & Wayne, Algorithmen, Abbildung 5.28
