Algorithmen und Datenstrukturen B7. Balancierte B¨aume

Algorithmen und Datenstrukturen

B7. Balancierte B¨ aume ¹

Marcel L¨ uthi and Gabriele R¨ oger

Universit¨ at Basel

10. April 2019

Algorithmen und Datenstrukturen

10. April 2019 — B7. Balancierte B¨ aume

aFolien basieren auf Vorlesungsfolien von Sedgewick & Wayne

https://algs4.cs.princeton.edu/lectures/33BalancedSearchTrees- 2x2.pdf

B7.1 Einf¨ uhrung B7.2 2-3 B¨ aume

B7.3 Rot-Schwarz B¨ aume

B7.1 Einf¨ uhrung

Informatiker des Tages : Donald Knuth

Donald E. Knuth

I Autor: ”The art of computer programming”

I Autor des Textsatzsystems TEX I Gewinner Turing Award (1974) und

vieler anderer Preise I Arbeit an Analyse von

Algorithmen

I Entwickelte erste Sprache f¨ ur

”Literate programming”

Knuth D. The art of computer programming 1: Fundamental algorithms 2: Seminumerical algorithms 3: Sorting and searching.

MA: Addison-Wesley. 1968.

Balancierte B¨ aume

Worst-case Average-case

Implementation suchen einf¨ ugen l¨ oschen suchen (hit) einf¨ ugen l¨ oschen

Verkettete Liste N N N N/2 N N/2

Bin¨ are suche log

(N) N N log

(N) N/2 N

BST N N N log

(N) log

(N) √

N Ziel log

(N) log

(N) log

(N) log

(N) log

(N) log

(N)

Frage

K¨ onnen wir eine Implementation finden, bei der alle Operationen logarithmische

Komplexit¨ at haben?

B7.2 2-3 B¨aume

2-3 B¨ aume

Wir unterscheiden zwei Knotentypen 2-Knoten 1 Schl¨ ussel, zwei Kinder 3-Knoten 2 Schl¨ ussel, drei Kinder I Wir verlangen symmetrische Ordnung

I Zus¨ atzlich muss Baum perfekt balanciert sein.

I Jeder Pfad von Wurzel zu Blatt hat dieselbe L¨ ange.

Einf¨ ugen in 2-3 Baum

Einf¨ ugen in 2-Knoten auf letzter Ebene

I Neuer Schl¨ ussel zu 2-Knoten hinzuf¨ ugen. Knoten wird zu

3-Knoten.

Einf¨ ugen in 2-3 Baum

Einf¨ ugen in 3-Knoten auf letzter Ebene

I Neuer Schl¨ ussel zu 3-Knoten hinzuf¨ ugen. Knoten wird tempor¨ ar zu 4-Knoten.

I Mittlerer Knoten in Parent einf¨ ugen.

I Falls n¨ otig, rekursiv fortsetzen.

I Falls Wurzel erreicht wird, und diese zu 4-Knoten wird, wird

diese zu zwei 2-Knoten.

Lokale Transformationen

I Teilen eines 4 Knotens ist lokale Operation I Unterb¨ aume nicht davon betroffen I Konstante Anzahl Operationen

Quelle: Abb. 3.30, Algorithmen, Wayne & Sedgewick

Globale Eigenschaften

I Invariante: Jede Operation bel¨ asst Baum perfekt balanciert.

I Ordnung der Teilb¨ aume bleibt erhalten.

Quelle: Abb. 3.31, Algorithmen, Wayne & Sedgewick

2-3 Baum: Quiz: Performance

I B¨ aume sind perfekt balanciert!

Baumh¨ ohe:

Worst Case

Best Case

Ubersicht ¨

Worst-case Average-case

Implementation suchen einf¨ ugen l¨ oschen suchen (hit) einf¨ ugen l¨ oschen

Verkettete Liste N N N N/2 N N/2

Bin¨ are suche log

(N) N N log

(N) N/2 N

Bin¨ arer Suchbaum N N N log

(N) log

(N) √

N

2-3 Baum log

(N) log

(N) log

(N) log

(N) log

(N) log

(N)

Problem

2-3 B¨ aume sind m¨ uhsam zu implementieren.

I Wir m¨ ussen viele Spezialf¨ alle unterscheiden.

I Code wird unelegant und fehleranf¨ allig.

I Elegante L¨ osung: Rot-Schwarz B¨ aume

B7.3 Rot-Schwarz B¨aume

Informatiker des Tages : Robert Sedgewick

Robert Sedgewick

I Professor in Princeton

I Doktorand von Donald Knuth.

I ”Erfinder” der Rot-Schwarz B¨ aume I Autor von unserem Lehrbuch.

Guibas, Leo J., and Robert Sedgewick. ”A dichromatic framework

for balanced trees”, IEEE Foundations of Computer Science, 1978.

Rot-Schwarz B¨ aume: Idee

I 2-3 Baum wird als bin¨ arer Suchbaum repr¨ asentiert I 3-Knoten werden mit speziellen ”roten” links markiert.

Quelle: Abb. 3.34, Algorithmen, Wayne & Sedgewick

Quelle: Abb. 3.36, Algorithmen, Wayne & Sedgewick

M. L¨uthi, G. R¨oger (Universit¨at Basel) Algorithmen und Datenstrukturen 10. April 2019 17 / 26

Rot-Schwarz B¨ aume - Definition

Ein Rot-Schwarz Baum ist ein bin¨ arer Suchbaum, mit der Eigenschaft:

I Rote Referenzen zeigen nach links

I Von keinem Knoten gehen zwei rote Referenzen aus I (Keine 4-Knoten im 2-3 Baum)

I Jeder Pfad von der Wurzel zu einem Blatt hat die gleiche Anzahl von schwarzen Referenzen.

I (Gleiche Tiefe im 2-3 Baum)

Repr¨ asentation in Code

I Jeder Knoten hat genau eine Referenz von Parent I 1 Feld in Knoten gen¨ ugt um Farbe speichern

c l a s s N o d e [ Key , V a l u e ]:

N o d e ( key : Key , v a l u e : V a l u e ) key : Key

v a l u e : V a l u e

l e f t : N o d e [ Key , V a l u e ]

r i g h t : N o d e [ Key , V a l u e ]

c o l o r : C o l o r # R e d or B l a c k

Suchen und ordnungsbasierte Operationen

I RB-Tree ist ein bin¨ arer Suchbaum - einfach mit Farbe I Implementation von Suche und ordnungsbasierten

Operationen bleibt gleich.

I Farbe wird ignoriert.

Quelle: Abb. 3.36, Algorithmen, Wayne & Sedgewick

Einf¨ ugen: Idee

Grundidee

Alle Operationen werden auf Operationen in entsprechendem 2-3 Baum zur¨ uckgef¨ uhrt

I Neuer Link wird immer Rot I F¨ uhrt zu potentiellem 4 Knoten

in 2-3 Baum

I Lokale Operationen um 2-3 Baum wiederherzustellen

I Farb wechseln

I Rotation links

I Rotation rechts

Einf¨ ugen: Details

I Unterscheidung aller m¨ oglichen F¨ alle

I Pro Fall: Eigene Strategie um 2-3 Baum wiederherzustellen Am besten in Ruhe selber lesen / anschauen

I Relevante Teile aus dem Buch auf Adam

I Gute, schrittweise Erkl¨ arung mit Ablaufprotokoll I Details nicht pr¨ ufungsrelevant

Animation:

https://algs4.cs.princeton.edu/lectures/

33DemoRedBlackBST.mov

Einf¨ ugen: Implementation

I Tr¨ ugerisch einfache Implementation

def _ p u t ( self , key , value , n o d e ):

if ( n o d e == N o n e ):

r e t u r n R e d B l a c k B S T . N o d e ( key , value , C o l o r . RED , 1) e l i f key < n o d e . key :

n o d e . l e f t = s e l f . _ p u t ( key , value , n o d e . l e f t ) e l i f key > n o d e . key :

n o d e . r i g h t = s e l f . _ p u t ( key , value , n o d e . r i g h t ) e l i f key == n o d e . key :

n o d e . v a l u e = v a l u e

if s e l f . _ i s R e d ( n o d e . r i g h t ) and not s e l f . _ i s R e d ( n o d e . l e f t ):

n o d e = s e l f . _ r o t a t e L e f t ( n o d e )

if s e l f . _ i s R e d ( n o d e . l e f t ) and s e l f . _ i s R e d ( n o d e . l e f t . l e f t ):

n o d e = s e l f . _ r o t a t e R i g h t ( n o d e )

if s e l f . _ i s R e d ( n o d e . l e f t ) and s e l f . _ i s R e d ( n o d e . r i g h t ):

s e l f . _ f l i p C o l o r s ( n o d e )

n o d e . c o u n t = 1 + s e l f . _ s i z e ( n o d e . l e f t ) + s e l f . _ s i z e ( n o d e . r i g h t )

Implementation

Jupyter-Notebook: RedBlackBST.ipynb

Analyse

Theorem

Die H¨ ohe eines Rot-Schwarz-Baums mit N Knoten ist nicht h¨ oher als 2 log ₂ (N) .

Intuition:

I Jeder Pfad von Wurzel zu Blatt hat gleiche Anzahl von Schwarzen Referenzen

I Korrespondenz mit 2-3 Baum

I Es gibt nie zwei rote Referenzen hintereinander.

Ubersicht ¨

Worst-case Average-case

Implementation suchen einf¨ ugen l¨ oschen suchen (hit) einf¨ ugen l¨ oschen

Verkettete Liste N N N N/2 N N/2

Bin¨ are suche log

(N) N N log

(N) N/2 N

Bin¨ arer Suchbaum N N N log

(N) log

(N) √

N Rot-Schwarz Baum log

(N) log

(N) log

(N) log

(N) log

(N) log

(N)

Wir haben logarithmische Komplexit¨ at aller Operationen mit einer kleinen Konstante.