Approximative Suche in Baumstrukturen

G OTTFRIED W ILHELM L EIBNIZ U NIVERSITÄT H ANNOVER
FAKULTÄT FÜR E LEKTROTECHNIK UND I NFORMATIK
I NSTITUT FÜR P RAKTISCHE I NFORMATIK
FACHGEBIET P ROGRAMMIERSPRACHEN UND Ü BERSETZER
Masterarbeit
Approximative Suche
in Baumstrukturen
Gennadi Mirmov
Matrikelnummer: 2242560
November 2009
Erstprüfer: Prof. Dr. R. Parchmann
Zweitprüfer: Prof. Dr. H. Vollmer
Gesetzt mit
LATEX 2ε
3
Inhaltsverzeichnis
Inhaltsverzeichnis
Inhaltsverzeichnis
3
1
Einleitung
5
2
Grundlagen und Definitionen
9
3
2.1 Grundlegende Schreibweisen und Grundlagen . . . . . . . . . . . . . . .
2.2 Edit-Operationen auf Bäumen . . . . . . . . . . . . . . . . . . . . . . . .
9
12
Vergleich von Bäumen über Edit-Operationen
17
3.1 Baum-Edit-Distanz . . . . . . . . . . . . . . . . . . . . . .
3.1.1 Edit-Distanz-Abbildungen . . . . . . . . . . . . . .
3.1.2 Rekursionsformel zur Berechnung der Edit-Distanz
3.2 Baum-Alignment-Distanz . . . . . . . . . . . . . . . . . . .
3.3 Baum-Inklusion-Problem . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
17
17
21
23
26
Verfahren zur Berechnung der Baum-Edit-Distanz
29
4.1 Zhang-Shasha-Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . .
4.2 Klein-Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
29
37
5
Verfahren zur Berechnung der Baum-Alignment-Distanz
41
6
Approximative Baumsuche
47
6.1 Das approximative Baum-Matching-Problem . . . . . . . . . . . . . . . .
6.2 Approximative Baumsuche nach Jansson und Peng . . . . . . . . . . . .
47
56
7
Implementierung
65
8
Fazit und Ausblick
69
4
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Literaturverzeichnis
71
Abbildungsverzeichnis
73
Algorithmenverzeichnis
75
Kapitel 1. Einleitung
5
1 Einleitung
Verarbeitung von Zeichenketten ist ein wichtiges Teilgebiet der Informatik, und tritt
in vielen Bereichen, wie z.B. der Dokumentenverarbeitung oder Genomforschung, auf.
Eine Wissenschaft die sich mit Textalgorithmen [CR94] beschäftigt nennt man auf englisch auch Stringology. Beruhend auf Stringology entwickelte sich eine Wissenschaft namens Treeology, die Stringology durch mehrdimensionale Strukturen erweitert und sich
statt Zeichenketten mit Bäumen befasst. Im Gegensatz zu Zeichenketten ist ein Baum
ein spezieller Graph und stellt eine mehrdimensionale Struktur dar, mit der sich eine
Monohierarchie modellieren lässt. Bäume gelten als die wichtigsten nicht linearen Datenstrukturen, die im Bereich der Computeralgorithmen eingesetzt werden [Knu69]. So
können viele Vorgänge und Strukturen, die bestimmte Informationen mit sich führen,
in unterschiedlichsten Anwendungsgebieten grafisch und übersichtlich durch Bäume
repräsentiert werden. In der Molekularbiologie wird eine RNA (Ribonukleinsäure), die
ähnlich einer DNA neben Phosphorsäure und Pentose aus den vier Nukleobasen Adenin
(A), Guanin (G), Cytosin (C) sowie Uracil (U) aufgebaut ist und genetische Informationen überträgt, durch eine Zeichenkette über vier Buchstaben A, G, C und U dargestellt.
Dabei lässt sich eine RNA in eine Sekundärstruktur zerlegen, die aus den stabilen Basenpaaren C-G, A-U und schwachen Paaren U-G besteht. Eine RNA-Sekundärstruktur gibt
einen genauen Einblick in die tatsächliche Molekülstruktur der vorliegenden RNA und
kann bequem durch einen Baum repräsentiert werden, dessen Knoten mit bestimmten
Symbolen beschriftet sind (siehe Abbildung 1.1). Da die Knoten eines solchen Baumes beschriftet sind, heißt er ein beschrifteter Baum. Zudem besitzt ein beschrifteter
Baum auch die Eigenschaft, dass bei ihm ein Knoten als Wurzel ausgezeichnet ist. Beschriftete Bäume spielen eine große Rolle in der Informatik als Datenstrukturen für die
Repräsentation hierarchischer Daten. Ein Beispiel dafür liefern die XML-Dokumente,
die in ihrem Aufbau den beschrifteten Bäumen entsprechen [CAM02]. Weiterhin kommen beschriftete Bäume in strukturierten Textdatenbanken vor. Dabei repräsentieren
sie die Struktur der gespeicherten Dokumente und ermöglichen eine effiziente Suche
nach bestimmten Textstellen in ihnen. Auch in vielen anderen Bereichen wie Bildanalyse (Darstellung von 3D-Objekten), Chemie (Molekülgraphen), Compileroptimierung
(Parse- bzw. Ableitungsbäume) oder Genetik (Stammbäume) kommen Bäume ständig
zum Einsatz [JWZ95]. Eines der wichtigsten und oft auftauchenden Probleme in allen
oben genannten Bereichen, besteht im Vergleich von Bäumen. Die modellierten Baumstrukturen müssen oftmals miteinander verglichen und auf Ähnlichkeit überprüft werden, um Aussagen über ihre Beschaffenheit folgern oder bestimmte Strukturen identifizieren zu können. Zum Beispiel können unterschiedliche RNA-Molekülketten ähnliche
Sekundärstrukturen erzeugen [ZS89]. Aus diesem Grund ist es notwendig in der Molekularbiologie RNA-Sekundärstrukturen miteinander zu vergleichen, um Ähnlichkeiten
bezüglich der Funktionalität verschiedener RNAs ausmachen zu können.
6
Approximative Suche in Baumstrukturen
Abbildung 1.1: (a) RNA-Primärstruktur.
(b) RNA-Sekundärstruktur.
(c) Baumrepräsentation der RNA-Sekundärstruktur.
In dieser Arbeit beschäftige ich mich mit den Problemen, die beim Vergleich von beschrifteten Bäumen auftreten. Ein Ziel dabei war es, einen allgemeinen Überblick über
die existierenden Probleme dieser Art in einem einheitlichen und gemeinsamen Rahmen
zu verschaffen. Wie bei Zeichenketten kann die Ähnlichkeit zwischen zwei beschrifteten
Bäumen T1 und T2 über die minimalen Kosten gemessen werden, die notwendig sind,
um den Baum T1 in T2 mit Hilfe von elementaren Edit-Operationen zu transformieren.
Dabei wirken die Edit-Operationen auf einzelne Knoten der Bäume bzw. deren Beschriftungen. Es werden drei elementare Edit-Operationen auf Knoten von Bäumen betrachtet: Umbeschriftung, Löschung und Einfügung von Knoten. Jeder elementaren Operation werden dann, abhängig vom gelöschten, eingesetzten oder bei einer Umbeschriftung
geänderten Symbol eines Knotens, Kosten zugeordnet. Hierbei existieren mehrere Möglichkeiten mit Hilfe von Edit-Operationen die Ähnlichkeit zwischen zwei Bäumen zu
messen. Im Allgemeinen führt der Vergleich von Bäumen über die Edit-Operationen auf
drei zentrale Probleme: die Baum-Edit-Distanz, Baum-Alignment-Distanz und das BaumInklusion-Problem. Alle diese Probleme werden in dieser Arbeit detailliert präsentiert.
Für die Baum-Edit- und Baum-Alignment-Distanz werden die grundlegenden Algorithmen vorgestellt und genau beschrieben. Dabei wird für alle Algorithmen die Zeit- und
Speicherkomlexität analysiert und am Ende die Korrektheit des Algorithmus bewiesen.
Schließlich wird der Übergang von dem Edit-Distanz-Problem auf das sogenannte approximative Baum-Matching-Problem besprochen, wobei hier die Beziehungen zwischen
diesen beiden Problemen in einem gemeinsamen Rahmen ausführlich diskutiert und
hinterher die dazugehörigen Algorithmen beschrieben werden. Beim Baum-MatchingProblem geht es nicht nur darum, die Ähnlichkeit zwischen zwei ganzen Bäumen T1 und
Kapitel 1. Einleitung
7
T2 zu messen, sondern auch darum bestimmte Teilstrukturen von T1 , die durch das Entfernen oder Abschneiden von Knoten aus T1 entstehen können, mit T2 zu vergleichen. In
Abschnitt 6.2 wird außerdem gezeigt wie die Lösung dieses Problems zum Finden von
vorgegebenen Teilstrukturen in einem Baum benutzt werden kann, die zu einem anderen gegebenen Baum, dem sogenannten Pattern-Baum, die größte Ähnlichkeit aufweisen. Ferner werden alle in dieser Arbeit vorgestellten Algorithmen zum Experimentieren
in einem grafischen Java-Tool implementiert, das in Kapitel 7 beschrieben wird.
Kapitel 2. Grundlagen und Definitionen
9
2 Grundlagen und Definitionen
2.1 Grundlegende Schreibweisen und Grundlagen
In diesem Kapitel werden Begriffe erklärt und definiert, die für das Verständnis dieser
Arbeit notwendig sind.
Ein Graph ist ein 2-Tupel G = (V, E), wobei V eine Knotenmenge und E ⊆ {(v, w) | v, w ∈ V }
eine Kantenmenge bezeichnet. Für einen Graph G ist V (G) die Menge der Knoten von
G und E(G) die Menge der Kanten von G. Graphen, deren Kanten eine ausgezeichnete
Richtung aufweisen, sind gerichtet, andernfalls heißen sie ungerichtet. Ein Pfad eines
Graphen G ist eine Folge von Knoten aus V (G), in welcher aufeinander folgende Knoten
durch Kanten verbunden sind und sich kein Knoten wiederholt. Ein Zyklus ist ein Pfad
mit identischen Anfangs- und Endknoten.
Ein Baum ist im Allgemeinen ein ungerichteter, verbundener und zyklenfreier Graph,
d.h, in dem zwischen je zwei beliebigen Knoten genau ein Pfad existiert. Dagegen stellt
ein gewurzelter Baum (engl. rooted tree) einen gerichteten, verbundenen und zyklenfreien Graph dar, bei dem ein bestimmter Knoten als Wurzel ausgezeichnet ist. Gewurzelte
Bäume lassen sich in Out-Trees, bei denen die Kanten von der Wurzel ausgehen, und in
In-Trees, bei denen die Kanten in Richtung Wurzel zeigen, unterscheiden. Alle weiteren
in dieser Arbeit vorkommenden Bäume werden als Out-Trees betrachtet. Die Wurzel eines gewurzelten Baumes T wird als root(T ) bezeichnet. Ferner besitzen die Knoten von
T unterschiedliche Beziehungen untereinander, die im Folgenden erklärt werden. Ein
Knoten v ∈ V (T ) heißt Vorgänger eines Knotens w ∈ V (T ) und umgekehrt w ein Nachfolger von v, wenn es einen Pfad von v nach w gibt. Gilt zusätzlich v 6= w, wobei v auf
einem Pfad von der Wurzel bis zu einem Blatt vor w liegt, dann ist v ein echter Vorgänger
von w und w ein echter Nachfolger von v. Mit anc(v) wird die Menge aller Vorgänger
eines Knotens v ∈ V (T ) angegeben. Sind v und w direkt durch eine Kante verbunden, so
heißt v der Vater von w und w ein Kind von v, falls v der direkte Vorgänger von w, d.h.
(v, w) ∈ E(T ) ist. Für jeden Knoten v ∈ V (T ) bezeichnet p(v) den Vater von v und pk (v)
den k-ten Vorgänger von v mit p0 (v) = v. Zwei Knoten v, w ∈ V (T ) heißen Geschwister,
falls sie denselben Vater haben, d.h. wenn p(v) = p(w) gilt. Ein Knoten, der keine Kinder
bzw. keine echten Nachfolger besitzt, heißt Blatt. Die Menge der Blätter von T wird mit
L(T ) bezeichnet.
Weiterhin unterscheidet man zwischen geordneten und ungeordneten Bäumen. Ein geordneter Baum ist ein Baum, in welchem die Reihenfolge der Kinder eines jeden Knotens von links nach rechts festgelegt ist. Hat ein Knoten v eines geordneten Baumes
die Kinder v1 , v2 , . . . , vi , wobei v1 das linkeste und vi das rechteste Kind in der Folge ist,
10
Approximative Suche in Baumstrukturen
so bezeichnet v1 den ersten Kind von v, v2 den zweiten Kind von v, usw. bis zum i-ten
Kind von v. Ist die Reihenfolge der Kinder von Knoten eines Baumes nicht vorgegeben,
so spricht man von einem ungeordneten Baum. Ein geordneter Wald ist eine Folge von
geordneten Bäumen T1 , . . . , Tk , bei dem die Bäume T1 , . . . , Tk von links nach rechts geordnet sind. Entsprechend bezeichnet ein ungeordneter Wald eine Menge von ungeordneten
Bäumen. Wenn nachfolgend in dieser Arbeit von Baumstrukturen gesprochen wird, dann
können sowohl Bäume als auch Wälder gemeint sein.
Bezeichne im Folgenden θ einen leeren Baum, der keine Knoten enthält und T (v) einen
Teilbaum eines gewurzelten Baumes T , der aus der Wurzel v ∈ V (T ) und allen Nachfolgern von v besteht. Ein Teilwald von T setzt sich aus den Teilbäumen T (v1 ), . . . , T (vk )
zusammen, deren Wurzeln v1 , . . . , vk Geschwister in T sind. Ist v der Vater von diesen Geschwistern, so wird dieser Teilwald mit F(v) bezeichnet. Teilwälder T (v) mit v 6= root(T )
heißen echte Teilwälder von T .
Um auf einzelne Knoten v eines Baumes T verweisen zu können, werden sie mit einer
positiven ganzen Zahl 1 ≤ v ≤ |T |, assoziiert und nach einer bestimmten Ordnung nummeriert, wobei |T | die Anzahl der Knoten in T angibt. Dabei gibt es verschiedene Möglichkeiten die Knoten v zu nummerieren, indem man sie in einer bestimmten Reihenfolge durchläuft. Durchlaufen der Knoten eines Baumes in einer bestimmten Reihenfolge
bezeichnet man als Traversierung. Oft werden die Knoten durch das Traversieren eines Baumes in einer Prä- oder Postordnung nummeriert. Die Präordnung-Traversierung
eines geordneten Baumes T mit der Wurzel v, deren Kinder v1 , . . . vi sind, ergibt sich,
indem man zuerst die Wurzel v besucht und dann rekursiv alle Teilbäume T (vk ) für
1 ≤ k ≤ i von links nach rechts in Präordnung durchläuft. Ähnlich wird der Baum T in
Postordnung traversiert, indem zuerst alle Teilbäume T (vk ) für 1 ≤ k ≤ i rekursiv von
links nach rechts durchlaufen werden und anschließend die Wurzel v besucht wird. Um
sich auch auf bestimmte Knoten eines ungeordneten Baumes beziehen zu können, werden sie in einer beliebigen Reihenfolge fixiert und dann entsprechend der Prä- oder
Postordnung-Traversierung nummeriert. Im weiteren Verlauf dieser Arbeit werden alle
vorkommenden Bäume anhand der Postordnung nummeriert sein, wenn nichts anderes angegeben ist. Jetzt kann durch die Prä- und Postordnung formal definiert werden,
wann ein Knoten v links von einem anderen Knoten w in einem Baum liegt.
Definition 2.1
Sei T ein gewurzelter geordneter Baum und v, w ∈ V (T ). Bezeichne pre(v) die Anzahl der
Knoten, die beim Traversieren von T in Präordnung vor v besucht werden und post(v) ihre
Anzahl analog in Postordnung. Knoten v liegen links von w in T , falls für sie folgende
Bedingung erfüllt ist:
pre(v) < pre(w) und post(v) < post(w).
Liegt v links von w, so befindet sich w rechts von v.
Häufig werden die Knoten eines Baumes T mit Symbolen beschriftet, um sie mit gewissen Informationen auszustatten. Für das Folgende sei Σ ein endliches Alphabet, − ∈
/Σ
e
ein Blank-Symbol und Σ = Σ ∪ − das aus dem Σ und dem Blank-Symbol zusammengesetzte Alphabet. Dann ist ein beschrifteter Baum (engl. labeled tree) über dem Alphabet
Σ ein gewurzelter Baum, bei dem jeder Knoten mit einem Symbol aus Σ beschriftet ist.
Kapitel 2. Grundlagen und Definitionen
11
Ein beschrifteter Wald ist eine Menge von beschrifteten Bäumen. An einigen Stellen in
dieser Arbeit werden Bäume über dem Alphabet Σ mit TΣ bezeichnet. Wenn nicht anders angegeben, werden alle folgenden in dieser Arbeit betrachteten Bäume gewurzelt,
geordnet und über dem Alphabet Σ beschriftet sein, ohne dass es explizit erwähnt wird.
Für jeden Knoten v ∈ V (T ) bezeichnet T [v] die Beschriftung von v. Eine Baumstruktur
bestehend aus allen Knoten u ∈ V (T ) mit v ≤ u ≤ w, für v, w ∈ V (T ), wird als T [v..w]
angegeben. Ist v > w, so ist T [v..w] = θ der leere Baum. Außerdem heißt T [1..w] für
0 ≤ w ≤ |T | ein Präfix von T und T [v..|T |] für 1 ≤ v ≤ |T | + 1 ein Suffix von T , wobei hier
die Knoten von T entsprechend ihrer Postordnung-Traversierung von links nach rechts
nummeriert sind. Weiterhin definiere l(v) für alle v ∈ V (T ), als den Knoten mit der
kleinsten Nummerierung in dem Teilbaum T (v). Bei einer Postordnung der Knoten liefert l(v) stets das linkeste Blatt im Teilbaum T (v). Außerdem gilt dabei T (v) = T [l(v)..v]
sowie F(v) = T [l(v)..v − 1].
Zwei weitere Begriffe, die oft in Zusammenhang mit Bäumen verwendet werden, sind
der Grad und die Tiefe eines Knotens. Der Grad eines Knotens v ∈ V (T ) ist die Anzahl
seiner Kinder und wird mit deg(v) bezeichnet. Die Tiefe eines Knotens v ∈ V (T ) ist die
Anzahl der Kanten auf dem Pfad von root(T ) nach v und wird mit depth(v) bezeichnet.
Beide Begriffe lassen sich auch auf Bäume erweitern. Dann wird der Grad eines Baumes
T als deg(T ) = maxv∈V (T ) {deg(v)} und die Tiefe von T als depth(T ) = maxv∈V (T ) {depth(v)}
definiert.
Die Tabelle 2.1 fasst noch einmal in einer kurzen Übersicht die in dieser Arbeit verwendeten Notationen.
12
Notation
θ
root(T )
|T |
V (T )
E(T )
L(T )
|L(T )|
T [v..w]
T [1..w]
T [v..|T |]
T [v]
T (v)
F(v)
l(v)
p(v)
pk (v)
deg(v)
depth(v)
deg(T )
depth(T )
anc(v)
Approximative Suche in Baumstrukturen
Definition
Der leere Baum bzw. Wald.
Die Wurzel von T .
Die Anzahl der Knoten in T .
Die Menge der Knoten von T .
Die Menge der Kanten von T .
Die Menge der Blätter von T .
Die Anzahl der Blätter in T .
Eine Baumstruktur von T bestehend aus allen Knoten u ∈ V (T ) mit
v ≤ u ≤ w.
Ein Präfix von T mit 0 ≤ w ≤ |T |.
Ein Suffix von T mit 1 ≤ v ≤ |T | + 1.
Die Beschriftung von v.
Ein Teilbaum von T bestehend aus der Wurzel v und allen Nachfolgern
von v. Bei einer Postordnung gilt: T (v) = T [l(v)..v].
Ein Teilwald von T bestehend aus den Teilbäumen von T , deren Wurzeln
Geschwister sind. Bei einer Postordnung gilt: F(v) = T [l(v)..v − 1].
Liefert den Knoten mit der kleinsten Nummerierung im Teilbaum T (v).
Der Vater von v.
Der k-te Vorgänger von v: p0 (v) = v, p1 (v) = p(v), p2 (v) = p(p(v)) usw.
Der Grad von v. Ist die Anzahl der Kinder von v.
Die Tiefe von v. Ist die Anzahl der Kanten auf dem Pfad von root(T )
nach v.
Der Grad von T : deg(T ) = maxv∈V (T ) {deg(v)}.
Die Tiefe von T : depth(T ) = maxv∈V (T ) {depth(v)}.
Die Menge der Vorgänger von v: {pk (v) | 0 ≤ k ≤ depth(v)}.
Tabelle 2.1: Notationen für einen Baum T mit v, w ∈ V (T ).
2.2 Edit-Operationen auf Bäumen
Im eindimensionalen Fall wird eine Zeichenkette mit Hilfe von elementaren EditOperationen in eine andere transformiert. Die elementaren Edit-Operationen wirken
dabei jeweils auf ein Zeichen der Zeichenkette. Basierend auf drei elementaren EditOperationen, Substitution eines Zeichens durch ein anderes, Löschung eines Zeichens,
Einfügung eines Zeichens, stellten Wagner und Fischer [WF74] die Ähnlichkeit von zwei
Zeichenketten fest. Um mit Bäumen analog arbeiten zu können, führte Tai [Tai79] erstmals drei Edit-Operationen ein, die jeweils auf einzelne Knoten bzw. deren Beschriftungen angesetzt werden. Sei T ein geordneter beschrifteter Baum über dem Alphabet Σ.
Dann werden die Edit-Operationen auf T wie folgt definiert:
Definition 2.2 (Edit-Operationen)
Umbeschriftung eines Knotens v in T : Ersetze das Symbol des Knotens v durch ein anderes
Symbol aus Σ.
Löschung eines Knotens v in T : Für einen Nicht-Wurzelknoten v mit dem Vater v0 verschie-
Kapitel 2. Grundlagen und Definitionen
13
be die Kanten zwischen v und seinen Kindern (falls vorhanden) so, dass die Kinder
von v nach der Verschiebung die Kinder von v0 werden und die festgelegte Reihenfolge der Kinder erhalten bleibt. Anschließend entferne den Knoten v und die Kante (v0 , v) ∈ E(T ). Für einen Wurzelknoten v entferne v und alle Kanten (v, w) mit
p(w) = v.
Einfügung eines Knotens v in T : Das Komplement von Löschen. Füge den Knoten v als Kind
von v0 ein und verschiebe die Kanten zwischen v0 und einer Teilfolge seiner Kinder (falls
vorhanden) so, dass die Kinder dieser Teilfolge nach der Verschiebung die Kinder von
v werden und die festgelegte Reihenfolge der Kinder erhalten bleibt.
Abbildung 2.1 veranschaulicht die drei Edit-Operationen. Für einen ungeordneten beschrifteten Baum können die Edit-Operationen ähnlich definiert werden. Dabei arbeiten
die Operationen Löschung und Einfügung mit Teilmengen von Knoten und nicht mit Teilfolgen, so dass in diesem Fall die Reihenfolge der Kinder eines Knotens unwesentlich ist.
Seien T1 und T2 beschriftete Bäume. In Anlehnung an [WF74] und [Tai79] wird eine
e × Σ)\(−,
e
Edit-Operation als ein Paar (a, b) ∈ (Σ
−) repräsentiert. Hierbei bezeichnet a
entweder ein Symbol eines Knotens v ∈ V (T1 ) oder das Blank-Symbol „−“. Analog bezeichnet b entweder ein Symbol eines Knotens w ∈ V (T2 ) oder das Blank-Symbol „−“.
Man schreibt auch a → b für das Paar (a, b)1 . Damit kann eine Edit-Operation durch
folgende drei Möglichkeiten gemäß der Definition 2.2 angegeben werden:
(1) Ist a 6= − und b 6= −, dann repräsentiert das Paar (a, b) die Umbeschriftung eines
Knotens v ∈ T1 mit dem Symbol a durch das Symbol b.
(2) Ist a 6= − und b = −, dann repräsentiert das Paar (a, b) die Löschung eines Knotens
v mit dem Symbol a in T1 .
(3) Ist a = − und b 6= −, dann repräsentiert das Paar (a, b) die Einfügung eines Knotens
w mit dem Symbol b in T1 .
Geht der Baum T1 durch Anwendung einer Edit-Operation a → b in den Baum T2 über,
(a,b)
so schreibt man T1 ==⇒ T2 .
Definition 2.3 (Baum-Transformation)
Sei S eine Folge s1 , . . . , sk von Edit-Operationen. S transformiert T1 in T2 , wenn es eine Folge
s
von Bäumen A0 , . . . , Ak gibt, so dass T1 = A0 , T2 = Ak und Ai−1 ⇒
=i Ai für 1 ≤ i ≤ k.
Die Abbildung 2.2 zeigt ein Beispiel einer Baum-Transformation.
Um verschiedene Edit-Operationen unterschiedlich zu gewichten, wird eine Kostenfunke × Σ)
e → R definiert. Jeder Edit-Operation a → b werden dann abhängig von
tion γ : (Σ
den in ihr auftretenden Symbolen a, b Kosten zugeordnet. Die Kostenfunktion bildet ein
paar von Symbolen auf eine nichtnegative reelle Zahl ab und stellt stets eine Distanze gilt:
Metrik dar. D.h. für alle a, b, c ∈ Σ
1 Da
mehrere Knoten mit demselben Symbol beschriftet sein können, ist diese Schreibweise mehrdeutig.
Nichtsdestotrotz wird im Folgenden aus dem Kontext immer klar sein, welcher Knoten gemeint ist.
14
Approximative Suche in Baumstrukturen
T1
T2
a
b
(a) Umbeschriftung eines Knotens mit
dem Symbol a durch das Symbol b.
T1
T2
a
a
F
b
F
(b) Löschung eines Knotens mit dem
Symbol b. F bezeichnet den Wald bestehend aus Bäumen, deren Wurzeln
die Kinder des Knotens mit dem Symbol b sind.
T1
T2
a
a
F
b
F
(c) Einfügung eines Knotens mit dem
Symbol b. F bezeichnet den Wald bestehend aus Bäumen, deren Wurzeln
die Knoten einer Teilfolge von Kindern des Knotens mit dem Symbol a
sind.
Abbildung 2.1: Edit-Operationen auf Bäumen.
15
Kapitel 2. Grundlagen und Definitionen
f
f
d
a
e
d
(c,–)
c
a
b
f
e
c
(–,c)
b
f
e
c
(e,d)
d
a
d
d
b
a
b
Abbildung 2.2: Baum-Transformation.
(1) γ(a, b) ≥ 0,
(2) γ(a, a) = 0,
(3) γ(a, b) = γ(b, a),
(4) γ(a, c) ≤ γ(a, b) + γ(b, c).
Durch Erweiterung der Kostenfunktion γ auf eine Folge S = s1 , . . . , sk von EditOperationen, mit γ(S) = ∑ki=1 γ(si ), werden die Kosten einer gesamten BaumTransformation angegeben.
17
Kapitel 3. Vergleich von Bäumen über Edit-Operationen
3 Vergleich von Bäumen über
Edit-Operationen
3.1 Baum-Edit-Distanz
3.1.1 Edit-Distanz-Abbildungen
Basierend auf einer Folge von Edit-Operationen wird ein Baum in einen anderen transformiert. Ziel ist es damit den Abstand bezüglich der Ähnlichkeit zwischen zwei Bäumen
zu berechnen. Daher wird für Bäume der Abstandsbegriff, genannt Baum-Edit-Distanz,
über die minimalen Kosten aller Folgen von Edit-Operationen festgelegt, die einen Baum
in einen anderen transformieren.
Definition 3.1 (Baum-Edit-Distanz)
Seien T1 und T2 beschriftete Bäume (geordnet oder ungeordnet) und sei eine Kostenfunktion
e × Σ)
e → R gegeben. Dann wird die Baum-Edit-Distanz zwischen T1 und T2 formal
γ : (Σ
folgendermaßen definiert:
δ (T1 , T2 ) = min{γ(S) | S ist eine Folge von Edit-Operationen, die T1 in T2 transformiert}.
Dabei gelten für δ alle Eigenschaften der Kostenfunktion γ, so dass δ ebenfalls eine
Distanz-Metrik ist. Die Bestimmung von δ (T1 , T2 ) wird in der englischen Literatur häufig
auch als das „tree-to-tree correction problem“ [Tai79] bezeichnet.
Entsprechend der Definition 3.1 für Edit-Distanz, gibt es unendlich viele Folgen von
Edit-Operationen, die den Baum T1 in T2 transformieren. Aus diesem Grund wird es unmöglich sein, alle gültigen Folgen von Edit-Operationen durchzugehen und die Folge mit
f
f
d
a
e
c
c
b
d
d
a
b
Abbildung 3.1: Edit-Distanz-Abbildung.
18
Approximative Suche in Baumstrukturen
den minimalen Kosten in überschaubarer Zeit zu bestimmen. Daher bedient man sich
eines Hilfsmittels und definiert spezielle Strukturen namens Edit-Distanz-Abbildungen
(engl. edit distance mappings), die eine effiziente Bestimmung der Edit-Distanz ermöglichen. Eine Edit-Distanz-Abbildung zwischen T1 und T2 stellt eine grafische Beschreibung
einer Folge von Edit-Operationen dar, die T1 in T2 transformiert. Im Gegensatz zu einer
Folge von Edit-Operationen ist die Reihenfolge der Anwendung von Edit-Operationen
bei einer Edit-Distanz-Abbildung unwichtig. Die Abbildung 3.1 zeigt beispielhaft eine
Edit-Distanz-Abbildung, welche mit der Folge von Edit-Operation aus Abbildung 2.2
korrespondiert. Dabei stehen zwei Knoten v ∈ T1 und w ∈ T2 , die durch eine Linie miteinander verbunden sind, in Korrespondenz. Eine derartige Korrespondenz repräsentiert
die Umbeschriftung des Knotens v mit dem Symbol T1 [v] durch das Symbol T2 [w], falls
T1 [v] 6= T2 [w] ist. Wenn die Symbole T1 [v] und T2 [w] gleich sind, bleiben beide Knoten
unverändert. Alle Knoten in T1 , die mit keinem Knoten aus T2 in Korrespondenz stehen, sind zu löschen. Umgekehrt sind alle Knoten in T2 , die mit keinem Knoten aus T1
in Korrespondenz stehen, in T1 einzufügen. Damit führt die Anwendung der grafischen
Vorschrift einer Edit-Distanz-Abbildung zwischen T1 und T2 analog der Folge von EditOperationen zu einer Transformation des Baumes T1 in T2 . Übereinstimmend mit der
Repräsentation einer Edit-Operation aus dem Abschnitt 2.2 werden die grafischen Beziehungen der gestrichelten Linie zwischen zwei Knoten bzw. Korrespondenzen durch
Paare ganzer Zahlen ausgedrückt. Für jede zwei Knoten v ∈ T1 und w ∈ T2 , die miteinander in Korrespondenz stehen, schreibt man das Paar (v, w). Die folgende Definition führt
diese informale Erklärung für geordnete Bäume formal aus.
Definition 3.2 (Geordnete Edit-Distanz-Abbildung)
Seien T1 , T2 geordnete beschriftete Bäume. Ein Tripel (M, T1 , T2 ) heißt eine geordnete EditDistanz-Abbildung zwischen T1 und T2 , falls M ⊆ {(v, w) | v ∈ V (T1 ), w ∈ V (T2 )} und für alle
Paare (v1 , w1 ), (v2 , w2 ) ∈ M folgende Eigenschaften gelten:
(1) v1 = v2 ⇐⇒ w1 = w2 (Eins-zu-eins-Bedingung),
(2) v1 ist ein Vorgänger von v2 ⇐⇒ w1 ist ein Vorgänger von w2 (Vorgänger-Bedingung),
(3) v1 liegt links von v2 ⇐⇒ w1 liegt links von w2 (Geschwister-Bedingung).
Die Bedingung (1) stellt sicher, dass jeder Knoten eines Baumes höchstens einmal mit
einem Knoten eines anderen Baumes in Korrespondenz steht. Damit verhindert man,
dass auf das Ergebnis einer Edit-Operation eine weitere Edit-Operation angewendet
wird. Die Bedingungen (2) und (3) stellen sicher, dass nachdem die nicht in einer
Korrespondenz stehenden Knoten aus T1 und T2 entfernt werden, T1 und T2 bezüglich
ihrer Struktur identisch sind. Hiermit sorgen diese Bedingungen dafür, dass nach der
Transformation, T1 die Struktur von T2 annimmt und dabei die festgelegte Ordnung
unter den Geschwistern in T2 bewahrt wird. Eine ungeordnete Edit-Distanz-Abbildung
zwischen zwei ungeordneten Bäumen wird auf die gleiche Weise definiert, jedoch ohne die Geschwister-Bedingung (3). Wenn es aus dem Kontext ersichtlich ist, wird statt
eines Tripels (M, T1 , T2 ) kurz M geschrieben.
Sei (M, T1 , T2 ) eine Edit-Distanz-Abbildung. Dann bezeichnet Mv = {v | (v, w) ∈ M} die
links-korrespondierende Menge von M und R1 = V (T1 )\Mv entsprechend die links-
19
Kapitel 3. Vergleich von Bäumen über Edit-Operationen
nicht-korrespondierende Menge von M. Analog ist die rechts-korrespondierende Menge
Mw = {w | (v, w) ∈ M} und die rechts-nicht-korrespondierende Menge R2 = V (T2 )\Mw von
M definiert. Des Weiteren werden die Kosten einer Edit-Distanz-Abbildung M wie folgt
angegeben:
γ(M) =
∑
γ(T1 [v], T2 [w]) +
(v,w)∈M
∑ γ(T1[v], −) + ∑
v∈R1
γ(−, T2 [w])
w∈R2
Die Edit-Distanz δ (T1 , T2 ) kann über die minimalen Kosten aller Edit-DistanzAbbildungen zwischen T1 und T2 bestimmt werden.
Satz 3.1
Seien T1 und T2 beschriftete Bäume (geordnet oder ungeordnet) und sei eine Kostenfunktion
e × Σ)
e → R gegeben. Dann gilt:
γ : (Σ
δ (T1 , T2 ) = min{γ(M) | (M, T1 , T2 ) ist eine Edit-Distanz-Abbildung}.
Für den Beweis dieses Satzes müssen zunächst Aussagen über die Komposition von EditDistanz-Abbildungen verifiziert werden.
Satz 3.2
Seien T1 , T2 und T3 beschriftete Bäume. Sei weiterhin (M1 , T1 , T2 ) und (M2 , T2 , T3 ) eine EditDistanz-Abbildung. Dann ist:
(1) M1 ◦ M2 = {(v, w) | ∃u ∈ V (T2 ), so dass (v, u) ∈ M1 und (u, w) ∈ M2 } eine Edit-DistanzAbbildung zwischen T1 und T3 ,
(2) γ(M1 ◦ M2 ) ≤ γ(M1 ) + γ(M2 ).
Beweis:
(1) Seien (v1 , w1 ), (v2 , w2 ) ∈ M1 ◦ M2 . Dann existiert ein u1 und ein u2 , so dass
(v1 , u1 ), (v2 , u2 ) ∈ M1 und (u1 , w1 ), (u2 , w2 ) ∈ M2 ist. Aus der Definition 3.2 einer EditDistanz-Abbildung folgt:
(a) (v1 = v2 ⇐⇒ u1 = u2 ) und (u1 = u2 ⇐⇒ w1 = w2 ) =⇒ (v1 = v2 ⇐⇒ w1 = w2 ),
(b) (v1 ist ein Vorgänger von v2 ⇐⇒ u1 ist ein Vorgänger von u2 )
und (u1 ist ein Vorgänger von u2 ⇐⇒ w1 ist ein Vorgänger von w2 )
=⇒ (v1 ist ein Vorgänger von v2 ⇐⇒ w1 ist ein Vorgänger von w2 ),
(c) (v1 liegt links von v2 ⇐⇒ u1 liegt links von u2 )
und (u1 liegt links von u2 ⇐⇒ w1 liegt links von w2 )
=⇒ (v1 liegt links von v2 ⇐⇒ w1 liegt links von w2 ).
Folglich ist (M1 ◦ M2 , T1 , T3 ) laut der Definition 3.2 eine Edit-Distanz-Abbildung.
(2) Sei (M1 , T1 , T2 ) und (M2 , T2 , T3 ) eine Edit-Distanz-Abbildung. Sei (M1 ◦ M2 , T1 , T3 ) die
durch Komposition zusammengesetzte Edit-Distanz-Abbildung. Ferner sei R1 die
links-nicht-korrespondierende Menge und R2 die rechts-nicht-korrespondierende
Menge von M1 ◦ M2 . Dann treten im Zusammenhang mit M1 ◦ M2 drei Fälle auf:
20
Approximative Suche in Baumstrukturen
(v, w) ∈ M1 ◦ M2 , v ∈ R1 oder w ∈ R2 . Jeder Fall korrespondiert mit einer EditOperation, (T1 [v], T3 [w]), (T1 [v], −) oder (−, T3 [w]). Bei der Berechnung von Kosten
dieser Edit-Operationen gilt stets die Dreiecksungleichung der Distanz-Metrik γ,
d.h. γ(T1 [v], T3 [w]) ≤ γ(T1 [v], T2 [u]) + γ(T2 [u], T3 [w]).
• Ist (v, w) ∈ M1 ◦ M2 , dann gilt:
∑
γ(T1 [v], T3 [w]) ≤
(v,w)∈M1 ◦M2
∑
γ(T1 [v], T2 [u]) +
(v,u)∈M1
γ(T2 [u], T3 [w]).
∑
(u,w)∈M2
• Ist v ∈ R1 , dann zerfällt die Menge R1 in Knoten v0 , die mit Knoten u ∈ T2
in Korrespondenz stehen und in Knoten v00 , die nicht mit Knoten u ∈ T2 in
Korrespondenz stehen. Es gilt:
∑ γ(T1[v], −) ≤ ∑ γ(T1[v0], T2[u]) + γ(T2[u], −) + ∑ γ(T1[v00], −).
v∈R1
(v0 ,u)∈M1
v00 ∈R1
• Ist w ∈ R2 , dann zerfällt die Menge R2 in Knoten w0 , die mit Knoten u ∈ T2
in Korrespondenz stehen, und in Knoten w00 , die nicht mit Knoten u ∈ T2 in
Korrespondenz stehen. Es gilt:
∑ γ(−, T3[w]) ≤ ∑ γ(−, T2[u]) + γ(T2[u], T3[w0]) + ∑ γ(−, T3[w00]).
w∈R2
(u,w0 )∈M2
w00 ∈R2
Insgesamt folgt also γ(M1 ◦ M2 ) ≤ γ(M1 ) + γ(M2 ).
Folgender Satz stellt die Beziehung zwischen einer Edit-Distanz-Abbildung und einer
Folge von Edit-Operationen her.
Satz 3.3
(1) Für jede Edit-Distanz-Abbildung (M, T1 , T2 ) gibt es eine Folge S = s1 , . . . , sk von EditOperationen, die T1 in T2 transformiert, mit γ(S) = γ(M).
(2) Umgekehrt gibt es für jede Folge S = s1 , . . . , sk von Edit-Operationen, die T1 in T2
transformiert, eine Edit-Distanz-Abbildung (M, T1 , T2 ) mit γ(M) ≤ γ(S).
Beweis:
(1) Sei (M, T1 , T2 ) eine Edit-Distanz-Abbildung. Seien R1 , R2 entsprechend die linksnicht-korrespondierende und die rechts-nicht-korrespondierende Menge von M.
Setze:
S = ((T1 [v], T2 [w]) für (v, w) ∈ M, (T1 [v], −) für v ∈ R1 , (−, T2 [w]) für w ∈ R2 ) .
Offensichtlich transformiert die Folge S den Baum T1 in T2 mit γ(S) = γ(M).
(2) Sei S eine Folge s1 , . . . , sk von Edit-Operationen. S transformiert T1 in T2 , d.h. es
s
gibt eine Folge von Bäumen A0 , . . . , Ak , so dass T1 = A0 , T2 = Ak und Ai−1 ⇒
=i Ai für
1 ≤ i ≤ k. Die Behauptung zeigt man dann durch vollständige Induktion:
Kapitel 3. Vergleich von Bäumen über Edit-Operationen
21
• k = 0: Dann ist T1 = T2 und S = (). Setze M = {(v, v) | v ∈ V (T1 )}, dann ist
(M, T1 , T2 ) eine Edit-Distanz-Abbildung und es folgt γ(S) = γ(M) = 0.
• k > 0: Sei S1 eine Folge s1 , . . . , sk−1 von Edit-Operationen, die T1 in Ak−1 transformiert. Laut Induktionsvoraussetzung existiert eine Edit-Distanz-Abbildung
(M1 , T1 , Ak−1 ), so dass γ(M1 ) ≤ γ(S1 ) ist. Sei (M2 , Ak−1 , T2 ) eine Edit-DistanzAbbildung für die Edit-Operation sk . Aus Satz 3.2 folgt:
γ(M1 ◦ M2 ) ≤ γ(M1 ) + γ(M2 ) ≤ γ(S1 ) + γ(sk ) = γ(S).
Der Beweis für den Satz 3.1 folgt sofort aus der oben gezeigten Beziehung zwischen
einer Edit-Distanz-Abbildung und einer Folge von Edit-Operationen. Damit kann die
Berechnung der Edit-Distanz auf die Suche nach einer Edit-Distanz-Abbildung mit minimalen Kosten reduziert werden. Eine Edit-Diszanz-Abbildung zwischen zwei Bäumen
T1 und T2 mit minimalen Kosten wird als eine optimale Edit-Distanz-Abbildung zwischen
T1 und T2 bezeichnet. Die Definition der Baum-Edit-Distanz lässt sich ohne Weiteres auf
Wälder verallgemeinern und wird demgemäß als Wald-Edit-Distanz bezeichnet. Demzufolge bezeichnet δ (F1 , F2 ) die Edit-Distanz zwischen einem Wald F1 und F2 . Hierbei
sind die Edit-Operationen für Bäume und Wälder gleich definiert. Die Definition der
Edit-Distanz-Abbildung wird analog auf Wälder erweitert.
3.1.2 Rekursionsformel zur Berechnung der Edit-Distanz
In der Wissenschaftlichen Publikation von Zhang und Shasha [ZS89] findet sich eine
Rekursionsformel, mit der es möglich ist unter Ausnutzung dynamischer Programmiermethoden [CSRL01] die Edit-Distanz zwischen zwei Bäumen zu berechnen. Dabei wird
eine optimale Gesamtlösung aus optimalen Lösungen von Teilproblemen konstruiert.
Diese Rekursionsformel bildet die Basis für weitere dynamische Programmieralgorithmen zur Berechnung der Edit-Distanz, die in folgendem Kapitel dieser Arbeit vorgestellt
werden.
Satz 3.4
Seien T1 und T2 geordnete Bäume, deren Knoten in Postordnung von links nach rechts
durchnummeriert sind. Seien v ∈ V (T1 ), w ∈ V (T2 ), i ∈ {l(v), . . . , v} und j ∈ {l(w), . . . , w}.
Dann gelten folgende Rekursionen:
(1) δ (θ , θ ) = 0,
(2) δ (T1 [l(v)..i], θ ) = δ (T1 [l(v)..i − 1], θ ) + γ(T1 [i], −),
(3) δ (θ , T2 [l(w).. j]) = δ (θ , T2 [l(w).. j − 1]) + γ(−, T2 [ j]),


δ (T1 [l(v)..i − 1], T2 [l(w).. j]) + γ(T1 [i], −),





δ (T1 [l(v)..i], T2 [l(w).. j − 1]) + γ(−, T2 [ j]),
(4) δ (T1 [l(v)..i], T2 [l(w).. j]) = min δ (T1 [l(v)..l(i) − 1], T2 [l(w)..l( j) − 1])



+δ (T1 [l(i)..i − 1], T2 [l( j).. j − 1])



 +γ(T [i], T [ j]).
1
2
22
Approximative Suche in Baumstrukturen
(i,j)
...
...
T1[l(v)..l(i)-1]
T1[l(i)..i-1]
T2[l(w)..l(j)-1]
T2[l(j)..j-1]
Abbildung 3.2: Dritter Fall der Rekursionsformel (4) des Satzes 3.4.
Beweis:
Im ersten Fall müssen keine Edit-Operationen ausgeführt werden. Für die Kosten im
zweiten Fall werden nur Lösch-Operationen und im dritten Fall nur Einfüge-Operationen
berücksichtigt. Im vierten Fall wird eine optimale Edit-Distanz-Abbildung M zwischen
T1 [l(v)..i] und T2 [l(w).. j] betrachtet, wobei R1 die links-nicht-korrespondierende und R2
die rechts-nicht-korrespondierende Menge von M bezeichnet. Dabei ergeben sich für die
Knoten i ∈ T1 [l(v)..i] und j ∈ T2 [l(w).. j] insgesamt folgende drei Möglichkeiten:
• i ∈ R1 : Dann muss i in T1 [l(v)..i] gelöscht werden. Also,
δ (T1 [l(v)..i], T2 [l(w).. j]) = δ (T1 [l(v)..i − 1], T2 [l(w).. j]) + γ(T1 [i], −).
• j ∈ R2 : Dann muss j in T1 [l(v)..i] eingefügt werden. Also,
δ (T1 [l(v)..i], T2 [l(w).. j]) = δ (T1 [l(v)..i], T2 [l(w).. j − 1]) + γ(−, T2 [ j]).
• i steht in Korrespondenz mit j : Dann ist (i, j) ∈ M. Diese Feststellung leitet sich
aus folgender Überlegung heraus. Angenommen (i, h), (k, j) ∈ M. Falls l(v) ≤ k ≤
l(i) − 1, dann liegt i rechts von k. Aus der Geschwister-Bedingung (3) folgt, dass
hier auch h rechts von j liegen muss. Falls l(i) ≤ k < i, dann ist i ein echter Vorgänger von k. Entsprechend der Vorgänger-Bedingung (2) muss h auch ein echter
Vorgänger von j sein. Da aber i und j die rechtesten Wurzeln der Wälder T1 [l(v)..i]
und T2 [l(w).. j] sind, können diese beiden Fälle nicht auftreten. Also folgt k = i. Aus
der Eins-zu-eins-Bedingung (1) ergibt sich schließlich h = j und (i, j) ∈ M.
Durch die Vorgänger-Bedingung (2) der Edit-Distanz-Abbildung können Knoten
des Teilbaumes mit der Wurzel i nur auf Knoten des Teilbaumes mit der Wurzel j
abgebildet werden (siehe Abbildung 3.2). Daher folgt:
δ (T1 [l(v)..i], T2 [l(w).. j]) = δ (T1 [l(v)..l(i) − 1], T2 [l(w)..l( j) − 1]
+δ (T1 [l(i)..i − 1], T2 [l( j).. j − 1]) + γ(T1 [i], T2 [ j]).
Da die oben diskutierten Möglichkeiten alle Fälle einer Edit-Distanz-Abbildung zwischen
T1 [l(v)..i] und T2 [l(w).. j] abdecken und nur eine optimale Edit-Distanz-Abbildung von
Interesse ist, bildet man anschließend das Minimum ihrer Kosten.
23
Kapitel 3. Vergleich von Bäumen über Edit-Operationen
3.2 Baum-Alignment-Distanz
Eine andere Möglichkeit die Ähnlichkeit von Bäumen festzustellen, die ebenfalls auf
Edit-Operationen beruht, bietet die Baum-Alignment-Distanz. Trotz der guten und
sinnvollen Ergebnisse einer Distanzmessung zweier Baumstrukturen über die EditDistanz, hat man damit in bestimmten Bereichen, z.B. beim Vergleich der RNASekundärstrukturen, nur ein approximierendes Verfahren der wirklichen funktionalen
Ähnlichkeit. Viele morphologische oder genetische Probleme, die eine Modellierung mit
ungeordneten Bäumen erfordern, sind mit Edit-Distanz-Algorithmen nur schwer zu lösen. So ist die Bestimmung der Edit-Distanz zweier ungeordneter Bäume bereits NP-hart
[ZSS92]. Um diese Schwierigkeiten überwinden zu können, führten Jiang, Wang und
Zhang in [JWZ95] erstmals ein anderes Messungsverfahren der Ähnlichkeit von Bäumen ein, das auf ihren Ausrichtungen (engl. alignments) basiert.
Zwei Bäume T1 und T2 werden gegeneinander ausgerichtet, indem in T1 und T2 Knoten
beschriftet mit Blank-Symbolen derart eingefügt werden, dass die resultierenden Bäume
0
0
T1 und T2 bezüglich ihrer Struktur identisch sind. Eine Ausrichtung A von Bäumen T1
0
0
und T2 ergibt sich anschließend, indem T1 mit T2 überlagert wird. Demgemäß stellt eine
Ausrichtung von T1 und T2 einen Baum dar, dessen Knoten infolge der Überlagerung
0
0
e × Σ)\(−,
e
−) von Symbolen beschriftet sind. Ein
von T1 mit T2 mit Paaren (a, b) ∈ (Σ
0
0
solches Paar setzt sich aus einem Symbol a ∈ T1 und b ∈ T2 zusammen (siehe Abbildung
3.3). Formal lässt sich die Definition einer Ausrichtung von Zeichenketten auf Bäume
transferieren (vgl. [Par07]). Dazu sei zunächt der Kompressionsoperator µ auf Knoten v
von T durch
(
lösche v,
falls T [v] = −
µ(v) =
keine Operation, sonst
0
gegeben. Dann sei µ : Te → TΣ der durch den Kompressionsoperator gegebene HomoΣ
e auf Bäume T 0 über Σ ab,
morphismus. Der Homomorphismus µ bildet Bäume T über Σ
indem er auf alle Knoten von T den Kompressionsoperator µ anwendet.
Definition 3.3 (Ausrichtung)
0
0
e die folgende Eigenschaften
Seien T1 und T2 Bäume über Σ. Seien T1 und T2 Bäume über Σ,
erfüllen:
0
0
(1) µ(T1 ) = T1 und µ(T2 ) = T2 ,
0
0
(2) T1 und T2 sind bezüglich ihrer Struktur identisch,
0
0
0
(3) Es ist T1 [i] 6= − oder T2 [i] 6= −, für 1 ≤ i ≤ |T1 |.
0
0
Dann ist die Ausrichtung A von T1 und T2 , der aus der Überlagerung von T1 mit T2 resultierende Baum.
Sei A eine Ausrichtung von T1 und T2 . Dann werden die Kosten von A, als die Summe
24
Approximative Suche in Baumstrukturen
aller Paare von Symbolen der Knoten von A angegeben:
γ(A) =
∑
γ(A[v]).
v∈V (A)
Die Baum-Alignment-Distanz wird als Kosten einer Ausrichtung von zwei Bäumen T1
und T2 definiert, die unter allen möglichen Ausrichtungen von T1 und T2 die minimalen
Kosten liefert.
Definition 3.4 (Baum-Alignment-Distanz)
Seien T1 und T2 beschriftete Bäume (geordnet oder ungeordnet) und sei eine Kostenfunktion
e × Σ)
e → R gegeben. Dann wird die Baum-Alignment-Distanz zwischen T1 und T2
γ : (Σ
formal folgendermaßen definiert:
α(T1 , T2 ) = min{γ(A) | A ist eine Ausrichtung von T1 und T2 }.
Eine optimale Ausrichtung von T1 und T2 ist eine Ausrichtung A∗ von T1 und T2 , deren
Kosten minimal sind, d.h. eine Ausrichtung für die
α(T1 , T2 ) = γ(A∗ )
gilt. Die Definition der Ausrichtung von Bäumen lässt sich auch auf Wälder erweitern.
Im Vergleich zu Bäumen wird bei den Wäldern auch eine Einfüge-Operation zugelassen, die einen Knoten als Wurzel einfügt, der eine aufeinander folgende Teilfolge (bei
geordneten Wäldern) bzw. eine Teilmenge (bei ungeordneten Wäldern) von einzelnen
Bäumen des Waldes miteinander verbindet. Im Falle von Wäldern bezeichnet α(F1 , F2 )
die Alignment-Distanz zwischen einem Wald F1 und F2 .
Bekanntlich liefern die Edit- und Alignment-Distanz zwischen zwei beliebigen Zeichenketten den gleichen Wert und sind deshalb für Zeichenketten äquivalent. Im Gegensatz dazu ergeben sich für die Edit- und Alignment-Distanz im Fall der Bäume unterschiedliche Resultate. Die Baum-Alignment Distanz stellt einen Spezialfall der BaumEdit-Distanz dar. Sie korrespondiert mit der beschränkten Baum-Edit-Distanz, wo alle
Einfüge- vor Lösch-Operationen ausgeführt werden müssen. Aus diesem Grund gilt stets
δ (T1 , T2 ) ≤ α(T1 , T2 ).
Beispiel:
Als Beispiel betrachte die zwei gegebenen Bäume T1 und T2 in Abbildung 3.3. Nehme
weiterhin an, dass alle Edit-Operationen die Kosten 1 haben. Eine optimale Folge von
Edit-Operationen, deren Kosten die Edit-Distanz liefern, ergibt sich, wenn zuerst der
Knoten mit dem Symbol e gelöscht und anschließend der Knoten mit dem Symbol f
in T1 eingefügt wird. Folglich hat die Edit-Distanz zwischen T1 und T2 den Wert 2. Da
die Kosten der optimalen Ausrichtung von T1 und T2 in Abbildung 3.3 aber den Wert 4
haben, beträgt die Baum-Alignment-Distanz α(T1 , T2 ) = 4.
Ein weiteres Unterschied zwischen der Baum-Edit- und Baum-Alignment-Distanz besteht in der Komplexität ihrer geordneten und ungeordneten Probleme. Für ungeordnete Bäume kann das Alignment-Problem in polynomieller Zeit gelöst werden, wenn die
25
Kapitel 3. Vergleich von Bäumen über Edit-Operationen
T1
T2
a
e
b
d
a
b
f
c
c
d
(a)
T 1'
T 2'
a
–
e
b
c
–
a
–
d
b
f
–
c
d
(b)
A
(a,a)
(e,–)
(–, f )
(b,b) (c,–)
(–,c) (d,d)
(c)
Abbildung 3.3: (a) Bäume T1 und T2 .
0
0
(b) Ausgerichtete Bäume T1 und T2 .
(c) Eine Optimale Ausrichtung von T1 und T2 .
vorgegebenen Bäume in ihrem Grad beschränkt sind. Jiang, Wang und Zhang gaben für
diesen Fall in [JWZ95] einen Algorithmus an, der die ungeordnete Baum-AlignmentDistanz in O(|T1 | · |T2 |) Zeit berechnet. Ist der Grad eines Baumes nicht beschränkt, so
gehört das Alignment-Problem zur Komplexitätsklasse NP-Hart [JWZ95]. Im Gegensatz
dazu gehört die Bestimmung der ungeordneten Baum-Edit-Distanz in beiden Fällen zu
den Problemen aus der Komplexitätsklasse NP-hart [ZSS92]. Zhang und Jiang haben
sich in [ZJ94] genauer mit der Analyse des ungeordneten Edit-Distanz-Problems auseinander gesetzt. Darin zeigten sie, dass die Bestimmung der Edit-Distanz zwischen
ungeordneten Bäumen zu den Problemen aus der Komplexitätsklasse MAX SNP-hart
zählt1 .
1 Die
Komplexitätsklasse MAX SNP-hart wurde erstmals von Papadimitriou und Yannakakis in [PY88]
definiert.
26
Approximative Suche in Baumstrukturen
3.3 Baum-Inklusion-Problem
Neben der Baum-Edit- und der Baum-Alignment-Distanz führt der Vergleich von Bäumen mit Hilfe von Edit-Operationen auf das sogenannte Baum-Inklusion-Problem. Dabei
geht es um die Beantwortung der Frage, ob sich ein gegebener Baum P bzw. der PatternBaum aus einem anderen gegebenen Baum T erhalten lässt, wenn mehrere Knoten aus
T gelöscht werden können. Man sagt auch, dass der Baum P in dem Baum T eingeschlossen ist, wenn sich P durch Löschung von Null oder mehr Knoten aus T ergeben
kann. Falls dem so ist, interessiert man sich für die Knoten von T , die nicht gelöscht
wurden bzw. für den kleinsten Teilwald von T , der P einschließt. Ist der Pattern-Baum
P nicht in T eingeschlossen, dann ist zumindest ein Teilbaum von T erwägenswert, der
zu P am ähnlichsten ist. Daher ähnelt dieses Problem dem in Kapitel 6 beschriebenen
approximativen Baum-Matching-Problem, wo es darum geht, bestimmte Teilstrukturen
in einem gegebenen Baum zu finden, die zu einem anderen gegebenen Baum am ähnlichsten sind.
Das Baum-Inklusion-Problem tritt häufig in Zusammenhang mit strukturierten Textdatenbanken auf. Eine strukturierte Textdatenbank stellt eine Sammlung von Parse- bzw.
Ableitungsbäumen dar, die die Struktur von den gespeicherten Dokumenten repräsentieren [GT87, TSM91]. In vielen Fällen werden Abfragen an eine Textdatenbank gerichtet, in denen bestimmte Textpassagen eines Dokumentes gefunden und, falls vorhanden,
abgerufen werden sollen. Dabei enthalten die Abfragen meistens keine feste Vorgaben,
sondern gewisse Muster, die zu mehreren unterschiedlichen Textstellen passen. Als Beispiel sollen hier Anfragen an eine Textdatenbank über grammatikalische Strukturen
einer natürlichen Sprache betrachtet werden. Abbildung 3.4a zeigt beispielhaft einen
Parsebaum eines Satzes der deutschen Sprache. Jetzt soll die Textdatenbank abgefragt
werden und alle diejenigen Sätze liefern, die eine Verbgruppe, bestehend aus einem finiten Verb „hat“, einem Nomen „Buch“ und einem beliebigen infiniten Verb, beinhalten,
bei der die einzelnen Satzglieder in der aufgeschriebenen Reihenfolge auftreten müssen.
Daraufhin bietet sich für die Textdatenbank eine Möglichkeit, einen Parsebaum (den
Pattern-Baum) entsprechend der vorgegebenen Verbgruppe, wie in Abbildung 3.4b, zu
erstellen und dann nach allen Sätzen in der Datenbank zu suchen, deren Parsebäume
den Pattern-Baum einschließen. In diesem Fall sind das alle diejenigen Sätze, deren
Parsebäume sich nur durch die Löschung von Knoten in den erstellten Pattern-Baum
transformieren lassen. Formal lässt sich das Baum-Inklusion-Problem wie folgt definieren.
Definition 3.5 (Das Baum-Inklusion-Problem)
Gegeben ist ein Baum P (der Pattern-Baum) und ein Baum T . Sei s1 , . . . , sk eine Folge von
Lösch-Operationen. Das Baum-Inklusion-Problem ist das folgende: Gibt es eine Folge von
s
Bäumen A0 , . . . Ak , so dass T = A0 , P = Ak und Ai−1 ⇒
=i Ai für 1 ≤ i ≤ k.
Die Abbildung 3.5 zeigt anschaulich ein Beispiel einer Baum-Inklusion.
Das Baum-Inklusion-Problem hat zwei folgende wichtige Eigenschaften:
• Es ist ein Spezialfall des Edit-Distanz-Problems. Da bei den Edit-Operationen die
27
Kapitel 3. Vergleich von Bäumen über Edit-Operationen
Satz
Nomengruppe
Verbgruppe
Artikel
Nomen
Verb
„Der“
„Junge“
„hat“
Nomengruppe
Verb
Artikel
Adjektiv
Nomen
„ein“
„großes“
„Buch“
„gekauft“
(a)
Satz
Verbgruppe
Verb
Nomen
„hat“
„Buch“
Verb
(b)
Abbildung 3.4: (a) Parsebaum eines Satzes.
(b) Ein eingeschlossener Baum des Parsebaumes unter (a).
28
Approximative Suche in Baumstrukturen
T=A0
d
a
A1
f
e
c
d
(c,–)
a
A2
f
e
b
(a,–)
P=A3
f
d
e
(d,–)
b
f
e
b
b
Abbildung 3.5: Beispiel einer Baum-Inklusion. Der Baum P ist in dem Baum T
eingeschlossen.
Einfügung von Knoten das Komplement von deren Löschung bildet, kann man,
um zu entscheiden, ob P in T eingeschlossen ist, statt Knoten in T zu löschen, sie
in P einfügen und dann P mit T vergleichen. In diesem Fall muss aber beachtet
werden, dass die Einfügung von Knoten nicht zu den Gesamtkosten der Transformation beiträgt, weil die Edit-Distanz die minimalen Kosten einer Transformation
angibt. Setzt man jetzt für alle Einfügungen die Kosten 0 und für alle anderen
Edit-Operationen die Kosten 1, dann ist P in T genau dann eingeschlossen wenn
δ (P, T ) = 0.
• Das Baum-Inklusion-Problem ist auch ein Spezialfall des Alignment-DistanzProblems. Haben P und T die gleiche Anzahl von Knoten, so ist P in T nur dann
eingeschlossen, wenn P = T , da sonst durch das Löschen von Knoten aus T , der
Pattern-Baum P sich nicht mehr erhalten lässt. Also müssen in diesem Fall die
Kosten der Ausrichtung zwischen P und T gleich |T | − |P| = 0 sein, wenn P in T
eingeschlossen sein soll. Haben P und T unterschiedlich viele Knoten, dann ist P
in T nur dann eingeschlossen, wenn die Anzahl der, mit dem Blank-Symbol bei
der Ausrichtung von P gegen T in P, eingefügten Knoten gleich |T | − |P| ist. Aus
diesem Grund ist P in T genau dann eingeschlossen, wenn α(P, T ) = |T | − |P| und
man dabei die Kosten für alle Edit-Operationen gleich 1 setzt.
Das Baum-Inklusion-Problem wurde ursprünglich von Knuth in [Knu69] (vgl. Übung
2.3.2-22) eingeführt. Durch die, in Zusammenhang mit den strukturierten Textdatenbanken auftauchenden Probleme, immer mehr wachsende Bedeutung dieses Problems,
war es der Gegenstand vieler Forschungsarbeiten. Der erste polynomielle Algorithmus zur Lösung des Baum-Inklusion-Problems wurde von Kilpeläinen und Mannila
[KM95] angegeben und benötigt für seine Ausführung O(|P| · |T |) Zeiteinheiten und
Speicherplatz. Darüber hinaus untersuchten sie in [KM95] das Problem für ungeordnete Bäume und konnten nachweisen, dass es NP-Vollständig ist, falls der Grad von
T nicht beschränkt ist. Zudem gaben sie einen Algorithmus an, der das ungeordnete
Baum-Inklusion-Problem in einer polynomiellen Zeit löst, falls der Grad von T durch
O(log(|T |)) beschränkt ist und dabei nur O(|P| · |T |) Zeit benötigt, falls der Grad von
T konstant ist. Weimin Chen gab in [Che98] einen weitaus komplexeren Algorithmus
zur Lösung des geordneten Baum-Inklusion-Problems an, der O(|L(P)| · |T |) Zeit und
O(L(P) · min{depth(T ), |L(T )|}) Speicher benötigt.
Kapitel 4. Verfahren zur Berechnung der Baum-Edit-Distanz
29
4 Verfahren zur Berechnung der
Baum-Edit-Distanz
4.1 Zhang-Shasha-Algorithmus
Dieses Kapitel stellt den Zhang-Shasha-Algorithmus [ZS89] vor. Der Zhang-ShashaAlgorithmus berechnet die Edit-Distanz zweier Bäume und löst somit das „tree-to-tree
correction problem“, indem er die Rekursionsformeln aus dem Satz 3.4 mit Hilfe dynamischer Programmierung umsetzt. Die Verwendung der dynamischen Programmierung
wird hier deshalb eingesetzt, weil die Edit-Distanzen in den Rekursionsformeln von den
Teilproblemen kleinerer Größe abhängen, die wiederum kleinere Teilprobleme teilen.
Ein Teilproblem repräsentiert in diesem Fall, die Berechnung einer Edit-Distanz zweier
Baumstrukturen mit einer geringeren Anzahl von Knoten als der Baumstrukturen des
anfänglich zu lösenden Problems. Hierbei können die Teilprobleme sowohl die Berechnung der Baum- als auch der Wald-Edit-Distanz darstellen. Untersucht man die Teilprobleme für Bäume und Wälder getrennt voneinander, so lässt sich die Rekursionsformel
(4) in zwei Teile zerlegen. Liegt i auf dem Pfad von l(v) nach v und j auf dem Pfad von
l(w) nach w, dann ist l(i) = l(v) und l( j) = l(w), so dass δ (T1 [l(v)..i], T2 [l(w).. j]) die Berechnung der Edit-Distanz zweier Bäume ausdrückt. Anderenfalls wird die Edit-Distanz
zwischen zwei Wäldern berechnet.
Satz 4.1
Seien T1 und T2 geordnete Bäume, deren Knoten in Postordnung von links nach rechts
durchnummeriert sind. Seien v ∈ T1 , w ∈ T2 , i ∈ {l(v), . . . , v} und j ∈ {l(w), . . . , w}.
(1) Falls l(i) = l(v) und l( j) = l(w), dann gilt:


δ (T1 [l(v)..i − 1], T2 [l(w).. j]) + γ(T1 [i], −),
δ (T1 [l(v)..i], T2 [l(w).. j]) = min δ (T1 [l(v)..i], T2 [l(w).. j − 1]) + γ(−, T2 [ j]),


δ (T1 [l(v)..i − 1], T2 [l(w).. j − 1]) + γ(T1 [i], T2 [ j]).
(2) Sonst:

δ (T1 [l(v)..i − 1], T2 [l(w).. j]) + γ(T1 [i], −),



δ (T [l(v)..i], T [l(w).. j − 1]) + γ(−, T [ j]),
1
2
2
δ (T1 [l(v)..i], T2 [l(w).. j]) = min

δ (T1 [l(v)..l(i) − 1], T2 [l(w)..l( j) − 1])



+δ (T1 (i), T2 ( j)).
30
Approximative Suche in Baumstrukturen
(i,j)
T1[l(i)..i-1]
T2[l(j)..j-1]
(a) Dritter Fall der Rekursionsformel für einen Baum
...
T1[l(v)..l(i)-1]
...
T1(i)
T2[l(w)..l(j)-1]
T2(j)
(b) Dritter Fall der Rekursionsformel für einen Wald
Abbildung 4.1: Zwei Situationen des Satzes 4.1.
Beweis:
(1) Setze l(i) = l(v) und l( j) = l(w) in die Rekursionsformel (4) des Satzes 3.4
ein. Dann folgt sofort die gesuchte Rekursionsformel (1), da δ (T1 [l(v)..l(v) −
1], T2 [l(w)..l(w) − 1]) = δ (θ , θ ) = 0.
(2) Um T1 [l(v)..i] in T2 [l(w).. j] zu transformieren, kann man zunächst T1 [l(v)..l(i) − 1]
auf T2 [l(w)..l( j) − 1] und dann den übrig gebliebenen Baum T1 (i) auf T2 ( j) abbilden. Ähnlich kann der Baum T1 (i) in T2 ( j) transformiert werden, indem man
zunächst T1 [l(i)..i − 1] auf T2 [l( j).. j − 1] und dann den restlichen Knoten i auf j
abbildet. Da diese Möglichkeiten aber einen Spezialfall darstellen, können sie suboptimal sein und deshalb nicht zu einer optimalen Edit-Distanz-Abbildung führen.
Daher lässt sich diese Situation durch folgende zwei Ungleichungen ausdrücken.
(a) δ (T1 [l(v)..i], T2 [l(w).. j]) ≤ δ (T1 [l(v)..l(i) − 1], T2 [l(w)..l( j) − 1])
+ δ (T1 (i), T2 ( j))
(b) δ (T1 (i), T2 ( j)) ≤ δ (T1 [l(i)..i − 1], T2 [l( j).. j − 1]) + γ(T1 [i], T2 [ j])
Kapitel 4. Verfahren zur Berechnung der Baum-Edit-Distanz
31
Aus den Ungleichungen (a) und (b) folgt:
δ (T1 [l(v)..i], T2 [l(w).. j]) ≤ δ (T1 [l(v)..l(i) − 1], T2 [l(w)..l( j) − 1])
+ δ (T1 (i), T2 ( j))
≤ δ (T1 [l(v)..l(i) − 1], T2 [l(w)..l( j) − 1])
+ δ (T1 [l(i)..i − 1], T2 [l( j).. j − 1]) + γ(T1 [i], T2 [ j])
Damit kann der Ausdruck δ (T1 [l(i)..i − 1], T2 [l( j).. j − 1]) + γ(T1 [i], T2 [ j]) durch
δ (T (i), T ( j)) ersetzt werden.
Die Abbildung 4.1 verdeutlicht beispielhaft die zwei auftretenden Situationen des Satzes 4.1.
Aus den Rekursionen des Satzes 4.1 ergibt sich, dass die im Laufe der Berechnung
von δ (T1 , T2 ) zu lösenden Teilprobleme entweder die Edit-Distanzen der Teilbäume von
T1 und T2 oder die Edit-Distanzen der Präfixe dieser Teilbäume darstellen. Beim Betrachten der Rekursionsformel (2) erkennt man, dass zur Berechnung der Edit-Distanz
δ (T1 (v), T2 (w)) alle Edit-Distanzen δ (T (i), T ( j)) für i ∈ T1 (v), j ∈ T2 (w) mit l(i) 6= l(v)
oder l( j) 6= l(w) gebraucht werden. Weiterhin stellt man durch Anwendung der Rekursionsformel (1) fest, dass nicht alle Edit-Distanzen der Teilbäume von T1 (v) und
T2 (w) explizit berechnet werden müssen. Liegt i auf dem Pfad von l(v) nach v und
j auf dem Pfad von l(w) nach w, dann wird die Edit-Distanz δ (T1 (i), T2 ( j)) zur Berechnung von δ (T1 (v), T2 (w)) nicht benötigt. Infolgedessen ist δ (T1 [l(v)..i], T2 [l(w).. j]) =
δ (T1 [l(i)..i], T2 [l( j).. j]) = δ (T1 (i), T2 ( j)). In diesem Fall ist δ (T1 (i), T2 ( j)) ein Präfix von
δ (T1 (v), T2 (w)) und kann implizit nur aus den Präfixen von T1 (v) und T2 (w) bestimmt
werden. Wurzeln der echten Teilbäume eines Baumes T , die in einem größeren und sie
umfassenden Teilbaum T (v) für v ∈ T nicht auf dem Pfad von l(v) nach v liegen, haben
immer ein echtes linkes Geschwister in T . Aus diesem Grund müssen zur Bestimmung
der Edit-Distanz δ (T1 , T2 ) tatsächlich nur alle diejenigen Edit-Distanzen δ (T1 (v), T2 (w))
der echten Teilbäume von T1 und T2 explizit berechnet werden, wo die Knoten v und w
in ihren Bäumen ein echtes linkes Geschwister haben. Die Wurzeln von Bäumen der im
Algorithmus explizit zu berechnenden Edit-Distanzen werden als Schlüsselknoten (engl.
key nodes1 ) bezeichnet. Die folgende Definition gibt die Schlüsselknoten folmal an.
Definition 4.1 (Schlüsselknoten)
Sei T ein gewurzelter geordneter Baum. Dann sind die Schlüsselknoten von T wie folgt
definiert:
K(T ) = {root(T )} ∪ {v ∈ V (T ) | v hat ein echtes linkes Geschwister}.
Teilbäume eines Baumes T , deren Wurzeln die Schlüsselknoten von T sind, werden
spezielle Teilbäume von T genannt. Die Präfixe aller speziellen Teilbäume von T werden
als relevante Teilstrukturen von T bezeichnet.
1 In
der originalen wissenschaftlichen Publikation von Zhang und Shasha [ZS89] und von einigen anderen Autoren in der Literatur werden diese Knoten auch als „key roots“ bezeichnet.
32
Approximative Suche in Baumstrukturen
Abbildung 4.2: Zerlegung eines Baumes in linkeste Pfade. Linkeste Pfade sind
fett abgedruckt. Gefüllte Knoten stellen Schlüsselknoten des
Baumes dar.
Die Idee des Zhang-Shasha-Algorithmus besteht darin, die Edit-Distanzen
δ (T1 (v), T2 (w)) für alle v ∈ K(T1 ) und w ∈ K(T2 ) gemäß den Prinzipien dynamischer Programmierung zu berechnen. Hierfür wird die Funktion compute_delta konstruiert,
die für alle Paare von Schlüsselknoten v und w, in der Reihenfolge ihrer Nummerierung
in Postordnung, bottom-up aufgerufen wird und die Distanzen δ (T1 [l(v)..i], T2 [l(w).. j])
für alle i ∈ {l(v), . . . v} und j ∈ {l(w)..w} basierend auf den Sätzen 3.4 und 4.1 berechnet.
Die berechneten Baum-Edit-Distanzen werden dabei in einer |T1 | × |T2 |-Distanzmatrix
treeDist permanent gespeichert, damit sie bei Bedarf in konstanter Zeit abgerufen
werden können. Der Eintrag treeDist[i, j] wird im Laufe des Algorithmus die EditDistanz δ (T1 (i), T2 ( j)) haben. Des Weiteren berechnet der Algorithmus für alle Paare
spezieller Teilbäume von T1 und T2 die Edit-Distanzen zwischen allen ihren Präfixen
in aufsteigender Größe und speichert sie temporär in einer (|T1 | + 1) × (|T2 | + 1)Distanzmatrix forestDist. Hierbei wird während der Berechnung einer Edit-Distanz
zweier spezieller Teilbäume T1 (v), T2 (w) dem Eintrag forestDist[i, j] die Edit-Distanz
δ (T1 [l(v)..i], T2 [l(w).. j]) zwischen einem Präfix von T1 (v) und einem Präfix von T2 (w)
zugewiesen. Die Distanzmatrix forestDist wird für jedes Paar von speziellen Teilbäumen wiederverwendet. Nach der Ausführung des Algorithmus besitzt der Eintrag
treeDist[|T1 |, |T2 |] die gesuchte Edit-Distanz δ (T1 , T2 ).
Ein gewurzelter Baum T lässt sich in linkeste Pfade zerlegen, indem man ausgehend von
jedem Schlüsselknoten immer via den linkesten Kindern bis zu einem Blattknoten absteigt. Sei left(v) das linkeste Kind von v und v ∈ K(T ), wobei v einen Nicht-Blattknoten
angibt. Für einen Blattknoten ist left(v) = v. Die Folge von Knoten
v, left(v), left(left(v)), . . .
definiert den absteigenden linken Pfad von T (v). Die Schlüsselknoten bilden also die
ersten Knoten der linkesten Pfade (siehe Abbildung 4.2) und können auf folgende Weise
algorithmisch bestimmt werden:
(1) Lösche das linkeste Blatt des Baumes und alle seine Vorgänger. Der letzte Vorgänger dieses Blattes ist ein Schlüsselknoten.
Kapitel 4. Verfahren zur Berechnung der Baum-Edit-Distanz
33
Eingabe : Knoten v ∈ K(T1 ) und w ∈ K(T2 ).
Ausgabe: {δ (T1 [l(v)..i], T2 [l(w).. j]) | i ∈ {l(v), . . . , v} und j ∈ {l(w), . . . , w}}.
/* forestDist[0..|V (T1 )|,0..|V (T2 )] ist die temporäre
Distanzmatrix
/* treeDist[1..|V (T1 )|,1..|V (T2 )|] ist die permanente
Distanzmatrix
/* γ ist die Kostenfunktion
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
*/
*/
*/
θ1 := l(v) − 1.
θ2 := l(w) − 1.
forestDist[θ1 , θ2 ] = 0
for i := l(v) to v do
forestDist[i, θ2 ] = forestDist[i − 1, θ2 ] + γ(T1 [i], −).
for j := l(w) to w do
forestDist[θ1 , j] = forestDist[θ1 , j − 1] + γ(−, T2 [ j]).
for i := l(v) to v do
for j := l(w) to w do
if l(i) = l(v) and l( j) = l(w)
 then

forestDist[i − 1, j] + γ(T1 [i], −);
forestDist[i, j] := min forestDist[i, j − 1] + γ(−, T2 [ j]);


forestDist[i − 1, j − 1] + γ(T1 [i], T2 [ j]).
treeDist[i, j] := forestDist[i, j].
else


forestDist[i − 1, j] + γ(T1 [i], −);
forestDist[i, j] := min forestDist[i, j − 1] + γ(−, T2 [ j]);


forestDist[l(i) − 1, l( j) − 1] + treeDist[i, j].
Funktion compute_delta(v, w)
(2) Wiederhole Schritt (1) bis keine Blätter mehr vorhanden sind.
Offensichtlich gibt es in einem Baum genauso viele Schlüsselknoten wie Blätter.
Satz 4.2
Sei T ein geordneter Baum. Dann gilt:
|K(T )| = |L(T )|.
Vor der Ausführung des Zhang-Shasha-Algorithmus werden in der Vorbereitungsphase
die Schlüsselknoten K(T1 ) und K(T2 ) bestimmt und jeweils in einem Hilfsfeld entsprechend ihrer Position in der Postordnung aufsteigend gespeichert. Außerdem wird auch
l(v) für alle v ∈ V (T1 ), w ∈ V (T2 ) vorberechnet und in einem Hilfsfeld gespeichert. Offensichtlich benötigt die Vorbereitungsphase für ihre Berechnungen eine lineare Zeit.
Damit lässt sich jetzt ein Algorithmus konstruieren, der die Edit-Distanz zweier Bäume
34
Approximative Suche in Baumstrukturen
T1 , T2 in O(|T1 | · |T2 | · min{depth(T1 ), L(T1 )} · min{depth(T2 ), L(T2 )}) Zeit und O(|T1 | · |T2 |)
Platz löst.
Eingabe : Baum T1 und T2 .
Ausgabe: δ (T1 , T2 ).
/* treeDist[1..|V (T1 )|,1..|V (T2 )|] ist die permanente
Distanzmatrix
*/
/* ----------------- Vorbereitungsphase ----------------- */
1:
berechne l(), K(T1 )[] und K(T2 )[]
/* ------------------- Hauptschleife -------------------- */
6:
for i := 1 to |K(T1 )| do
for j := 1 to |K(T2 )| do
v := K(T1 )[i],
w := K(T2 )[ j],
call compute_delta(v, w).
7:
print "Edit-Distanz ist treeDist[v, w]".
2:
3:
4:
5:
Algorithmus 4.2: Zhang-Shasha-Algorithmus
Satz 4.3
Der Zhang-Shasha-Algorithmus berechnet die Kosten einer optimalen Edit-DistanzAbbildung zweier Bäume korrekt.
Beweis:
Die Funktion compute_delta(v, w) berechnet die Edit-Distanz zweier spezieller Bäume T1 und T2 mit den Wurzeln v ∈ K(T1 ), w ∈ K(T2 ) und wird für alle Schlüsselknoten
v, w entsprechend ihrer Position in Postordnung von unten nach oben aufgerufen. Für
Schlüsselknoten v1 , v2 ∈ K(T1 ) und w1 , w2 ∈ K(T2 ) mit v1 + w1 < v2 + w2 bedeutet das, dass
compute_delta(v1 , w1 ) vor compute_delta(v2 , w2 ) aufgerufen wird. Da beim Aufruf von compute_delta(v1 , w1 ) die Edit-Distanzen aller Präfixe von T1 (v1 ) und T2 (w1 )
berechnet werden, sind vor dem Aufruf von compute_delta(v2 , w2 ) auch alle Werte
treeDist[i, j] für l(v2 ) ≤ i ≤ v2 und l(w2 ) ≤ j ≤ w2 mit l(v2 ) 6= l(i) oder l(w2 ) 6= l( j) vorhanden. Danach werden im ersten if-Teil der Funktion compute_delta die fehlenden
Werte treeDist[i, j] mit l(v2 ) = l(i) und l(w2 ) = l( j) bestimmt. Nach dem Aufruf von
compute_delta(v2 , w2 ) sind schließlich alle Werte treeDist[i, j] für l(v2 ) ≤ i ≤ v2
und l(w2 ) ≤ j ≤ w2 verfügbar.
Da beim Zhang-Shasha-Algorithmus nicht alle Teilprobleme berechnet werden müssen,
taucht ein bestimmter Knoten im Baum eines zu lösenden Teilproblems in allen Berechnungen insgesamt weniger Male als seine Tiefe auf. Um die Komplexität des Algorithmus angeben zu können, definierten Zhang und Shasha die sogenannte kollabierte Tiefe
(engl. collapsed depth) eines Knotens v ∈ V (T ). Die kollabierte Tiefe von v gibt die Anzahl seiner Vorfahren an, die gleichzeitig Schlüsselknoten von T sind. Formal definiert
Kapitel 4. Verfahren zur Berechnung der Baum-Edit-Distanz
35
man kollabierte Tiefe als:
cdepth(v) = | anc(v) ∩ K(T )|.
Die kollabierte Tiefe eines Baumes T wird wie folgt definiert:
cdepth(T ) = max{cdepth(v) | v ∈ T }.
Durch folgenden Satz kann die obere Schranke der kollabierten Tiefe eines Baumes
abgeschätzt werden.
Satz 4.4
cdepth(T ) ≤ min{depth(T ), L(T )}.
Beweis:
Es gelten folgende Abschätzungen:
cdepth(v) ≤ depth(v) ≤ depth(T )
(4.1)
cdepth(v) ≤ |K(T )| = |L(T )|, für alle v ∈ T.
(4.2)
und mit Satz 4.2
Aus (4.1) und (4.2) folgt:
cdepth(v) ≤ min{depth(T ), L(T )}, für alle v ∈ T.
Also gilt:
cdepth(T ) ≤ min{depth(T ), L(T )}.
Um die Edit-Distanzen zweier Bäume T1 und T2 zu bestimmen, berechnet der ZhangShasha-Algorithmus die Edit-Distanzen zwischen allen relevanten Teilstrukturen von T1
und T2 . Die relevanten Teilstrukturen eines Baumes T bestehen aus den Präfixen von
allen speziellen Teilbäumen von T . Die Anzahl aller Präfixe eines speziellen Teilbaumes
T(v) ist gleich |T(v)|. Der nächste Satz gibt die Anzahl aller relevanten Teilstrukturen
von T durch die kollabierte Tiefe der Knoten von T an.
Satz 4.5
∑
v∈K(T )
|T (v)| =
∑
cdepth(w)
w∈V (T )
Beweis:
Die linke Summe der Gleichung läuft über alle Schlüsselknoten des Baumes T . Dabei
werden für jeden Teilbaum von T mit einem Schlüsselknoten v als Wurzel alle Knoten w
summiert, für die dieser Schlüsselknoten ein Vorgänger ist. Insgesamt wird ein Knoten w
in der linken Summe soviel Mal gezählt, wie er Schlüsselknoten hat, die seine Vorfahren
sind. Das entspricht nach der Definition genau der kollabierten Tiefe cdepth(w).
36
Approximative Suche in Baumstrukturen
Satz 4.6
Die Berechnung der Edit-Distanz zweier geordneter beschrifteter Bäume T1 , T2
mit dem Zhang-Shasha-Algorithmus benötigt O(|T1 | · |T2 | · min{depth(T1 ), L(T1 )} ·
min{depth(T2 ), L(T2 )}) Zeiteinheiten und O(|T1 | · |T2 |) Speicherplatz.
Beweis:
Im Algorithmus wird die Baum-Edit-Distanz getrennt von der Wald-Edit-Distanz gespeichert. Die Baum-Edit-Distanz δ (T1 (v), T2 (w)) wird für jedes v ∈ T1 und w ∈ T2 , sobald sie berechnet ist, in einem zweidimensionalen Feld treeDist der Größe |T1 | · |T2 |
permanent während der gesamten Ausführung des Algorithmus gespeichert. Dagegen
wird die Wald-Edit-Distanz δ (T1 [l(v)..i], T2 [l(w).. j]) für jedes i ∈ {l(v) − 1, . . . , v} und j ∈
{l(w) − 1, . . . , w} nur temporär in einem zweidimensionalen Feld forestDist der Größe (|T1 | + 1) · (|T2 | + 1) während einer Ausführung der Hauptschleife des Algorithmus gespeichert. Das Feld forestDist wird in jedem Aufruf der Funktion compute_delta
wiederbenutzt. Insgesamt benötigt der Algorithmus also O(|T1 | · |T2 |) Speicherplatz.
Die Vorbereitungsphase des Algorithmus nimmt für die Berechnung von K(T1 ), K(T2 )
und l(v) für alle v ∈ V (T1 ), v ∈ V (T2 ) eine lineare Zeit in Anspruch. Die Funktion
compute_delta berechnet in der Hauptschleife die Edit-Distanz δ (T1 (v), T2 (w)) für
alle v ∈ K(T1 ), w ∈ K(T2 ) und benötigt für eine ihrer Ausführungen O(|T1 (v)| · |T2 (w)|)
Zeiteinheiten. Infolgedessen wird compute_delta für alle speziellen Bäume von T1
und T2 ausgeführt und braucht insgesamt folgende Zeit:
∑
∑
O(|T1 (v)| · |T2 (w)|) = O(
v∈K(T1 ) w∈K(T2 )
∑
|T1 (v)| ·
v∈K(T1 )
∑
|T2 (w)|).
w∈K(T2 )
Aus der obigen Gleichung und Satz 4.5 folgt schließlich:
O(
∑
v∈K(T1 )
|T1 (v)| ·
∑
w∈K(T2 )
|T2 (w)|) = O(
∑
v∈V (T1 )
cdepth(v) ·
∑
cdepth(w))
w∈V (T2 )
≤ O(|T1 | · |T2 | · cdepth(T1 ) · cdepth(T2 )).
Unter Anwendung des Satzes 4.4 ergibt sich die Laufzeitkomplexität zu:
O(|T1 | · |T2 | · min{depth(T1 ), |L(T1 )|} · min{depth(T2 ), |L(T2 )|}).
Der Zhang-Shasha-Algorithmus berechnet nur die Edit-Distanz zweier Bäume.Um
eine optimale Edit-Distanz-Abbildung in derselben Zeit- und Speicherkomplexität zu bestimmen, muss man am Ende des Algorithmus, ausgehend vom Eintrag
forestDist[|T1 |, |T2 |] zurück zum Eintrag forestDist[0, 0] den Weg des jeweils
gefundenen Minimums folgen. Die Vorgehensweise ist ähnlich dem in [WF74] für
Zeichenketten und wird hier deswegen nicht angegeben.
Der Zhang-Shasha-Algorithmus besitzt noch eine weitere interessante Eigenschaft. Er
stellt eine Verallgemeinerung des Wagner-Fischer-Algorithmus [WF74] dar, der die EditDistanz zweier Zeichenketten berechnet. Somit überträgt er das Verfahren, zur Berechnung einer Edit-Distanz, vom eindimensionalen Fall der Zeichenketten auf den mehrdimensionalen Fall der Bäume in einer vergleichbaren algorithmischen Weise und behält für eindimensionale Eingaben dieselbe Zeit- und Speicherkomplexität. Da eine
Kapitel 4. Verfahren zur Berechnung der Baum-Edit-Distanz
37
Zeichenkette durch einen Baum repräsentiert werden kann, wo jeder Knoten außer
der Wurzel genau einen Vaterknoten besitzt, ergeben sich die Mengen der Schlüsselknoten beider Eingabebäume T1 , T2 beim Zhang-Shasha-Algorithmus zu K(T1 ) = {|T1 |}
und K(T2 ) = {|T2 |}. In diesem Fall hat die Hauptschleife des Zhang-Shasha-Algorithmus
genau eine Iteration. Außerdem ist hierbei der Knoten mit der Nummerierung eins,
in beiden Eingabebäumen, der Knoten mit der kleinsten Nummerierung und damit
l(v) = l(w) = 1 für alle v ∈ V (T1 ), w ∈ V (T2 ). Infolgedessen muss in der Funktion
compute_delta immer nur der erste Teil der if-Abfrage für die Bedingung l(i) = l(v)
und l( j) = l(w) behandelt werden, da es niemals l(i) 6= l(v) oder l( j) 6= l(w) gilt. Setzt
man jetzt in der Hauptschleife des Zhang-Shasha-Algorithmus v = |T1 |, w = |T2 | und in
der Funktion compute_delta l(v) = l(w) = 1, verschwindet die Hauptschleife und der
Fall l(i) 6= l(v) oder l( j) 6= l(w), so dass exakt der Wagner-Fischer-Algorithmus entsteht.
(vgl. Algorithmus 4.3 und [WF74])
Eingabe : Baum T1 und T2 mit |L(T1 )| = 1 und |L(T2 )| = 1.
Ausgabe: δ (T1 , T2 ).
/* treeDist[1..|V (T1 )|,1..|V (T2 )|] ist die permanente
Distanzmatrix
1:
2:
3:
4:
5:
6:
7:
8:
*/
treeDist[0, 0] := 0.
for i := 1 to |T1 | do
treeDist[i, 0] = forestDist[i − 1, 0] + γ(T1 [i], −).
for j := 1 to |T2 | do
treeDist[0, j] = forestDist[0, j − 1] + γ(−, T2 [ j]).
for i := 1 to |T1 | do
for j := 1 to |T2 | do 

treeDist[i − 1, j] + γ(T1 [i], −);
treeDist[i, j] := min treeDist[i, j − 1] + γ(−, T2 [ j]);


treeDist[i − 1, j − 1] + γ(T1 [i], T2 [ j]).
print "Edit-Distanz ist treeDist[|T1 |, |T2 |]".
Algorithmus 4.3: Zhang-Shasha-Algorithmus für Eingaben T1 , T2 mit |L(T1 )| = 1
und |L(T2 )| = 1.
4.2 Klein-Algorithmus
Der Zhang-Shasha-Algorithmus kann als ein Zerlegungsalgorithmus angesehen werden,
da er zur Berechnung der Edit-Distanz seine Eingabebäume in Teilbäume und deren
Präfixe zerlegt. Dabei hängt die Anzahl der gemachten Zerlegungen von der Form beider Eingabebäume ab und kann von Fall zu Fall stark variieren. Um diesen Prozess zu
verdeutlichen, betrachte die Berechnungsvorschrift für den Zhang-Shasha-Algorithmus
nach Satz 4.1 zur Bestimmung der Edit-Distanz zwischen zwei Bäumen T1 (v) und T2 (w)
38
Approximative Suche in Baumstrukturen
mit den Wurzeln v ∈ V (T1 ) und w ∈ V (T2 ). Bezeichne im Folgenden T1 (F1 (v)) = T1 (v) und
T2 (F2 (w)) = T2 (w). Diese Schreibweise soll den rekursiven Aufbau eines Baumes hervorheben und bedeutet, dass die Wurzeln v, w der jeweiligen Bäume entsprechend mit den
Teilwäldern F1 (v) und F2 (w) verbunden sind, die wiederum aus Teilbäumen aufgebaut
sind. Dann gilt:


δ (F1 (v), T2 (F2 (w))) + γ(T1 [v], −),
δ (T1 (F1 (v)), T2 (F2 (w))) = min δ (T1 (F1 (v)), F2 (w)) + γ(−, T2 [w]),
(4.3)


δ (F1 (v), F2 (w)) + γ(T1 [v], T2 [w]).
Jetzt kann auch eine Berechnungsvorschrift für Wälder nach Satz 4.1 abgeleitet werden.
Dabei bezeichnet Wk ◦ Tk (Fk (v)) einen Wald, der in der Reihenfolge von links nach rechts
aus dem Wald Wk und dem Teilbaum Tk (Fk (v)) für k ∈ {1, 2}, v ∈ Tk besteht.


δ (W1 ◦ F1 (v),W2 ◦ T2 (F2 (w))) + γ(T1 [v], −),
δ (W1 ◦ T1 (F1 (v)),W2 ◦ T2 (F2 (w))) = min δ (W1 ◦ T1 (F1 (v)),W2 ◦ F2 (w)) + γ(−, T2 [w]),


δ (W1 ,W2 ) + δ (T1 (F1 (v)), T2 (F2 (w))).
(4.4)
Daraus erkennt man, dass der Zhang-Shasha-Algorithmus die Teilwälder von T1 und T2
in kleinere Teilwälder zerlegt, deren rechteste Wurzeln links von den rechtesten Wurzeln der ursprünglichen Teilwälder liegen. Man nennt daher die in den Rekursionen
auftauchenden Teilwälder die linkesten Teilwälder. Da aber hier immer nur der rechteste
Teilbaum zerlegt wird, bezeichnet man diesen Vorgang als rechte Zerlegung. In einigen
Situationen kann es jedoch sinnvoller sein, eine andere Zerlegung der Teilwälder zu
wählen, um die Anzahl der rekursiven Aufrufe zu verringern. Eine andere Möglichkeit
die Teilwälder der Eingabebäume zu zerlegen, stellt die linke Zerlegung dar. Hierbei
werden bei den rekursiven Aufrufen die Teilwälder in rechteste Teilwälder zerlegt. Folgende Gleichung gibt die linke Zerlegung an.


δ (F1 (v) ◦W1 , T2 (F2 (w)) ◦W2 ) + γ(T1 [v], −),
δ (T1 (F1 (v)) ◦W1 , T2 (F2 (w)) ◦W2 ) = min δ (T1 (F1 (v)) ◦W1 , F2 (w) ◦W2 ) + γ(−, T2 [w]),


δ (W1 ,W2 ) + δ (T1 (F1 (v)), T2 (F2 (w))).
(4.5)
Um die linke Zerlegung algorithmisch zu bewerkstelligen, muss bei dem ZhangShasha-Algorithmus zu Beginn die Nummerierung der Knoten anhand der PostordnungTraversierung von rechts nach links, anstatt wie bisher von links nach rechts, festgelegt
werden. Anschließend braucht man nur l(v) durch r(v) zu ersetzen, das den rechtesten
Blatt im Teilbaum T (v) liefert und die Menge der Schlüsselknoten
K(T ) = {root(T )} ∪ {v ∈ V (T ) | v hat ein echtes rechtes Geschwister}
entsprechend in der Vorbereitungsphase zu berechnen. Hierbei werden die Bäume T1
und T2 in rechteste Pfade zerlegt.
39
Kapitel 4. Verfahren zur Berechnung der Baum-Edit-Distanz
Im Falle der rechten bzw. der linken Zerlegung kommen bei den rekursiven Aufrufen alle
Teilbäume von T1 und T2 sowie deren Präfixe bzw. Suffixe vor. Da jedes Teilbaum T (v)
genau |T (v)| nicht leere Präfixe und Suffixe hat, ist die Anzahl der rekursiven Aufrufe
sowohl bei der rechten als auch der linken Zerlegung für einen Baum T durch
∑
O(|T (v)|) ≤ O(|T |2 )
v∈V (T )
beschränkt.
Falls also die beiden Eingabebäume T1 und T2 , mit |T1 | = |T2 | = n die gleiche Anzahl
von Knoten haben und die Anzahl der Aufrufe von der Funktion compute_delta O(n)
beträgt, benötigt der Zhang-Shasha-Algorithmus im schlechtesten Fall zu Berechnung
ihrer Edit-Distanz O(n4 ) Zeiteinheiten.
Der von Klein [Kle98] angegebene Algorithmus zur Berechnung der Edit-Distanz zweier
Bäume verfolgt einen anderen Weg und wechselt bei jedem rekursiven Aufruf für den
ersten Eingabebaum T1 die Richtung der Zerlegung seiner Teilwälder anhand von sogenannten schweren Pfaden. Die Zerlegung von Bäumen in schwere Pfade wurde erstmals
von Harel und Tarjan eingeführt [HT84]. Folgende Definition gibt einen schweren Pfad
formal an.
Definition 4.2 (Schwerer Pfad)
Sei T ein gewurzelter Baum. Definiere das Gewicht eines Knotens v ∈ V (T ) als die Größe
|T (v)|. Falls v ∈
/ L(T ), so bezeichne heavy(v) ein Kind von v mit dem größten Gewicht, wobei
es hier mehrere Kinder mit demselben Gewicht zur Auswahl geben kann. Falls v ∈ L(T ), so
ist heavy(v) = v. Die Folge von Knoten
v, heavy(v), heavy(heavy(v)), . . .
definiert einen absteigenden schweren Pfad von T (v).
Die Abbildung 4.3 zeigt ein Beispiel einer Zerlegung eines Baumes in schwere Pfade.
Der Klein-Algorithmus kann im Allgemeinen durch folgende vier Schritte beschrieben
werden:
0
0
(1) Sei δ (T1 (F1 (v)) ◦W1 , F2 ) ein zu berechnendes Teilproblem, wobei F2 irgendein Teilwald von T2 ist.
(2) Berechne den schweren Pfad P für T1 (F1 (v)) ◦W1 .
(3) Falls v auf dem Pfad P liegt, benutze die rechte Zerlegung nach Gleichung 4.4,
andererseits die linke Zerlegung nach Gleichung 4.5.
(4) Wende diese Berechnungsvorschrift rekursiv auf Teilwälder von T1 (F1 (v)) ◦W1 an.
Die Zerlegung eines Baumes T in schwere Pfade hat den Vorteil, dass dann die kollabierte Tiefe cdepth(v) für alle v ∈ V (T ) durch O(log(|T |)) beschränkt ist (vgl. [ST81]).
40
Approximative Suche in Baumstrukturen
Abbildung 4.3: Zerlegung eines Baumes in schwere Pfade. Schwere Pfade
sind fett abgedruckt. Gefüllte Knoten stellen Schlüsselknoten
des Baumes dar.
In diesem Fall werden für den ersten Baum höchstens O(|T1 | · log(|T1 |)) rekursive Aufrufe generiert2 , so dass der Klein-Algorithmus im schlechtesten Fall nur O(n3 · log(n))
Zeiteinheiten für seine Berechnungen benötigt.
Satz 4.7
Die Berechnung der Edit-Distanz zweier Bäume T1 , T2 mit dem Klein-Algorithmus benötigt
O(|T1 |2 · |T2 | · log(|T2 |)) Zeiteinheiten und Speicherplatz [Kle98].
Damit reduziert der Klein-Algorithmus die Laufzeit des Zhang-Shasha-Algorithmus im
schlechtesten Fall von O(n4 ) auf O(n3 · log(n)). Im mittleren Fall aber läuft der ZhangShasha-Algorithmus immer noch schneller als der Klein-Algorithmus, da er dafür laut
3
3
Dulucq und Tichit [DT03] O(|T1 | 2 · |T2 | 2 ) Zeiteinheiten benötigt und somit für Bäume
gleicher Größe seine gesamten Berechnungen im Durchschnitt in O(n3 ) Zeiteinheiten
ausführt.
2 Für
den zweiten Baum müssen jedoch O(|T2 |2 ) rekursive Aufrufe ausgeführt werden.
Kapitel 5. Verfahren zur Berechnung der Baum-Alignment-Distanz
41
5 Verfahren zur Berechnung der
Baum-Alignment-Distanz
In diesem Kapitel wird der Jiang-Wang-Zhang-Algorithmus [JWZ95] vorgestellt, der die
Alignment-Distanz zwischen zwei geordneten Bäumen berechnet. Er basiert auf den
folgenden zwei Sätzen, die die Berechnung der Alignment-Distanz zwischen Bäumen
bzw. Wäldern rekursiv ausdrücken und eine Implementierung des Algorithmus nach
den dynamischen Programmiermethoden ermöglichen.
Zunächst sollen aus Gründen der Übersichtlichkeit einige Abkürzungen vorgenommen
werden. Ist Tk (k ∈ N) ein geordneter Baum und hat ein Knoten v ∈ V (Tk ) mit dem
Grad deg(v) = i die Kinder v1 , . . . , vi , so bezeichnet Fk (vs , vt ) für 1 ≤ s ≤ t ≤ i einen Wald
bestehend aus den Bäumen Tk (vs ), . . . , Tk (vt ). Weiterhin wird vereinfachend Fk (v1 , vi ) =
Fk (v)1 gesetzt.
Satz 5.1
Seien T1 und T2 geordnete Bäume, deren Knoten in Postordnung von links nach rechts
durchnummeriert sind. Sei v ∈ V (T1 ) und v1 , . . . , vi die Folge seiner Kinder. Sei w ∈ V (T2 )
und w1 , . . . , w j die Folge seiner Kinder. Dann gilt:
(1) α(θ , θ ) = 0,
(2) α(T1 (v), θ ) = α(F1 (v), θ ) + γ(T1 [v], −),
(3) α(θ , T2 (w)) = α(θ , F2 (w)) + γ(−, T2 [w]),
i
(4) α(F1 (v), θ ) = ∑ α(T1 (vk ), θ ),
k=1
j
(5) α(θ , F2 (w)) = ∑ α(θ , T2 (wk )),
k=1


α(T1 (v), θ ) + min {α(T1 (vk ), T2 (w)) − α(T1 (vk ), θ )},


1≤k≤i

(6) α(T1 (v), T2 (w)) = min α(θ , T2 (w)) + min {α(T1 (v), T2 (wk )) − α(θ , T2 (wk ))},

1≤k≤ j


α(F (v), F (w)) + γ(T [v], T [w]).
1
2
1
2
Beweis:
Die erste Gleichung ist trivial, da leere Bäume nicht ausgerichtet werden müssen. In der
zweiten Gleichung wird der erste Baum T1 (v) gegen einen leeren Baum ausgerichtet, so
1 Liegt
eine Postordnung der Knoten von Tk vor, so ist Tk [l(v)..v − 1] = Fk (v).
42
Approximative Suche in Baumstrukturen
dass nach der Ausrichtung der leere Baum nur aus den Blank-Symbolen besteht und die
Struktur des ersten Baumes T1 (v) annimmt. In der dritten Gleichung wird analog der
zweite Baum T2 (w) gegen einen leeren Baum ausgerichtet. Die Gleichungen (4) und (5)
sind ebenfalls trivial, da dort Wälder gegen leere Wälder ausgerichtet werden. Im sechsten Fall wird eine optimale Ausrichtung A von T1 (v) und T2 (w) betrachtet. Dabei ergeben
sich für die Wurzeln v, w der Bäume T1 (v) und T2 (w) insgesamt vier Möglichkeiten, wie
ihre Symbole in Knoten von A als Paare zusammensetzt werden können:
(1) Das Paar (T1 [v], T2 [w]) ist eine Beschriftung in A. Dann muss die Wurzel von A mit
dem Paar (T1 [v], T2 [w]) beschriftet sein. Also,
α(T1 (v), T2 (w)) = α(F1 (v), F2 (w)) + γ(T1 [v], T2 [w]).
(2) Die Paare (T1 [v], −) und (T1 [m], T2 [w]) sind Beschriftungen in A für irgendein m ∈
V (T1 (v)). Dann muss die Wurzel von A mit dem Paar (T1 [v], −) beschriftet sein. In
diesem Fall ist m ∈ V (T1 (vk )) für irgendein 1 ≤ k ≤ i. Folglich,
α(T1 (v), T2 (w)) = α(T1 (v), θ ) + min {α(T1 (vk ), T2 (w)) − α(T1 (vk ), θ )}.
1≤k≤i
(3) Die Paare (−, T2 [w]) und (T1 [v], T2 [n]) sind Beschriftungen in A für irgendein n ∈
V (T2 (w)). Dann muss die Wurzel von A mit dem Paar (−, T2 [w]) beschriftet sein. In
diesem Fall ist n ∈ V (T2 (wk )) für irgendein 1 ≤ k ≤ j. Folglich,
α(T1 (v), T2 (w)) = α(θ , T2 (w)) + min {α(T1 (v), T2 (wk )) − α(θ , T2 (wk ))}.
1≤k≤ j
(4) Die Paare (T1 [v], −) und (−, T2 [w]) sind Beschriftungen in A. Entfernt man die
zwei Knoten mit diesen Beschriftungen und fügt stattdessen einen Knoten mit
der Beschriftung (T1 [v], T [w]) in A ein, entsteht eine neue Ausrichtung von
T1 (v) und T2 (w), dessen Kosten aufgrund der Dreiecksungleichung γ(T[ v], T [w]) ≤
γ(T1 [v], −) + γ(−, T2 [w]) kleiner oder gleich sind als die der ursprünglichen Ausrichtung. Aus diesem Grund sind die Kosten dieses Falles kleiner oder gleich der
Kosten im Fall (1), so dass der Fall (4) nicht getrennt behandelt werden muss.
Das Minimum aller betrachteten Fälle liefert schließlich die Gleichung (6).
Da die Baum-Alignment-Distanz α(T1 (v), T2 (w)) in der Rekursionsformel (6) von der
Wald-Alignment-Distanz α(F1 (v), F2 (w)) abhängt, ist ein weiterer Satz notwendig, der
eine Berechnungsvorschrift für die Alignment-Distanz zwischen den Wäldern angibt.
Satz 5.2
Seien T1 und T2 geordnete Bäume, deren Knoten in Postordnung von links nach rechts
durchnummeriert sind. Sei v ∈ V (T1 ) und v1 , . . . , vi die Folge seiner Kinder. Sei w ∈ V (T2 )
Kapitel 5. Verfahren zur Berechnung der Baum-Alignment-Distanz
43
und w1 , . . . , w j die Folge seiner Kinder. Dann gilt für alle s,t mit 1 ≤ s ≤ i und 1 ≤ t ≤ j:


α(F1 (v1 , vs−1 ), F2 (w1 , wt )) + α(T1 (vs ), θ ),



α(F1 (v1 , vs ), F2 (w1 , wt−1 )) + α(θ , T2 (wt )),





α(F1 (v1 , vs−1 ), F2 (w1 , wt−1 )) + α(T1 (vs ), T2 (wt )),



min {α(F1 (v1 , vk−1 ), F2 (w1 , wt−1 ))
α(F1 (v1 , vs ), F2 (w1 , wt )) = min 1≤k<s



+α(F1 (vk , vs ), F2 (wt ))} + γ(−, T2 [wt ]),





min {α(F1 (v1 , vs−1 ), F2 (w1 , wk−1 ))


1≤k<t



+α(F1 (vs ), F2 (wk , wt ))} + γ(T1 [vs ], −).
Beweis:
Betrachte eine optimale Ausrichtung A von Wäldern F1 (v1 , vs ) und F2 (w1 , wt ). Es gibt
insgesamt drei Möglichkeiten wie das Paar der rechtesten Wurzel in A aus den Symbolen
der Wurzeln vs und wt zusammengesetzt sein könnte:
(1) Das Paar ist (T1 [vs ], T2 [wt ]). Dann muss der rechteste Baum in A eine optimale Ausrichtung von Bäumen T (vs ) und T (wt ) sein. Folglich,
α(F1 (v1 , vs ), F2 (w1 , wt )) = α(F1 (v1 , vs−1 ), F2 (w1 , wt−1 )) + α(T1 (vs ), T2 (wt )).
(2) Das Paar ist (T1 [vs ], −). In diesem Fall existiert ein k mit 1 ≤ k ≤ t + 1, so dass der
rechteste Baum T1 (vs ) in A mit dem Teilwald F2 (wk , wt ) ausgerichtet ist. Hierbei
sind drei Unterfälle zu berücksichtigen:
(a) (k = t + 1) : Dann ist T1 (vs ) mit F2 (wt+1 , wt ) = θ ausgerichtet und es folgt,
α(F1 (v1 , vs ), F2 (w1 , wt )) = α(F1 (v1 , vs−1 ), F2 (w1 , wt )) + α(T1 (vs ), θ ).
(b) (k = t) : Dann ist T1 (vs ) mit F2 (wt , wt ) = T2 (wt ) ausgerichtet und es folgt
Fall (1).
(c) (1 ≤ k < t) : Dann ist T1 (vs ) mit einem solchen Wald F2 (wk , wt ) ausgerichtet,
der in A enthalten ist. Also,
α(F1 (v1 , vs ), F2 (w1 , wt )) = min {α(F1 (v1 , vs−1 ), F2 (w1 , wk−1 ))
1≤k<t
+ α(F1 (vs ), F2 (wk , wt ))}
+ γ(T1 [vs ], −).
(3) Das Paar ist (−, T2 [wt ]). Symmetrisch zu Fall (2).
Das Minimum aller betrachteten Fälle liefert schließlich die gesuchte Gleichung.
Um die Alignment-Distanz α(T1 (v), T2 (w)) mit dem Satz 5.1 in einer konstanten
Zeit bestimmen zu können, ist es zunächst erforderlich alle Alignment-Distanzen
α(T1 (m), T2 (n)) für m ≤ v und n ≤ w mit m + n < v + w vorher zu berechnen. Es bietet sich
44
Approximative Suche in Baumstrukturen
daher an, die Rekursionen in einer Bottom-up-Manier mittels dynamischer Programmierung zu implementieren. Weiterhin muss zur Bestimmung von α(T1 (v), T2 (w)) die
Wald-Alignment-Distanz α(F1 (v), F2 (w)) berechnet werden. Um sie in einer konstanten
Zeit bestimmen zu können, müssen nach dem Satz 5.2 folgende Alignment-Dsitanzen
bereits berechnet sein:
(1) α(F1 (v), F2 (w1 , w j−1 )), α(F1 (v1 , vi−1 ), F2 (w))
und α(F1 (v1 , v p ), F2 (w1 , wq )), für 0 ≤ p < i, 0 ≤ q < j,
(2) α(F1 (v p ), F2 (wk , wq )), für 1 ≤ p ≤ i, 1 ≤ k ≤ q ≤ j,
(3) α(F1 (vk , v p ), F2 (wq )), für 1 ≤ k ≤ p ≤ i, 1 ≤ q ≤ j.
Es müssen also für jedes Paar von Teilbäumen T1 (v) und T2 (w) auch die AlignmentDistanzen α(F1 (v), F2 (ws , wt )) für alle 1 ≤ s ≤ t ≤ j und α(F1 (vs , vt ), F2 (w)) für alle
1 ≤ s ≤ t ≤ i berechnet werden. Das bedeutet, dass F1 (v) mit allen Teilwäldern von F2 (w)
und umgekehrt F2 (w) mit allen Teilwäldern von F1 (v) ausgerichtet werden muss. Dazu verwendet der Jiang-Wang-Zhang-Algorithmus die Funktion compute_alpha, die
mit den Parametern vs , vi ∈ F1 (v) und wt , w j ∈ F2 (w) aufgerufen wird, und für ein bestimmtes s mit 1 ≤ s ≤ i und ein bestimmtes t mit 1 ≤ t ≤ j die Menge der AlignmentDistanzen As,t = {α(F1 (vs , v p ), F2 (wt , wq )) | s ≤ p ≤ i,t ≤ q ≤ j} berechnet. Infolgedessen
wird compute_alpha im Laufe des Algorithmus zur Bestimmung der Mengen As,1
und A1,t für alle 1 ≤ s ≤ i und 1 ≤ t ≤ j aufgerufen. Unter Annahme, dass alle Werte
α(F1 (v p ), F2 (wk , wq )) für 1 ≤ p ≤ i und 1 ≤ k ≤ q ≤ j, und alle α(F1 (vk , v p ), F2 (wq )) für
1 ≤ k ≤ p ≤ i und 1 ≤ q ≤ j bereits vorliegen, wird die Funktion compute_alpha ebenfalls bottom-up unter Ausnutzung dynamischer Programmierung nach den Rekursionen
des Satzes 5.2 konstruiert.
Eingabe : Knoten vs , vi ∈ F1 (v) und wt , w j ∈ F2 (w).
Ausgabe: {α(F1 (vs , v p ), F2 (wt , wq )) | s ≤ p ≤ i und t ≤ q ≤ j}.
1:
2:
3:
4:
5:
6:
7:
8:
α(F1 (vs , vs−1 ), F2 (wt , wt−1 )) := 0
for p := s to i do
α(F1 (vs , v p ), F2 (wt , wt−1 )) := α(F1 (vs , v p−1 ), F2 (wt , wt−1 )) + α(T1 (v p ), θ )
for q := t to j do
α(F1 (vs , vs−1 ), F2 (wt , wq )) := α(F1 (vs , vs−1 ), F2 (wt , wq−1 )) + α(θ , T2 (wq ))
for p := s to i do
for q := t to j do
Berechne α(F1 (vs , v p ), F2 (wt , wq )) unter Anwendung des Satzes 5.2.
Funktion compute_alpha(vs , vi , wt , w j )
Der Algorithmus 5.2 zeigt den Jiang-Wang-Zhang-Algorithmus übersichtlich in
einer allgemeinen Form, die verschiedene Implementierungen bezüglich der
Speichereffizienz erlaubt. Eine konkrete von mir in dieser Arbeit mit Programmiersprache Java umgesetzte Implementierung des Jiang-Wang-ZhangAlgorithmus kann im Quelltext auf der beiliegenden CD eingesehen werden.
45
Kapitel 5. Verfahren zur Berechnung der Baum-Alignment-Distanz
Eingabe : Baum T1 und T2 .
Ausgabe: α(T1 , T2 ).
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
α(θ , θ ) := 0
for v := 1 to |T1 | do
α(F1 (v), θ ) := ∑ik=1 α(T1 (vk ), θ )
α(T1 (v), θ ) := α(F1 (v), θ ) + γ(T1 [v], −)
for w := 1 to |T2 | do
j
α(θ , F2 (w)) := ∑k=1 α(θ , T2 (wk ))
α(θ , T2 (w)) := α(θ , F2 (w)) + γ(−, T2 [w])
for v := 1 to |T1 | do
for w := 1 to |T2 | do
/* Richte F2 (w) mit allen Teilwäldern von F1 (v) aus.
for s := 1 to i do
/* Aufruf der Funktion compute_alpha für
/* F1 (vs , vi ) und F2 (w).
call compute_alpha (vs , vi , w1 , w j ).
/* Richte F1 (v) mit allen Teilwäldern von F2 (w) aus.
for t := 1 to j do
/* Aufruf der Funktion compute_alpha für
/* F1 (v) und F2 (wt , w j ).
call compute_alpha (v1 , vi , wt , w j ).

α(T1 (v), θ )





+ min {α(T1 (vk ), T2 (w)) − α(T1 (vk ), θ )};


1≤k≤i

α(T1 (v), T2 (w)) := min α(θ , T2 (w))



min {α(T1 (v), T2 (wk )) − α(θ , T2 (wk ))};


1≤k≤ j



α(F1 (v), F2 (w)) + γ(T1 [v], T2 [w]).
*/
*/
*/
*/
*/
*/
print "Alignment-Distanz ist α(T1 (|T1 |), T2 (|T2 |))".
Algorithmus 5.2: Jiang-Wang-Zhang-Algorithmus
Satz 5.3
Die Berechnung der Alignment-Distanz zweier geordneter beschrifteter Bäume T1 , T2 mit
dem Jiang-Wang-Zhang-Algorithmus benötigt O(|T1 | · |T2 | · ((deg(T1 ) + deg(T2 ))2 ) Zeiteinheiten.
Beweis:
Für eine Eingabe vs , vi ∈ F1 (v) und wt , w j ∈ F2 (w) benötigt die Funktion compute_alpha
˙ − s + j − t)) = O(i · j · (i + j)). Somit braucht der Algorithmus,
die Zeit O((i − s) · ( j − t)(i
für ein Paar v und w, O(i · j · (i + j)2 ) Zeit. Dementsprechend braucht der Algorithmus für
46
Approximative Suche in Baumstrukturen
alle Paare von Knoten v und w folgende Zeit:
∑
∑
O(deg(v) · deg(w) · (deg(v) + deg(w))2 )
v∈V (T1 ) w∈V (T2 )
≤
∑
∑
O(deg(v) · deg(w) · (deg(T1 ) + deg(T2 ))2 )
v∈V (T1 ) w∈V (T2 )
≤ O((deg(T1 ) + deg(T2 ))2 ·
∑
deg(v) ·
v∈V (T1 )
≤ O(|T1 | · |T2 | · (deg(T1 ) + deg(T2 ))2 ).
∑
deg(w))
w∈V (T2 )
Der Jiang-Wang-Zhang-Algorithmus berechnet nur die Kosten einer optimalen Ausrichtung. Eine entsprechende optimale Ausrichtung lässt sich aus den berechneten Werten
α(T1 (v), T2 (w)), α(F1 (v), F2 (w)), α(F1 (vs , vt ), F2 (w)) und α(F1 (v), F2 (ws , wt )) in derselben
Zeit- und Speicherkomplexität durch einfache Rückverfolgungstechniken bestimmen.
47
Kapitel 6. Approximative Baumsuche
6 Approximative Baumsuche
6.1 Das approximative Baum-Matching-Problem
In vielen Anwendungsgebieten der Dokumentenverarbeitung und der Bioinformatik
[WS81] geht es darum, eine Zeichenkette oder ein Suchmuster, das sogenannte Pattern, in einem größeren Text möglichst effizient mit Textalgorithmen [CR94] zu finden.
Man interessiert sich dabei z.B. für das Erkennen von Texten, die Schreib- oder Sprachfehler enthalten, oder auch für DNA-Sequenzen, die durch etwaige Mutationen oder
andere Manipulationen verändert wurden. Hierbei ist oft nicht nur ein exaktes Auftreten eines Patterns in einem Text von Interesse, sondern auch Textstellen, wo gewisse
Abweichungen und Übereinstimmungen des Patterns erlaubt sind. Man sucht also bestimmte Stellen im Text, die dem gegebenen Pattern am ähnlichsten sind. Dabei wird
die Ähnlichkeit zwischen Zeichenketten über die Edit-Distanz festgestellt, die in diesem
Fall die minimalen Kosten angibt, eine gefundene Textstelle mit Edit-Operationen in das
gegebene Pattern zu transformieren. Die Bestimmung der minimalen Edit-Distanz unter
allen Edit-Distanzen zwischen einer aufeinanderfolgenden Teilzeichenkette eines Textes und einem gegebenen Pattern führt auf das approximative String-Matching-Problem
hinaus, das im Folgenden formal definiert wird.
Definition 6.1 (Das approximative String-Matching-Problem)
Sei Σ ein Alphabet und t1 ,t2 ∈ Σ∗ zwei Zeichenketten, wobei t1 die Länge |t1 | = n hat. Dann
bezeichnet δ (t1 ,t2 ) die Edit-Distanz zwischen t1 und t2 und
∆ (t1 ,t2 ) = min {δ (t1 [ j..n],t2 )}.
1≤ j≤i+1
Gegeben ist eine Zeichenkette t ∈ Σ∗ und ein Pattern p ∈ Σ∗ . Das approximative StringMatching-Problem besteht darin, für alle 1 ≤ i ≤ |t|, ∆ (t[1..i], p) zu berechnen.
In dem approximativen String-Matching-Problem geht es also darum, für 1 ≤ i ≤ |t| alle
Edit-Distanzen zwischen der Zeichenkette t[1..i] und dem Pattern p zu berechnen, wenn
vorher in t[1..i] ein beliebig langes Präfix kostenfrei entfernt werden kann. Somit lässt
sich durch die Lösung des approximativen String-Matching-Problems eine Teilzeichnekette in einer Zeichenkette t finden, die dem gegeben Pattern p am ähnlichsten ist, wenn
man anschließend aus den berechneten Edit-Distanzen min1≤i≤|t| ∆ (t[1..i], p) bestimmt.
Da eine Zeichenkette durch einen Baum repräsentiert werden kann, in welchem alle
Nicht-Blattknoten genau ein Kind besitzen, ist es sinnvoll das approximative StringMatching-Problem auf Bäume zu erweitern, um damit mehrdimensionale Probleme lösen zu können. In [ZS89] übertragen Zhang und Shasha das Problem von Zeichenketten
48
Approximative Suche in Baumstrukturen
auf Bäume, indem sie statt den Präfixen von Zeichenketten, eine Menge von Teilbäumen
bzw. Teilwäldern aus einem gegebenen Baum entfernen. Dazu führen sie zwei folgende
neue Edit-Operationen ein, die kostenfrei auf einem Baum T ausgeführt werden können.
Definition 6.2 (Zusätzliche Edit-Operationen)
Entfernung eines Knotens v in T : Entferne den gesamten Teilbaum T (v), einschließlich v,
und die Kante (v, p(v)) aus T 1 . (siehe Abbildung 6.1a)
Beschneidung eines Knotens v in T : Entferne alle echten Nachfolger von v zusammen mit
allen sie verbindenden Kanten aus T 2 . (siehe Abbildung 6.1b)
Um alle aus einem Baum zu entfernenden Knoten auf einmal bequem über eine Operation angeben zu können, müssen zunächst weitere Begriffe eingeführt werden.
Definition 6.3 (Konsistenz)
Zwei Knoten v und w mit v 6= w heißen konsistent, wenn keiner von ihnen ein Nachfolger
des jeweils anderen ist. D.h. v ist nicht ein Nachfolger von w und w ist nicht ein Nachfolger
von v.
Eine Menge C von Knoten aus T ist konsistent, wenn jede zwei Knoten v, w ∈ C mit v 6= w
konsistent sind. Die Menge aller konsistenten Mengen von Knoten aus T wird als ϒ (T )
bezeichnet.
Des Weiteren werden zwei neue Operation auf Bäumen definiert, die auf den EditOperationen Entfernung und Beschneidung von Knoten beruhen.
Definition 6.4 (Entferne- und Schneide-Operation)
Sei T ein Baum. Für alle C ∈ ϒ (T ) definiere zwei folgende Operationen auf T .
Entferne-Operation : T C bezeichnet den Baum, der aus T nach Entfernung aller Kno-
ten v ∈ C resultiert.
Schneide-Operation : T  C bezeichnet den Baum, der aus T nach Beschneidung aller
Knoten v ∈ C resultiert.
Jetzt kann das approximative Baum-Matching-Problem nach Zhang und Shasha [ZS89]
auf zwei Weisen über die Entferne-Operation oder die Schneide-Operation  definiert
werden.
Definition 6.5 (Das approximative Baum-Matching-Problem)
Seien T1 , T2 zwei Bäume. Definiere
Ψ (T1 , T2 ) = min {δ (T1 C, T2 )}
C∈ϒ (T1 )
1 Wenn
Knoten von T in Postordnung nummeriert sind, wird der komplette Teilbaum T [l(v)..v] entfernt.
Knoten von T in Postordnung nummeriert sind, wird der komplette Teilwald T [l(v)..v − 1] entfernt.
2 Wenn
49
Kapitel 6. Approximative Baumsuche
T’
T
9
9
3
1
8
2
6
4
3
7
1
2
5
(a)
T’
T
9
9
3
1
8
2
6
4
3
7
1
8
2
5
(b)
Abbildung 6.1: In Abbildung (a) und (b) sind Beispiele der neuen kostenfreien Edit-Operationen, Entfernung und Beschneidung von Knoten, abgebildet. Der Einfachheit halber sind alle Knoten mit ihrer Nummerierung in Postordnung beschriftet.
(a) Entfernung des Knotens 8.
(b) Beschneidung des Knotens 8.
50
Approximative Suche in Baumstrukturen
und
Φ(T1 , T2 ) = min {δ (T1  C, T2 )}.
C∈ϒ (T1 )
Gegeben ist ein Baum T und ein Baum P („das Pattern“). Das approximative BaumMatching-Problem besteht darin, für alle v ∈ T , Ψ (T (v), P) oder Φ(T (v), P) zu berechnen.
Sind statt zwei Bäumen T, P zwei Wälder F, P gegeben, dann wird die Berechnung,
für alle v ∈ F, von Ψ (F(v), P) und Φ(F(v), P) das approximative Wald-Matching-Problem
bezeichnet.
Der nächste Satz gibt eine rekursive Berechnungsvorschrift zur Lösung des approximativen Baum-Matching-Problems über die Entferne-Operation an. Er zeigt wie sich für
zwei gegebene Bäume T1 und T2 alle Edit-Distanzen zwischen T1 (v) und T2 mit v ∈ T1 berechnen lassen, wenn Null oder mehr Teilbäume vorher mit der Operation aus T1 (v)
ohne Kosten entfernt werden können.
Satz 6.1
Seien T1 und T2 geordnete Bäume, deren Knoten in Postordnung von links nach rechts
durchnummeriert sind. Seien v ∈ V (T1 ), w ∈ V (T2 ), i ∈ {l(v), . . . , v} und j ∈ {l(w), . . . , w}.
Dann gelten folgende Rekursionen:
(1) Ψ (θ , θ ) = 0,
(2) Ψ (T1 [l(v)..i], θ ) = 0,
(3) Ψ (θ , T2 [l(w).. j]) = Ψ (θ , T2 [l(w).. j − 1]) + γ(−, T2 [ j]),

Ψ (T1 [l(v)..l(i) − 1], T2 [l(w).. j]),





Ψ (T1 [l(v)..i − 1], T2 [l(w).. j]) + γ(T1 [i], −),



Ψ (T [l(v)..i], T [l(w).. j − 1]) + γ(−, T [ j]),
1
2
2
(4) Ψ (T1 [l(v)..i], T2 [l(w).. j]) = min

Ψ
(T
[l(v)..l(i)
−
1],
T
[l(w)..l(
j)
−
1])
1
2




 +Ψ (T1 [l(i)..i − 1], T2 [l( j).. j − 1])



+γ(T1 [i], T2 [ j]).
Beweis:
Die erste Gleichung ist trivial, da die Kosten einer Edit-Distanz-Abbildung zwischen
zwei leeren Baumstrukturen gleich Null sind. In der zweiten Gleichung können alle
Bäume, aus denen sich der Wald T1 [l(v)..i] zusammensetzt, ohne Kosten mit der Operation entfernt werden, so dass am Ende nur ein leerer Wald übrig bleibt und es
Ψ (T1 [l(v)..i], θ ) = δ (θ , θ ) = 0 gilt. In der dritten Gleichung können keine Knoten des ersten Waldes mehr entfernt werden und es ergibt sich der gleiche Fall des Satzes 3.4 für
die Gleichung (3). Für die vierte Gleichung sei C ∈ ϒ (T1 [l(v)..i]) eine konsistente Menge,
die δ (T1 [l(v)..i] C, T2 [l(w).. j]) derart minimiert, dass es δ (T1 [l(v)..i] C, T2 [l(w).. j]) =
Ψ (T1 [l(v)..i], T2 [l(w).. j]) gilt. Dann gibt es für den Knoten i zwei Möglichkeiten:
(1) i ∈ C : In diesem Fall wird der ganze Teilbaum T (i) in T1 [l(v)..i] ohne Kosten ent-
Kapitel 6. Approximative Baumsuche
51
fernt und es ergibt sich:
Ψ (T1 [l(v)..i], T2 [l(w).. j]) = Ψ (T1 [l(v)..l(i) − 1], T2 [l(w).. j]).
(2) i ∈
/ C : In diesem Fall wird i nicht mit der Operation aus T1 [l(v)..i] entfernt. Betrachte nun eine optimale Edit-Distanz-Abbildung M zwischen T1 [l(v)..i] C und
T2 [l(w).. j]. Hierbei ergeben sich wiederum die gleichen drei Fälle wie in der Gleichung (4) des Satzes 3.4.
Das Minimum aller behandelten Fälle liefert die Gleichung (4).
Genauso wie bei den Rekursionsformeln des Satzes 3.4 zur Berechnung der EditDistanz, lässt sich auch die Gleichung (4) des Satzes 6.1 vereinfachen und in zwei Teile
getrennt für Bäume und Wälder zerlegen.
Satz 6.2
Seien T1 und T2 geordnete Bäume, deren Knoten in Postordnung von links nach rechts
durchnummeriert sind. Seien v ∈ V (T1 ), w ∈ V (T2 ), i ∈ {l(v), . . . , v} und j ∈ {l(w), . . . , w}.
(1) Falls l(i) = l(v) und l( j) = l(w), dann gilt:

Ψ (θ , T2 [l(w).. j]),



Ψ (T [l(v)..i − 1], T [l(w).. j]) + γ(T [i], −),
1
2
1
Ψ (T1 [l(v)..i], T2 [l(w).. j]) = min

Ψ (T1 [l(v)..i], T2 [l(w).. j − 1]) + γ(−, T2 [ j]),



Ψ (T1 [l(v)..i − 1], T2 [l(w).. j − 1]) + γ(T1 [i], T2 [ j]).
(2) Sonst:


Ψ (T1 [l(v)..l(i) − 1], T2 [l(w).. j]),





Ψ (T1 [l(v)..i − 1], T2 [l(w).. j]) + γ(T1 [i], −),
Ψ (T1 [l(v)..i], T2 [l(w).. j]) = min Ψ (T1 [l(v)..i], T2 [l(w).. j − 1]) + γ(−, T2 [ j]),



Ψ (T1 [l(v)..l(i) − 1], T2 [l(w)..l( j) − 1])



 +Ψ (T (i), T ( j)).
1
2
Der Beweis des obigen Satzes ist analog zu Satz 4.1 und wird hier deshalb nicht wiederholt.
Jetzt kann der Zhang-Shasha-Algorithmus umgeändert werden, damit er für zwei gegebene Bäume T1 und T2 , alle Edit-Distanzen zwischen T1 (v) und T2 mit v ∈ T1 berechnet, wenn Null oder mehr Teilbäume aus T1 (v) mit der Operation entfernt werden
können. Dazu muss nur die Funktion compute_delta im Zhang-Shasha-Algorithmus
mit einer neuen Funktion ausgetauscht werden, die die Rekursionsformeln der Sätze
6.1 und 6.2 umsetzt. Hierfür wird die Funktion compute_Psi in derselben Weise wie
52
Approximative Suche in Baumstrukturen
compute_delta mit dynamischer Programmierung in Bottom-Up-Ordnung konstruiert.
Eingabe : Knoten v ∈ V (T1 ) und w ∈ V (T2 ).
Ausgabe: {Ψ (T1 [l(v)..i], T2 [l(w).. j]) | i ∈ {l(v), . . . , v} und j ∈ {l(w), . . . , w}}.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
θ1 := l(v) − 1
θ2 := l(w) − 1
forestDist[θ1 , θ2 ] = 0
for i := l(v) to v do
forestDist[i, θ2 ] = 0
for j := l(w) to w do
forestDist[θ1 , j] = forestDist[θ1 , j − 1] + γ(−, T2 [ j])
for i := l(v) to v do
for j := l(w) to w do
if l(i) = l(v) and l( j) = l(w) then

forestDist[θ1 , j];



forestDist[i − 1, j] + γ(T [i], −);
1
forestDist[i, j] := min

forestDist[i, j − 1] + γ(−, T2 [ j]);



forestDist[i − 1, j − 1] + γ(T1 [i], T2 [ j]).
treeDist[i, j] := forestDist[i, j].
else

forestDist[l(i) − 1, j];



forestDist[i − 1, j] + γ(T [i], −);
1
forestDist[i, j] := min

forestDist[i,
j
−
1]
+
γ(−,
T2 [ j]);



forestDist[l(i) − 1, l( j) − 1] + treeDist[i, j].
Funktion compute_Psi(v, w)
Soll das approximative Baum-Matching-Problem für Bäume T1 , T2 hingegen über die
Schneide-Operation gelöst werden, d.h. die Edit-Distanz zwischen T1 (v) und T2 für alle v ∈ T1 berechnet werden, wenn Null oder mehr Knoten in T1 (v) mit der Operation
 abgeschnitten werden können, so kann eine Berechnungsvorschrift dazu aus dem
nächsten Satz entnommen werden.
Satz 6.3
Seien T1 und T2 geordnete Bäume, deren Knoten in Postordnung von links nach rechts
durchnummeriert sind. Seien v ∈ V (T1 ), w ∈ V (T2 ), i ∈ {l(v), . . . , v} und j ∈ {l(w), . . . , w}.
Dann gelten folgende Rekursionen:
(1) Φ(θ , θ ) = 0,
(2) Φ(T1 [l(v)..i], θ ) = Φ(T1 [l(v)..l(i) − 1], θ ) + γ(T1 [i], −),
(3) Φ(θ , T2 [l(w).. j]) = Φ(θ , T2 [l(w).. j − 1]) + γ(−, T2 [ j]),
Kapitel 6. Approximative Baumsuche
53


Φ(T1 [l(v)..l(i) − 1], T2 [l(w).. j]) + γ(T1 [i], −),





Φ(T1 [l(v)..i − 1], T2 [l(w).. j]) + γ(T1 [i], −),





Φ(T1 [l(v)..i], T2 [l(w).. j − 1]) + γ(−, T2 [ j]),





Φ(T1 [l(v)..l(i) − 1], T2 [l(w)..l( j) − 1])
(4) Φ(T1 [l(v)..i], T2 [l(w).. j]) = min
+Φ(θ , T2 [l( j).. j − 1])



+γ(T1 [i], T2 [ j]),





Φ(T1 [l(v)..l(i) − 1], T2 [l(w)..l( j) − 1])





+Φ(T1 [l(i)..i − 1], T2 [l( j).. j − 1])



 +γ(T [i], T [ j]).
1
2
Beweis:
Die erste und die dritte Gleichung entsprechen genau den Rekursionsformeln (1) und
(3) des Satzes 3.4 zur Berechnung der Edit-Distanz, da der erste Baum leer ist und
sich dort somit keine Knoten abschneiden lassen. In der zweiten Gleichung kann der
gesamte Teilbaum T1 (i) ohne Kosten in T1 [l(v)..i] mit der Operation  abgeschnitten
werden. Somit ist die Edit-Distanz in diesem Fall
Φ(T1 [l(v)..i], θ ) = Φ(T1 [l(v)..l(i) − 1], θ ) + γ(T1 [i], −).
Für die vierte Gleichung sei C eine konsistente Menge, die δ (T1 [l(v)..i]  C, T2 [l(w).. j])
derart minimiert, dass es δ (T1 [l(v)..i]  C, T2 [l(w).. j]) = Ψ (T1 [l(v)..i], T2 [l(w).. j]) gilt.
Weiterhin sei M eine optimale Edit-Distanz-Abbildung zwischen T1 [l(v)..i]  C und
T2 [l(w).. j]. Dabei ergeben sich wie im Fall der vierten Gleichung des Satzes 3.4 für die
Knoten i und j in Zusammenhang mit M insgesamt drei Möglichkeiten:
(1) i ∈
/ {v | (v, w) ∈ M} : Dann muss i in T1 [l(v)..i] gelöscht werden. Hier unterscheidet
man zwei Unterfälle:
(a) i ∈ C : Dann folgt
Φ(T1 [l(v)..i], T2 [l(w).. j]) = Φ(T1 [l(v)..l(i) − 1], T2 [l(w).. j]) + γ(T1 [i], −).
(b) i ∈
/ C : Dann folgt
Φ(T1 [l(v)..i], T2 [l(w).. j]) = Φ(T1 [l(v)..i − 1], T2 [l(w).. j]) + γ(T1 [i], −).
(2) j ∈
/ {w | (v, w) ∈ M} : Dann muss j in T2 [l(w)..w] Da nur Knoten in T1 abgeschnitten
werden dürfen, gibt es hier nur einen Fall:
Φ(T1 [l(v)..i], T2 [l(w).. j]) = Φ(T1 [l(v)..i], T2 [l(w).. j − 1]) + γ(−, T2 [ j]).
(3) (i, j) ∈ M : Hierbei existieren wieder zwei Unterfälle:
(a) i ∈ C : Dann folgt
Φ(T1 [l(v)..i], T2 [l(w).. j]) = Φ(T1 [l(v)..l(i) − 1], T2 [l(w)..l( j) − 1])
+ Φ(θ , T2 [l( j).. j − 1]) + γ(T1 [i], T2 [ j]).
54
Approximative Suche in Baumstrukturen
(b) i ∈
/ C : Dann folgt
Φ(T1 [l(v)..i], T2 [l(w).. j]) = Φ(T1 [l(v)..l(i) − 1], T2 [l(w)..l( j) − 1])
+ Φ(T1 [l(i)..i − 1], T2 [l( j).. j − 1]) + γ(T1 [i], T2 [ j]).
Das Minimum aller behandelten Fälle liefert die Gleichung (4).
Wiederum lässt sich die vierte Gleichung des Satzes 6.3 vereinfachen und in folgende
zwei Teile zerlegen. Der erste Teil gibt mit der Bedingung l(i) = l(v) und l( j) = l(w) das
approximative Baum-Matching-Problem an, wogegen der zweite Teil für das approximative Wald-Matching-Problem steht.
Satz 6.4
Seien T1 und T2 geordnete Bäume, deren Knoten in Postordnung von links nach rechts
durchnummeriert sind. Seien v ∈ V (T1 ), w ∈ V (T2 ), i ∈ {l(v), . . . , v} und j ∈ {l(w), . . . , w}.
(1) Falls l(i) = l(v) und l( j) = l(w), dann gilt:


Φ(θ , T2 [l(w).. j − 1]) + γ(T1 [i], T2 [ j]),

Φ(T [l(v)..i − 1], T [l(w).. j]) + γ(T [i], −),
1
2
1
Φ(T1 [l(v)..i], T2 [l(w).. j]) = min

Φ(T1 [l(v)..i], T2 [l(w).. j − 1]) + γ(−, T2 [ j]),



Φ(T1 [l(v)..i − 1], T2 [l(w).. j − 1]) + γ(T1 [i], T2 [ j]).
(2) Sonst:


Φ(T1 [l(v)..l(i) − 1], T2 [l(w).. j]) + γ(T1 [i], −),





Φ(T1 [l(v)..i − 1], T2 [l(w).. j]) + γ(T1 [i], −),
Φ(T1 [l(v)..i], T2 [l(w).. j]) = min Φ(T1 [l(v)..i], T2 [l(w).. j − 1]) + γ(−, T2 [ j]),



Φ(T1 [l(v)..l(i) − 1], T2 [l(w)..l( j) − 1])



 +Φ(T (i), T ( j)).
1
2
Beweis:
Betrachte die Gleichung (4) des Satzes 6.3. Falls l(i) = l(v) und l( j) = l(w), dann wird
aus dem ersten Fall der Minimumfunktion,
Φ(θ , T2 [l(w).. j]) + γ(T1 [i], −),
(6.1)
Φ(θ , T2 [l(w).. j − 1]) + γ(T1 [i], T2 [ j]).
(6.2)
und aus dem vierten Fall,
Setze Gleichung (3) des Satzes 6.3 in die Gleichung 6.1 ein. Dann folgt
Φ(θ , T2 [l(w).. j]) + γ(T1 [i], −) = Φ(θ , T2 [l(w).. j − 1]) + γ(−, T2 [ j]) + γ(T1 [i], −)
Kapitel 6. Approximative Baumsuche
55
und mit der Dreiecksungleichung
≥ Φ(θ , T2 [l(w).. j − 1]) + γ(T1 [i], T2 [ j]).
Es gilt also, dass Gleichung 6.1 ≥ Gleichung 6.2. Somit ersetzt die Distanz der Gleichung
6.2 in der Rekursionsformel (1) zwei der oben untersuchten Fälle. Außerdem gilt für
den fünften Fall der Minimumfunktion,
Φ(T1 [l(v)..l(i) − 1], T2 [l(w)..l( j) − 1]) + Φ(T1 [l(i)..i − 1], T2 [l( j).. j − 1]) + γ(T1 [i], T2 [ j])
= Φ(T1 [l(i)..l(i) − 1], T2 [l( j)..l( j) − 1]) + Φ(T1 [l(i)..i − 1], T2 [l( j).. j − 1]) + γ(T1 [i], T2 [ j])
= Φ(θ , θ ) + Φ(T1 [l(i)..i − 1], T2 [l( j).. j − 1]) + γ(T1 [i], T2 [ j])
= Φ(T1 [l(i)..i − 1], T2 [l( j).. j − 1]) + γ(T1 [i], T2 [ j]).
Demzufolge ist die Rekursionsformel (1) korrekt.
Falls l(i) 6= l(v) oder l( j) 6= l(w), so können die Fälle vier und fünf der Minimumfunktion
nach dem gleichen Muster wie im Satz 4.1 durch
Φ(T1 [l(v)..l(i) − 1], T2 [l(w)..l( j) − 1]) + Φ(T1 (i), T2 ( j))
ersetzt werden.
Nun kann auch das approximative Baum-Matching-Problem über die SchneideOperation  mit dem Zhang-Shasha-Algorithmus gelöst werden, indem einfach die
Funktion compute_delta durch die folgende Funktion compute_Phi ersetzt wird,
die nach den Sätzen 6.3 und 6.4 aufgebaut ist.
56
Approximative Suche in Baumstrukturen
Eingabe : Knoten v ∈ V (T1 ) und w ∈ V (T2 ).
Ausgabe: {Φ(T1 [l(v)..i], T2 [l(w).. j]) | i ∈ {l(v), . . . , v} und j ∈ {l(w), . . . , w}}.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
θ1 := l(v) − 1
θ2 := l(w) − 1
forestDist[θ1 , θ2 ] = 0
for i := l(v) to v do
forestDist[i, θ2 ] = forestDist[l(i) − 1, θ2 ] + γ(T1 [i], −)
for j := l(w) to w do
forestDist[θ1 , j] = forestDist[θ1 , j − 1] + γ(−, T2 [ j])
for i := l(v) to v do
for j := l(w) to w do
if l(i) = l(v) and l( j) = l(w) then

forestDist[θ1 , j − 1] + γ(T1 [i], T2 [ j]);



forestDist[i − 1, j] + γ(T [i], −);
1
forestDist[i, j] := min

forestDist[i,
j
−
1]
+
γ(−,
T2 [ j]);



forestDist[i − 1, j − 1] + γ(T1 [i], T2 [ j]).
treeDist[i, j] := forestDist[i, j].
else

forestDist[l(i) − 1, j] + γ(T1 [i], −);



forestDist[i − 1, j] + γ(T [i], −);
1
forestDist[i, j] := min

forestDist[i, j − 1] + γ(−, T2 [ j]);



forestDist[l(i) − 1, l( j) − 1] + treeDist[i, j].
Funktion compute_Phi(v, w)
Es ist offensichtlich, dass die beiden in diesem Abschnitt vorgestellten abgeänderten Versionen des Zhang-Shasha-Algorithmus zur Lösung des approximativen Baum-MatchingProblems die gleiche Zeit- und Speicherkomplexität wie der ursprüngliche Algorithmus
besitzen.
6.2 Approximative Baumsuche nach Jansson und Peng
Die in dieser Abreit bisher vorgestellten Verfahren, wie der Zhang-Shasha- oder JiangWang-Zhang-Algorithmus, vergleichen ganze Baumstrukturen miteinander und helfen dabei eine Aussage über deren Ähnlichkeit zu treffen. In vielen hierarchischen
Strukturen, wie den XML-Dokumenten [CAM02] oder den RNA-Sekundärstrukturen
[HTGK03, SZ90], die mit Bäumen modelliert werden können, geht es aber auch oft
darum, bestimmte zusammenhängende Teilstrukturen bzw. Suchmuster (Pattern) zu
finden, wobei hier gewisse Abweichungen erlaubt sind. Allgemein könnte man das auftretende Problem folgendermaßen formulieren:
Kapitel 6. Approximative Baumsuche
57
Problem:
Gegeben ist ein Baum T und ein Baum P (das Pattern). Finde eine Teilstruktur von T ,
die zu P am ähnlichsten ist.
Im Gegensatz zu Zeichenketten, wo zusammenhängende Teilbereiche durch aufeinanderfolgende Zeichen wiedergegeben werden, gibt es bei den mehrdimensionalen Strukturen wie Bäumen, viele Möglichkeiten solche Teilstrukturen zu definieren. Beruhend
auf Jansson und Peng [JP06] werden in diesem Abschnitt drei verschiedene Typen von
Teilstrukturen eines Baumes definiert und für jede von ihnen ein Algorithmus zur Lösung des oben beschriebenen Problems angegeben.
Definition 6.6 (Teilstrukturen)
Sei T ein geordneter Baum. Dann werden die Teilstrukturen von T wie folgt definiert:
Einfache Teilstruktur: Ein beliebiger verbundener Teilgraph von T . (siehe Abbildung 6.2b)
Geschwister-Teilstruktur: Eine Menge von disjunkten einfachen Teilstrukturen, dessen Wur-
zeln Geschwister in T sind3 . (siehe Abbildung 6.2c)
Geschlossener Teilwald: Eine Folge von Teilbäumen, dessen Wurzeln aufeinanderfolgende
Geschwister in T sind. (siehe Abbildung 6.2d)
In ihrer Arbeit [JP06] betrachten Jansson und Peng, das in diesem Abschnitt behandelte
Problem anstelle von Bäumen für zwei Wälder. Lösen es aber, indem sie zunächst jeweils
die in den Wäldern vorkommenden Bäume durch eine imaginäre Wurzel verbinden, diese Wurzel mit dem speziellen Symbol ∈
/ Σ beschriften und die Kostenfunktion γ für alle
a, b ∈ Σ durch γ(a, ) = 0, γ(, b) = 0, γ(, ) = 0, γ(, −) ≥ 0, γ(−, ) ≥ 0 erweitern. Auf
diese Weise lösen sie das Problem zwar für Wälder, setzen dennoch alle ihre Algorithmen im engeren Sinne auf Bäume an. Aus diesem Grund werden alle nachfolgenden
Algorithmen nur für Bäume betrachtet. Sie lassen sich jedoch wie bei Jansson und Peng
leicht auf Wälder anwenden. Außerdem werden Algorithmen angegeben, die nur die
Kosten einer optimalen Lösung berechnen. Wie schon im Falle der bisher beschriebenen
Algorithmen, lässt sich die Lösung selbst leicht durch einfache Rückverfolgungstechniken bestimmen.
Als erstes soll der Jansson-Peng-Algorithmus angegeben werden, der für zwei gegebene
Bäume T1 und T2 , die zu T2 ähnlichste einfache Teilstruktur von T1 findet. Sei im Folgen0
den T1 eine einfache Teilstruktur von T1 mit einer Wurzel v ∈ T1 . Laut der Definition 6.6
ist jeder beliebiger verbundener Graph von T1 mit einer Wurzel v ∈ V (T1 ), eine einfache
0
0
Teilstruktur T1 von T1 (v). T1 entsteht also dadurch, dass man alle Knoten irgendeiner
konsistenten Menge C ∈ ϒ (T1 (v)) aus T1 (v) mit der Operation entfernt. Damit kann
jetzt der folgende Satz formuliert werden.
Satz 6.5
0
Sei T ein Baum und v ∈ T . Der Baum T mit einer Wurzel v ist eine einfache Teilstruktur
0
von T gdw. T = T (v) C für irgendein C ∈ ϒ (T (v)).
3 Die
Geschwister müssen nicht notwendigerweise aufeinanderfolgend sein.
58
Approximative Suche in Baumstrukturen
T
33
32
7
22
14
21
31
5
26
1
6
2
3
12
4
17
13
11
29
24 25
28
8
15
9
23
20
16 18
30
19
10
27
(a) Baum T .
22
26
32
7
14
21
12
17
11
31
29
20
5
26
1
6
24 25
30
28
13
2
3
4
8
27
(b) Einfache Teilstruktur
von T .
(c) Geschwister-Teilstruktur
von T .
(d) Geschlossener Teilwald von T .
Abbildung 6.2: Teilstrukturen eines Baumes.
Um eine einfache Teilstruktur von T1 zu finden, die zu T2 am ähnlichsten ist, muss man
für alle v ∈ V (T1 (v)) die Teilstrukturen von T1 (v) mit T2 vergleichen. Nach Satz 6.5 entspricht das, dem Finden einer konsistenten Menge C ∈ ϒ (T1 (v)), die δ (T1 (v) C, T2 )
minimiert. Das korrespondiert mit dem approximativen Baum-Matching-Problem4 und
kann durch dessen Lösung bestimmt werden. Hierfür benutzen Jansson und Peng die
abgeänderte Version des Zhang-Shasha-Algorithmus mit der Funktion compute_Psi
aus dem Abschnitt 6.1 und ersetzen nur den siebten Schritt der Hauptschleife im ZhangShasha-Algorithmus durch minv∈V (T1 ) Ψ (T1 (v), T2 ). In der Implementierung des JanssonPeng-Algorithmus für einfache Teilstrukturen, wird im siebten Schritt der kleinste Eintrag in der permanenten Distanzmatrix treeDist unter allen Zeilen der letzten Spalte, d.h. minv∈V (T1 ) {treeDist[v, |T1 |]}, zurückgegeben, da alle Werte von Edit-Distanzen
Ψ (T1 (v), T2 (w)) unter treeDist[v, w] gespeichert werden. (siehe Algorithmus 6.3)
Als nächstes soll der Jansson-Peng-Algorithmus besprochen werden, der das am Anfang dieses Abschnittes beschriebene Problem für Geschwister-Teilstrukturen löst. Er
entspricht im Wesentlichen dem Algorithmus 6.3, bis auf den letzten Schritt in der
Hauptschleife. Es soll also das nachfolgende Problem gelöst werden.
4 siehe
Definition 6.5
Kapitel 6. Approximative Baumsuche
59
Eingabe : Baum T1 und T2 .
Ausgabe: minv∈V (T1 ) Ψ (T1 (v), T2 ).
/* treeDist[1..|V (T1 )|,1..|V (T2 )|] ist die permanente
Distanzmatrix
*/
/* ----------------- Vorbereitungsphase ----------------- */
1:
berechne l(), K(T1 )[] und K(T2 )[].
/* ------------------- Hauptschleife -------------------- */
6:
for i := 1 to |K(T1 )| do
for j := 1 to |K(T2 )| do
v := K(T1 )[i]
w := K(T2 )[ j]
call compute_Psi(v, w).
7:
return minx∈V (T1 ) {treeDist[x, w]}.
2:
3:
4:
5:
Algorithmus 6.3: Jansson-Peng-Algorithmus zum Finden einer zu T2 ähnlichsten
einfachen Teilstruktur von T1 .
Problem:
Gegeben sind zwei geordnete Bäume T1 und T2 . Gesucht ist eine GeschwisterTeilstruktur von T1 , die zu T2 am ähnlichsten ist.
0
Sei im Folgenden v ∈ V (T1 ) und v1 , . . . , vi die Folge seiner Kinder. Weiterhin sei T1
eine zu T2 ähnlichste Geschwister-Teilstruktur von T1 , deren Wurzeln vs , . . . vt mit
1 ≤ s ≤ t ≤ i die Kinder von v sind. Setze C = {v1 , . . . , vi }\{vs , . . . , vt }. Damit ist die
0
Menge C konsistent und C ∈ ϒ (T1 ). Unter diesen Annahmen ist T1 auch eine zu T2
ähnlichste Geschwister-Teilstruktur des geschlossenen Teilwaldes F1 (v1 , vi ) von T1 , da
0
F1 (v1 , vi ) C = F1 (vs , vt ) = T1 und die Entferne-Operation kostenfrei ist. Infolgedessen
0
ist δ (T1 , T2 ) = Ψ (F1 (v1 , vi ), T2 ) und das zu lösende Problem reduziert sich auf das Finden
von minv∈V (T1 ) {Ψ (F1 (v1 , vi ), T2 )}. Sind die Knoten in Postordnung nummeriert, entspricht
das dem Finden von minv∈V (T1 ) {Ψ (T1 [l(v)..v − 1], T2 )}.
Das hat zur Folge, dass die Funktion compute_Psi in diesem Fall wiederverwendet werden kann. Es wird nur ein zusätzlicher Speicher reserviert, in dem die Werte
Ψ (T1 [l(v)..v − 1], T2 ) für alle v ∈ V (T1 ) in einem Feld dist der Länge |T1 | unter dist[v]
permanent gespeichert werden. Anschließend wird im letzten Schritt des Zhang-ShashaAlgorithmus der Wert minv∈V (T1 ) {dist[v]} zurückgegeben. (siehe Algorithmus 6.4)
Die beiden bisher in diesem Abschnitt vorgestellten Algorithmen 6.3 und 6.4 von Jannson und Peng besitzen dieselbe Zeit- und Speicherkomplexität wie der Zhang-ShashaAlgorithmus. Keines dieser Algorithmen lässt sich für die dritte Variante des Problems,
wo ein zu T2 ähnlichster geschlossener Wald von T1 gesucht wird, anwenden, da sie
für zwei Geschwister-Knoten v1 , v2 ∈ V (T1 ) mit v1 < v2 und v1 ∈ K(T1 ) die Edit-Distanz
δ (F1 (v1 , v2 ), T2 ) nicht berechnen. Weil für zwei verschiedene Schlüsselknoten v, w ∈ K(T1 )
60
Approximative Suche in Baumstrukturen
Eingabe : Baum T1 und T2 .
Ausgabe: minv∈T1 Ψ (T1 [l(v)..v − 1], T2 ).
/* dist[1..|V (T1 )|] ist ein Feld zur Speicherung von
Ψ (T1 [l(v)..v − 1], T2 ).
*/
/* ----------------- Vorbereitungsphase ----------------- */
1:
berechne l(), K(T1 )[] und K(T2 )[].
/* ------------------- Hauptschleife -------------------- */
6:
for i := 1 to |K(T1 )| do
for j := 1 to |K(T2 )| do
v := K(T1 )[i]
w := K(T2 )[ j]
call compute_Psi(v, w).
7:
return minv∈T1 {dist[v]}.
2:
3:
4:
5:
Algorithmus 6.4: Jansson-Peng-Algorithmus zum Finden einer zu T2 ähnlichsten
Geschwister-Teilstruktur von T1 .
stets l(v) 6= l(w) gilt, wird die Edit-Distanz δ (F1 (v1 , v2 ), T2 ) auch dann nicht berechnet,
wenn die Funktion compute_delta im Zhang-Shasha-Algorithmus für einen anderen
Schlüsselknoten w > v1 aufgerufen wird. Aus diesem Grund geben Jansson und Peng
andere Beziehungen zwischen den Edit-Distanzen an, die die Grundlage zur Lösung
des oben genannten Problems für geschlossene Teilwälder bilden. Der nächste Satz gibt
diese Beziehungen wieder und verwendet folgende Schreibweisen:
Sei T ein Baum oder ein Wald, v ∈ L(T ) und i ∈ V (T ). Schreibe v i, falls v ein Nachfolger
von i in T ist und v i andererseits. Sind alle l(i) in der Vorbereitungsphase berechnet
worden, so kann sofort durch die Bedingung l(i) ≤ v ≤ i festgestellt werden, ob v i ist.
Satz 6.6
Seien T1 und T2 geordnete Bäume, deren Knoten in Postordnung von links nach rechts
durchnummeriert sind. Seien v ∈ L(T1 ), w ∈ K(T2 ), i ∈ {v, . . . , |T1 |} und j ∈ {l(w), . . . , w}.
Dann ergibt sich δ (T1 [v..i], T2 [l(w).. j]) aus dem Minimum der folgenden drei Werte:

δ (T1 [v..i − 1], T2 [l(w).. j]) + γ(T1 [i], −),





δ (T1 [v..i], T2 [l(w).. j − 1]) + γ(−, T2 [ j]),



δ (T [v..i − 1], T [l(w).. j − 1]) + γ(T [i], T [ j]),
falls v i und l(w) j,

1
2
1
2




δ (θ , T2 [l(w)..l( j) − 1]) + δ (T1 [v..i], T2 ( j)),
falls v i und l(w) j,






falls v i und l(w) j,
δ (T1 [v..l(i) − 1], θ ) + δ (T1 (i), T2 ( j)),




δ (T1 [v..l(i) − 1], T2 [l(w)..l( j) − 1]) + δ (T1 (i), T2 ( j)), falls v i und l(w) j.
Beweis:
Betrachte eine optimale Edit-Distanz-Abbildung M zwischen T1 [v..i] und T2 [l(w).. j]. Dann
gibt es für die Knoten i und j in Zusammenhang mit M insgesamt drei Möglichkeiten.
Kapitel 6. Approximative Baumsuche
61
Die ersten zwei Möglichkeiten mit i ∈ R1 und j ∈ R2 entsprechen denen, aus dem Satz
3.4. Für die dritte Möglichkeit mit (i, j) ∈ M sind folgende vier Fälle zu unterscheiden:
(1) v i und l(w) j: Dann ist i die Wurzel einer einfachen Teilstruktur von T1 und
j, wegen l(w) ≤ j ≤ w und l(w) = l( j), die Wurzel eines Teilbaumes T2 ( j) von T2 .
Folglich ist
δ (T1 [v..i], T2 [l(w).. j]) = δ (T1 [v..i − 1], T2 [l(w).. j − 1]) + γ(T1 [i], T2 [ j]).
(2) v i und l(w) j: Dann ist i die Wurzel einer einfachen Teilstruktur von T1
und j, wegen l(w) ≤ j ≤ w und l(w) 6= l( j), die rechteste Wurzel eines Teilwaldes T2 [l(w).. j] von T2 . Folglich ist
δ (T1 [v..i], T2 [l(w).. j]) = δ (θ , T2 [l(w)..l( j) − 1]) + δ (T1 [v..i], T2 ( j)).
(3) v i und l(w) j: Dann ist i die rechteste Wurzel eines Waldes T1 [v..i] und j die
Wurzel eines Teilbaumes T2 ( j) von T2 . Folglich ist
δ (T1 [v..i], T2 [l(w).. j]) = δ (T1 [v..l(i) − 1], θ ) + δ (T1 (i), T2 ( j)).
(4) v i und l(w) j: Dann ist i die rechteste Wurzel eines Waldes T1 [v..i] und j die
rechteste Wurzel eines Teilwaldes T2 [l(w).. j] von T2 . Folglich ist
δ (T1 [v..i], T2 [l(w).. j]) = δ (T1 [v..l(i) − 1], T2 [l(w)..l( j) − 1]) + δ (T1 (i), T2 ( j)).
Um den Algorithmus zu erhalten, der einen zu T2 ähnlichsten geschlossenen Teilwald
von T1 findet, wird die Funktion compute_delta des Zhang-Shasha-Algorithmus 4.2
neu nach der Rekursionsformel des Satzes 6.6 unter Anwendung dynamischer Programmierung konstruiert. Ferner wird in der Vorbereitungsphase die Menge der Blätter
L(T1 ) festgestellt, satt wie bisher im Zhang-Shasha-Algorithmus die Menge der Schlüsselknoten K(T1 ). Die Blätter aus L(T1 ) werden nach ihrer Nummerierung in Postordnung
aufsteigend sortiert und in einem Hilfsfeld gespeichert. Die neu konstruierte Funktion
compute_delta wird jetzt in der Hauptschleife des Algorithmus 6.6 für alle v ∈ L(T1 ),
absteigend nach ihrer Nummerierung, und alle w ∈ K(T2 ), in aufsteigender Ordnung,
aufgerufen. Mit Hilfe des Satzes 6.6 berechnet sie die Werte δ (T1 [v..i], T2 [l(w).. j]) für
alle i ∈ {v, . . . , |T1 |} und j ∈ {l(w), . . . , w}.
Damit in compute_delta alle Terme entsprechend nach Satz 6.6 in O(1) Zeit ausgewertet werden können, werden die Werte δ (T1 [v..i], T2 [l(w).. j]) für alle i ∈ {v, . . . , |T1 |}
und j ∈ {l(w), . . . , w}, sofort nachdem sie mit dynamischer Programmierung berechnet
sind, in einem |T1 | × |T2 |- zweidimensionalen Feld temporär bis zum nächsten Aufruf
von compute_delta gespeichert. Weiterhin werden die Werte δ (T1 (i), T2 ( j)) für alle
i ∈ V (T1 ) und j ∈ V (T2 ) in einem zusätzlichen |T1 | × |T2 |- zweidimensionalen Feld und
δ (T1 [v..i], T2 ( j)) für jedes v ∈ L(T1 ) und alle i ∈ V (T1 ), die die Bedingung v i erfüllen,
in einem weiteren zweidimensionalen Feld der Größe depth(T1 ) · |T2 | während der gesamten Ausführung des Algorithmus permanent gespeichert, da sie nach Satz 6.6 in
folgenden Fällen zur Berechnung von δ (T1 [v..i], T2 [l(w).. j]) gebraucht werden:
62
Approximative Suche in Baumstrukturen
Eingabe : Knoten v ∈ L(T1 ) und w ∈ K(T2 ).
Ausgabe: {δ (T1 [v..i], T2 [l(w).. j]) | i ∈ {v, . . . , |T1 |} und j ∈ {l(w), . . . , w}}.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
for i := v to |T1 | do
δ (T1 [v..i], θ ) := δ (T1 [v..i − 1], θ ) + γ(T1 [i], −).
for j := l(w) to w do
δ (θ , T2 [l(w).. j]) := δ (θ , T2 [l(w).. j − 1]) + γ(−, T2 [ j]).
for i := v to |T1 | do
for j := l(w) to w do
if v i and l(w) j then
d := δ (T1 [v..i − 1], T2 [l(w).. j − 1]) + γ(T1 [i], T2 [ j]).
else if v i and l(w) j then
d := δ (θ , T2 [l(w)..l( j) − 1]) + δ (T1 [v..i], T2 ( j)).
else
/* Hier werden zwei Fälle zusammengefasst für
/* v i
d := δ (T1 [v..l(i) − 1], T2 [l(w)..l( j) − 1]) + δ (T1 (i), T2 ( j)).


δ (T1 [v..i − 1], T2 [l(w).. j]) + γ(T1 [i], −),
δ (T1 [v..i], T2 [l(w).. j]) = min δ (T1 [v..i], T2 [l(w).. j − 1]) + γ(−, T2 [ j]),


d.
*/
*/
Funktion compute_delta(v, w)
(1) δ (T1 (i), T2 ( j)) für v i: Wegen v ≤ i ≤ |T1 | muss i rechts von v liegen und somit
v < l(i) sein. Setze v2 = v und v1 = l(i). Da compute_delta für alle Blätter v in
absteigender Ordnung aufgerufen wird, wurde compute_delta für alle v1 > v2
bereits aufgerufen und somit die Edit-Distanz δ (T1 (i), T2 ( j)) in einem früheren
Lauf berechnet.
(2) δ (T1 [v..i], T2 ( j)) für v i und l(w) j: Wegen l(w) ≤ j ≤ w und l( j) 6= l(w) muss j <
w sein. Also ist j entweder ein Schlüsselknoten, der im Teilbaum T (w) liegt, oder
ein echter Nachfolger eines anderen Schlüsselknotens w1 < w mit l( j) = l(w1 ), der
sich ebenfalls im Teilbaum T1 (w) befindet. In beiden Fällen muss δ (T1 [v..i], T2 ( j))
schon in einem früheren Lauf für einen Schlüsselknoten w1 mit l(w1 ) ≤ j ≤ w1 < w
berechnet worden sein, da compute_delta für alle Schlüsselknoten w in aufsteigender Ordnung aufgerufen wird und dabei δ (T1 [v..i], T2 [l(w).. j]) für alle i ∈
{v, . . . , |T1 |} und j ∈ {l(w), . . . , w} berechnet.
Anschließend wird am Ende des Algorithmus, nachdem die Werte δ (T1 [v..i], T2 [l(w).. j])
für alle v ∈ L(T1 ) und w ∈ K(T2 ) mit i ∈ {v, . . . , |T1 |}, j ∈ {l(w), . . . , w} bestimmt wurden,
min{δ (F1 (v1 , v2 ), T2 ) | v1 und v2 sind Geschwister in T1 } zurückgegeben.
Ist z.B. F1 (x, y) der zu T2 ähnlichster geschlossener Teilwald von T1 , dann wurde
δ (F1 (x, y), T2 ) von dem Algorithmus 6.6 auf jeden Fall berechnet, wie der folgende Beweis zeigt.
Kapitel 6. Approximative Baumsuche
63
Eingabe : Baum T1 und T2 .
Ausgabe: min{δ (F1 (v1 , v2 ), T2 ) | v1 und v2 sind Geschwister in T1 }.
/* ----------------- Vorbereitungsphase ----------------- */
1:
berechne l(), L(T1 )[] und K(T2 )[].
/* ------------------- Hauptschleife -------------------- */
7:
δ (θ , θ ) := 0.
for i := |L(T1 )| to 1 do
for j := 1 to |K(T2 )| do
v := L(T1 )[i],
w := K(T2 )[ j],
call compute_delta(v, w).
8:
return min{δ (F1 (v1 , v2 ), T2 ) | v1 und v2 sind Geschwister in T1 }.
2:
3:
4:
5:
6:
Algorithmus 6.6: Jansson-Peng-Algorithmus zum Finden eines zu T2 ähnlichsten
geschlossenen Teilwaldes von T1
Beweis:
Für F1 (x, y) und T2 gilt:
• F1 (x, y) = T1 [l(x)..y], l(x) ∈ L(T1 ) und y ∈ {l(x), . . . , |T1 |}. Setze v = l(x) und i = y.
• T2 = T2 [l(|T2 |)..|T2 |] und |T2 | ∈ K(T2 ). Setze w = |T2 | und j = |T2 |.
Entsprechend dem Algorithmus 6.6 wird δ (F1 (x, y), T2 ) berechnet. Der Algorithmus 6.6
ist somit korrekt.
Die Funktion compute_delta ist hier der Übersichtlichkeit halber in einer allgemeinen
Form angegeben und kann bezüglich der Speichereffizienz unterschiedlich implementiert werden. Eine mögliche Realisierung in der Programmiersprache Java, wurde von
mir während dieser Arbeit in einem Java-Tool implementiert und kann dort nachvollzogen werden.
Satz 6.7
Gegeben sind zwei geordnete Bäume T1 und T2 . Der Jansson-Peng-Algorithmus 6.6
benötigt zum Finden eines zu T2 ähnlichsten Teilwaldes von T1 O(|T1 | · |T2 | · |L(T1 )| ·
min{depth(T2 ), |L(T2 )|}) Zeiteinheiten und O(|T1 | · |T2 |) Speicherplatz.
Beweis:
Für jedes v ∈ L(T1 ) und w ∈ K(T2 ) ruft der Algorithmus in der Hauptschleife die Funktion compute_delta auf, die die Werte δ (T1 [v..i], T2 [l(w).. j]) für alle i ∈ {v, . . . , |T1 |},
j ∈ {l(w), . . . , w} in einem zweidimensionalen Feld der Größe O(|T1 | · |T2 |) speichert. Diese Werte werden nur temporär gespeichert, so dass der Speicherplatz bei jedem Aufruf
von compute_delta wiederverwendet werden kann. Zusätzlich braucht der Algorithmus für jedes v ∈ L(T1 ), O(depth(T1 ) · |T2 |) Speicherplatz, um die Werte δ (T1 [v..i], T ( j))
für alle i ∈ {v, . . . , |T1 |} mit v i und alle j ∈ V (T2 ) speichern zu können. Dieser Speicher-
64
Approximative Suche in Baumstrukturen
platz kann ebenfalls für jedes v ∈ L(T1 ) wiederverwendet werden. Außerdem werden
die Edit-Distanzen δ (T1 (i), T ( j)) für alle i ∈ V (T1 ) und j ∈ V (T2 ) während der gesamten Ausführung des Algorithmus gespeichert. Insgesamt benötigt der Algorithmus also
O(|T1 | · |T2 |) Speicherplatz.
Da die Funktion compute_delta in der Hauptschleife für alle v ∈ L(T1 ), w ∈ K(T2 )
aufgerufen wird und für eine Ausführung O(|T1 [v..|T1 |]|·|T2 (w)|) Zeit in Anspruch nimmt,
benötigt der Algorithmus für die gesamte Ausführung folgende Zeit:
∑
∑
O(|T1 [v..|T1 |]| · |T2 (w)|) = O(
v∈L(T1 ) w∈K(T2 )
∑
(|T1 | − v) ·
v∈L(T1 )
∑
|T2 |).
(6.3)
w∈K(T2 )
Aus Gleichung (6.3) und Satz 4.5 folgt schließlich:
O(
∑
(|T1 | − v) ·
v∈L(T1 )
∑
w∈K(T2 )
|T2 |) ≤ O(
∑
v∈L(T1 )
|T1 | ·
∑
cdepth(w))
w∈V (T2 )
≤ O(|T1 | · |T2 | · |L(T1 )| · cdepth(T2 )).
(6.4)
Unter Anwendung des Satzes 4.4 ergibt sich aus der Ungleichung 6.4 die Laufzeitkomplexität
O(|T1 | · |T2 | · |L(T1 )| · min{depth(T2 ), |L(T2 )|}).
65
Kapitel 7. Implementierung
7 Implementierung
Zum Experimentieren wurden alle in dieser Arbeit vorgestellten Algorithmen in einem
Java-Tool implementiert. Das implementierte Java-Tool bietet eine grafische Benutzeroberfläche und kann zufällige beschriftete Bäume beliebiger Größe generieren und visualisieren. Die Abbildung 7.1 zeigt einen Screenshot des Java-Tools.
Abbildung 7.1: GUI Java-Tool.
Die zufälligen Bäume werden in der Klasse RandomTreeBuilder erzeugt. Intern
verwendet diese Klasse die von der Java Standard Edition API bereitgestellte Klasse
Random aus dem Paket java.util, um Pseudo-Zufallszahlen zu erzeugen. Die PseudoZufallszahlen werden dazu verwendet, die Größe eines jeden Teilbaumes im zu erzeugenden Baum zufällig festzulegen. Um die Knoten der Bäume mit Symbolen zu beschriften, bedient sich die Klasse RandomTreeBuilder der Klasse AlphabetGenerator,
die ein Alphabet aus einer Datei ausliest und zur Verfügung stellt. Aus diesem Alphabet greift sich ein RandomTreeBuilder Objekt zufällige Zeichen heraus und ordnet
sie verschiedenen Knoten eines Baumes zu. Das Java-Tool kann selbst erstellte Bäume
in Form einer linearen Liste einlesen und die erzeugten Bäume speichern. Um Bäume
intern verwalten zu können, wurde die von der Brown Universität entwickelte Open
Source Bibliothek „Java Data Struktures Library“ (JDSL) verwendet [JDS]. JDSL ist ei-
66
Approximative Suche in Baumstrukturen
ne Sammlung von Schnittstellen und Klassen, die grundlegende Datenstrukturen, wie
Folgen, Bäume, Graphen etc., und darauf basierende Algorithmen implementieren.
Die Abbildung 7.2 zeigt das UML-Klassendiagramm des Java-Tools. Dieses Klassendiagramm stellt nur die wesentlichen Klassen und deren Elemente dar und soll nur einen
allgemeinen Überblick über den Aufbau des Java-Tools ermöglichen. Die einzelnen Algorithmen wurden in folgenden Klassen implementiert:
ZhangShasha: Implementiert den Zhang-Shasha-Algorithmus. Das Objekt der
Klasse wird durch den Konstruktor ZhangShasha(Tree t1, Tree t2,
CostFunction f, int dec) erzeugt. Dabei gibt der formale Parameter
dec die Richtung der Zerlegung an und kann folgende Werte annehmen:
• ZhangShasha.LEFT_DECOMPOSITION = 0
• ZhangShasha.RIGHT_DECOMPOSITION = 1
JiangWangZhang: Implementiert den Jiang-Wang-Zhang-Algorithmus. Das Objekt
der Klasse wird durch den Konstruktor JiangWangZhang(Tree t1, Tree
t2, CostFunction f) erzeugt.
JanssonPeng: Implementiert den Jansson-Peng-Algorithmus für einfache Teilstrukturen, Geschwister-Teilsturkturen und geschlossene Wälder. Das Objekt der
Klasse wird durch den Konstruktor JanssonPeng(Tree t1, Tree t2,
CostFunction f, int variant) erzeugt. Dabei gibt der formale Parameter variant die Art der Teilstruktur an, für die der Algorithmus ausgeführt
werden soll. Hierbei kann variant folgende Werte annehmen:
• JanssonPeng.SIMPLE_SUBSTRUCT = 0
• JanssonPeng.SIBLING_SUBSTRUCT = 1
• JanssonPeng.CLOSED_SUBFOREST = 2
Alle diese Klassen erben von der abstrakten Klasse DistanceAlgorithm und implementieren die abstrakte Methode execute, die die Ausführung des Algorithmus startet.
Außerdem muss bei der Erzeugung eines Objektes dieser Klassen eine Kostenfunktion
festgelegt werden, die den einzelnen Edit-Operationen, abhängig vom gelöschten, eingefügten oder geänderten Symbol eines Knotens, Kosten zuordnet. Eine Kostenfunktion
wird durch die abstrakte Klasse CostFunction repräsentiert. Eine Ausprägung der
CostFunction bildet die Klasse ConstantCostFunction, die im Java-Tool voreingestellt ist und jeder Edit-Operation unabhängig von den Symbolen der Knoten konstante Kosten zuordnet. Diese Kosten können in der GUI verändert werden.
Das implementierte Java-Tool liegt neben den Quelltexten auf der beiliegenden CD als
eine ausführbare Jar-Datei vor und kann damit auf allen Plattformen ausgeführt werden.
67
Kapitel 7. Implementierung
CostFunction
+BLANK: Character = null
+NO_OP_COST: double = 0
#relabelCost(label1: Character, label2: Character): double
#delInsCost(label1: Character, label2: Character): double
+getValue(label1: Character, label2: Character): double
ConstantCostFunction
-_relableCost: double
-_delInsCost: double
+ConstantCostFunction(relabelCost: double, delInsCost: double)
#relabelCost(label1: Character, label2: Character): double
#delInsCost(label1: Character, label2: Character): double
ZhangShasha
-_tree1: Tree
-_tree2: Tree
-_func: CostFunction
+ZhangShasha(t1: Tree1, t2: Tree, f: Costfunction, dec: int)
+execute()
+getDistance(): double
DistanceAlgorithm
#_func: CostFunction
+execute()
+getDistance(): double
+defineCostFunction(f: CostFunction)
JiangWangZhang
-_tree1: Tree
-_tree2: Tree
-_func: CostFunction
+JiangWangZhang(t1: Tree1, t2: Tree, f: Costfunction)
+execute()
+getDistance(): double
JanssonPeng
-_tree1: Tree
-_tree2: Tree
-_func: CostFunction
-_variant: int
+JanssonPeng(t1: Tree1, t2: Tree, f: Costfunction, _variant: int)
+execute()
+getDistance(): double
DrawingWindow
+DrawingWindow(t1: Tree, t2: Tree)
Experiments
+main(args: String)
RandomTreeBuilder
-_tree: Tree
-_alphabet: Sequence
#gen: Random = new Random()
+randomTree(n: int): Tree
#build(p: Position, n: int)
#permute(s: Sequence)
#pickCharacter(): Character
#randomInteger(min: int, max: int): int
AlphabetGenerator
+getCharacters(): Sequence
Abbildung 7.2: UML-Klassendiagramm des Java-Tools.
Kapitel 8. Fazit und Ausblick
69
8 Fazit und Ausblick
In dieser Arbeit habe ich mich mit den Verfahren beschäftigt, die in den verschiedensten Bereichen zum Vergleich von Baumstrukturen mit Hilfe von elementaren EditOperationen eingesetzt werden. Dabei wurden die drei daraus resultierenden zentralen Probleme, Baum-Edit-Distanz, Baum-Alignment-Distanz und das Baum-InklusionProblem genau beschrieben und zueinander in Beziehung gesetzt. Ferner wurden für
die Baum-Edit- und Baum-Alignment-Distanz die grundlegendsten Algorithmen in allen
Einzelheiten detailliert analysiert und miteinander verglichen. Des Weiteren wurde das
approximative Baum-Matching-Problem ausführlich vorgestellt und dessen Anwendungen mit den dazugehörigen Algorithmen erläutert. Weiterhin wurden in dieser Arbeit
die fünf folgenden Algorithmen implementiert und getestet:
• Zhang-Shasha-Algorithmus zur Berechnung der Edit-Distanz zwischen zwei Bäumen, wobei hier sowohl die rechte als auch die linke Zerlegung für den Algorithmus umgesetzt wurden und im Java-Tool ausgewählt werden können.
• Jiang-Wang-Zhang-Algorithmus zur Berechnung der Alignment-Distanz zwischen
zwei Bäumen.
• Jansson-Peng-Algorithmus zum Finden einer ähnlichsten Teilstruktur eines Baumes zu einem anderen Baum für die Varianten, einfache Teilstruktur, GeschwisterTeilstruktur und geschlossener Teilwald.
Alle diese Algorithmen können in dem implementierten Java-Tool für beliebig generierte beschriftete Bäume ausgeführt werden. Der im Abschnitt 4.2 vorgestellte KleinAlgorithmus konnte jedoch am Ende aufgrund von fehlenden zeitlichen Ressourcen in
dieser Arbeit programmiertechnisch nicht mehr umgesetzt werden, da er in der Literatur zwar theoretisch gut beschrieben ist, praktisch aber viele Realisierungen ermöglicht und sich deswegen schwer implementieren lässt. Es muss daher noch anhand von konkreten Anwendungen genau untersucht werden, ob er tatsächlich, wie
theoretisch angegeben, gegenüber dem Zhang-Shasha-Algorithmus in der Praxis Vorteile bietet. Generell wurde außerdem die Beobachtung festgestellt, dass je komplexer
ein Algorithmus aufgebaut ist, er seine theoretisch angegeben Komplexitätsschranken
praktisch nicht halten kann. So wurden die Laufzeiten des Zhang-Shasha- und JiangWang-Zhang-Algorithmus miteinander verglichen. Die theoretisch angegebene Laufzeit O(|T1 | · |T2 | · ((deg(T1 ) + deg(T2 ))2 ) des Jiang-Wang-Zhang-Algorithmus ist gegenüber der Laufzeit O(|T1 | · |T2 | · min{depth(T1 ), L(T1 )} · min{depth(T2 ), L(T2 )}) des ZhangShasha-Algorithmus eindeutig schneller, da stets für alle Bäume T deg(T ) ≤ L(T ) gilt
und laut [JWZ95] in der Praxis, z.B. beim Vergleich von RNA-Sekundärstrukturen,
sogar die Beziehung deg(T ) L(T ) und deg(T ) depth(T ) besteht. Jedoch konnte
beim Testen mit zufällig generierten Bäumen auf dem Computer mit einem Pentium
70
Approximative Suche in Baumstrukturen
M Prozessor (1400 MHz) und 512 MB RAM keine schnellere Laufzeit des Jiang-WangZhang-Algorithmus gegenüber dem Zhang-Shasha-Algorithmus gemessen werden, da
der Jiang-Wang-Zhang-Algorithmus wegen seiner komplexeren Struktur in der Programmiersprache Java mit mehr laufzeitintensiven Elementen implementiert werden
musste als der Zhang-Shasha-Algorithmus. Leider konnte aufgrund mangelnder Zeit am
Ende keine grafische Auswertung dieses Sachverhaltes in dieser Arbeit mehr vorgenommen werden.
Literaturverzeichnis
71
Literaturverzeichnis
[CAM02]
C OBENA, Gregory ; A BITEBOUL, Serge ; M ARIAN, Amelie: Detecting Changes in XML Documents. In: Data Engineering, International Conference on
(2002), S. 0041
[Che98]
C HEN, Weimin: More efficient algorithm for ordered tree inclusion. In: J.
Algorithms 26 (1998), Nr. 2, S. 370–385
[CR94]
C ROCHEMORE, Maxime ; RYTTER, Wojciech: Text Algorithms. Oxford University Press, 1994
[CSRL01] C ORMEN, Thomas H. ; S TEIN, Clifford ; R IVEST, Ronald L. ; L EISERSON,
Charles E.: Introduction to Algorithms. 2. The MIT Press and McGraw-Hill
Book Company, 2001. – ISBN 0262032937
[DT03]
D ULUCQ, Serge ; T ICHIT, Laurent: RNA Secondary structure comparison:
exact analysis of the Zhang–Shasha tree edit algorithm. In: Theor. Comput.
Sci. 306 (2003), Nr. 1-3, S. 471–484
[GT87]
G ONNET, Gaston H. ; T OMPA, Frank W.: Mind your grammar - a new approach to text databases. In: In Proc. VLDB’87, Morgan Haufman Publishers,
1987, S. 339–346
[HT84]
H AREL, Dov ; TARJAN, Robert E.: Fast algorithms for finding nearest common
ancestors. In: SIAM J. Comput. 13 (1984), Nr. 2, S. 338–355
[HTGK03] H ÖCHSMANN, Matthias ; T ÖLLER, Thomas ; G IEGERICH, Robert ; KURTZ, Stefan: Local Similarity in RNA Secondary Structures. In: Computational Systems Bioinformatics Conference, International IEEE Computer Society (2003),
S. 159
[JDS]
The Data Structures Library in Java. http://www.cs.brown.edu/cgc/
jdsl
[JP06]
JANSSON, Jesper ; P ENG, Zeshan: Algorithms for Finding a Most Similar
Subforest. In: CPM, 2006, S. 377–388
[JWZ95]
J IANG, T. ; WANG, J. ; Z HANG, K.: Alignment of Trees - An Alternative to
Tree Edit. In: Theor. Comput. Sci. 143 (1995), Nr. 1, S. 137–148
[Kle98]
K LEIN, Philip N.: Computing the Edit-Distance Between Unrooted Ordered
Trees. In: ESA ’98: Proceedings of the 6th Annual European Symposium on
Algorithms. Springer-Verlag, 1998, S. 91–102
72
Approximative Suche in Baumstrukturen
[KM95]
K ILPELAINEN, Pekka ; M ANNILA, Heikki: Ordered and Unordered Tree Inclusion. In: SIAM J. Comput. 24 (1995), Nr. 2, S. 340–356
[Knu69]
K NUTH, Donald E.: The art of computer programming. Bd. 1. Boston, MA,
USA : Addison-Wesley Longman Publishing Co., 1969
[Par07]
PARCHMANN, Prof. Dr. R.: Skript zur Vorlesung Approximative Zeichenkettensuche. (2007)
[PY88]
PAPADIMITRIOU, Christos ; YANNAKAKIS, Mihalis: Optimization, approximation, and complexity classes. In: STOC ’88: Proceedings of the twentieth annual
ACM symposium on Theory of computing. New York, NY, USA : ACM, 1988,
S. 229–234
[ST81]
S LEATOR, Daniel D. ; TARJAN, Robert E.: A data structure for dynamic trees.
In: STOC ’81: Proceedings of the thirteenth annual ACM symposium on Theory
of computing. New York, NY, USA : ACM, 1981, S. 114–122
[SZ90]
S HAPIRO, B. A. ; Z HANG, K.: Comparing multiple RNA secondary structures using tree comparisons. In: Computer Applications in the Biosciences 6
(1990), S. 309–318
[Tai79]
TAI, Kuo-Chung: The Tree-to-Tree Correction Problem. In: Journal of the
ACM (JACM) 26 (1979), Juli, Nr. 3, S. 422–433. – ISSN 0004–5411
[TSM91]
TAGUE, Jean ; S ALMINEN, Airi ; M C C LELLAN, Charles: Complete formal model for information retrieval systems. In: SIGIR ’91: Proceedings of the 14th
annual international ACM SIGIR conference on Research and development in
information retrieval. New York, NY, USA : ACM, 1991, S. 14–20
[WF74]
WAGNER, Robert A. ; F ISCHER, Michael J.: The String-to-String Correction
Problem. In: Journal of the ACM (JACM) 21 (1974), Januar, Nr. 1, S. 168–
173. – ISSN 0004–5411
[WS81]
WATERMAN, M. S. ; S MITH, T. F.: Identification of common molecular subsequences. In: Journal of Molecular Biology 147 (1981), S. 195–197
[ZJ94]
Z HANG, Kaizhong ; J IANG, Tao: Some MAX SNP-hard results concerning
unordered labeled trees. In: Inf. Process. Lett. 49 (1994), Nr. 5, S. 249–254
[ZS89]
Z HANG, K. ; S HASHA, D.: Simple fast algorithms for the editing distance between trees and related problems. In: SIAM J. Comput. 18 (1989), Dezember,
Nr. 6, S. 1245–1262. – ISSN 0097–5397
[ZSS92]
Z HANG, Kaizhong ; S TATMAN, Rick ; S HASHA, Dennis: On the editing distance between unordered labeled trees. In: Inf. Process. Lett. 42 (1992), Nr. 3,
S. 133–139
73
Abbildungsverzeichnis
Abbildungsverzeichnis
1.1 RNA-Strukturen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6
2.1 Edit-Operationen auf Bäumen. . . . . . . . . . . . . . . . . . . . . . . .
2.2 Baum-Transformation. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14
15
3.1
3.2
3.3
3.4
3.5
.
.
.
.
.
17
22
25
27
28
4.1 Zwei Situationen des Satzes 4.1. . . . . . . . . . . . . . . . . . . . . . .
4.2 Zerlegung eines Baumes in linkeste Pfade. . . . . . . . . . . . . . . . . .
4.3 Zerlegung eines Baumes in schwere Pfade. . . . . . . . . . . . . . . . . .
30
32
40
6.1 Edit-Operationen, Entfernung und Beschneidung von Knoten. . . . . . .
6.2 Teilstrukturen eines Baumes. . . . . . . . . . . . . . . . . . . . . . . . .
49
58
7.1 GUI Java-Tool. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.2 UML-Klassendiagramm des Java-Tools. . . . . . . . . . . . . . . . . . . .
65
67
Edit-Distanz-Abbildung. . . . . . . . . . . . . . . . .
Dritter Fall der Rekursionsformel (4) des Satzes 3.4.
Ausrichtung von Bäumen. . . . . . . . . . . . . . . .
Parsebäume. . . . . . . . . . . . . . . . . . . . . . . .
Beispiel einer Baum-Inklusion. . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Algorithmenverzeichnis
75
Algorithmenverzeichnis
4.1 compute_delta(v, w) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2 Zhang-Shasha-Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . .
4.3 Zhang-Shasha-Algorithmus für Eingaben T1 , T2 mit |L(T1 )| = 1 und
|L(T2 )| = 1. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.1 compute_alpha(vs , vi , wt , w j ) . . . . . . . . . . . . . . . . . . . . . . . . . .
5.2 Jiang-Wang-Zhang-Algorithmus . . . . . . . . . . . . . . . . . . . . . . . .
6.1 compute_Psi(v, w) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.2 compute_Phi(v, w) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.3 Jansson-Peng-Algorithmus zum Finden einer zu T2 ähnlichsten einfachen
Teilstruktur von T1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.4 Jansson-Peng-Algorithmus zum Finden einer zu T2 ähnlichsten
Geschwister-Teilstruktur von T1 . . . . . . . . . . . . . . . . . . . . . . . .
6.5 compute_delta(v, w) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.6 Jansson-Peng-Algorithmus zum Finden eines zu T2 ähnlichsten geschlossenen Teilwaldes von T1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
33
34
37
44
45
52
56
59
60
62
63
Erklärung der Selbstständigkeit
Hiermit versichere ich, dass ich die vorliegende Masterarbeit selbständig und ohne fremde Hilfe verfasst und keine anderen als die in der Arbeit angegebenen Quellen und
Hilfsmittel verwendet habe. Die Arbeit hat in gleicher oder ähnlicher Form noch keinem
anderen Prüfungsamt vorgelegen.
Hannover, den 04. November 2009
Gennadi Mirmov