Geometrische Datenstrukturen

1
Geometrische Datenstrukturen

• Haozhe Chen
• Aaron Richardson

2
Range Trees

• 1D Range Tree
• Ein Balance Binärbaum
• Jeder Blatt repräsentiert eine Punkte
• Jeder Innerknoten marken die größte Punkt an
  seinem Linken Teilbaum. Alle Elemente in dem
  rechten Teilbaum sind Größer als die
  Stamminnerknoten.

3
Konstruieren

• Sortieren die Punkte. Fügen die Punkte in die
  Blätter.
• Suchen das Median aus, als die Begrenz teilt die
  Bereich zu 2 Teilen. Linkes Teil speichert im
  Linken Teilbaum, rechtes Teil speichert im
  rechten Teilbaum.
• Speichen die Wert der größten Punkt an dem linken
  Teilbaum in diesem Stamminnerknoten.

4
Komplexität

• Speicherbedarf O(n)
• Konstruierungszeit O(nlogn)
• Laufzeit der Abfrage nach die punkte in einem
  gegebenen Bereich O(klogn)

5
2D Range Tree

• Hauptbaum ist ein mit X Koordinate konstruiertes
  1D Range Tree.
• Zubehöriger Baum ist ein mit Y Koordinate
  konstruiertes 1D Range Tree.
• Jeder Innerknoten repräsentiert einen zubehörigen
  Baum mit gleichen Blättern von seinem Teilbäume.

6
Komplexität

• Queryzeit O((logn)2 k)
• Speicherbedarf O(nlogn)
• Konstruierungszeit O(nlogn)

7
kd-Trees

• Aufgabe Suche nach einer Menge von Punkten
  innerhalb eines Quadrats x, x' y, y', x lt
  x', y lt y'.
• Ein Punkt p (px, py) liegt im Quadrat
• genau dann wenn px ? x, x' und py ? y, y'

8
Algorithm BuildKdTree (P, Depth)

• Input A set of points p and the current depth
  depth
• Output The root of a kd-Tree storing P.
• 1 if P contains only one point
• 2 then return leaf with this point.
• 3 else if depth is even
• 4 then l ist the median x-coordinate in P,
  then split P into two subsets with all points in
  P1 smaller or equal to l in the x-coordinate and
  P2 the set of point with x-coordinate larger than
  l.
• 5 else l ist the median y-coordinate in P,
  then split P into two subsets with all points in
  P1 smaller or equal to l in the y-coordinate and
  P2 the set of point with y-coordinate larger than
  l.
• 6 ?left BuildKDTree(P1, depth 1)
• 7 ?right BuildKDTree(P2, depth 1)
• 8 create node ? storing l, make ?left left child
  of ? and make ?right right child of ?.
• 9 return ?

9
Komplexität BuildKdTree

• So ist die Aufbauzeit von n Punkten (nachdem sie
  nach x oder y einsortiertsind) ist
• T (n) (O(1) ) if n 1.
• O(n) 2T (?n/2?) if n gt 1.
• was am Ende O(n log n) ist. Da auch das Sortieren
  O(n log n) ist, hat man eine Laufzeit von O(n log
  n).

10
Algorithm SearchKDTree (?, R)

• Input root of kd-tree and range Rx,x' x
  y,y'
• Output points at leaves below v that lie in
  range
• 1 if ? is leaf
• 2 then report point stored at ? if it lies in
  R.
• 3 else if region((lc(?)) is fully contained
  in R.
• 4 then ReportSubtree(lc((?)))
• 5 else if region((lc(?)) intersects R.
• 6 then SearchKDTree(lc(?))
• 7 if region((rc(?)) is fully contained in R.
• 8 then ReportSubtree(rc((?)))
• 9 else if region((rc(?)) intersects R.
• 10 then SearchKDTree(rc(?))

11
Kömplexität SearchKDTree

• So ist die Zahl der Nodes, die eine senkrechte
• Gerade treffen, genau
• Q(n) (O(1)) if n 1.
• 2 2T (n/4) if n gt 1.
• oder nach Induktion Q(n) O(vn). Q(vn) gilt auch
  für waagerechte Geraden und allgemein für die
  Grenze eines Quadrats. (Die Grenzen müssen
  parellel mit den Achsen sein.) So ist die
  Komplexität der Abfrage O(vn k).

12
Intervallbäume

• Staat Punkte wollen wir nun Segmente archivieren
  und abfragen. Die Segmente sind hier
  eindimensional. Jedes Node des Baumes hat einen
  Wert xmid. Am jedem Node eines Baume speichern
  wir nur die Intervalle, die sog.
  Mittelintervalle,die den Punkt xmid hat . Alle
  Intervalle links und rechts von xmid werden in
  den Unternodes gespeichert.

13
AlgorthmConstrctIntervalTree

• Input set I of intervals on the real line
• Output root of an internal tree for I
• 1 if I empty set
• 2 then return empty leaf
• 3 else
• 4 create node ?. Compute xmid, the median
  of the set of interval endpoints, and store xmid
  with ?.
• 5 Sort out Imid , Ileft and Iright
  .Constuct two sorted lists for Imid a list
  Lleft(?) sorted on left endpoint and list
  Lright(?) sorted on right endpoint.
• 6 lc(?) ConstructIntervalTree(Lleft)
• 7 rc(?) ConstructIntervalTree(Lright)
• 8 return ?

14
Komplexität ConstrctIntervalTree

• Um die Listen Lleft(?) und Lright(?) zu
  sortieren brauchen wir O(nmid log nmid) in jedem
  Node oder O(n log n) insgesamt.

15
Algorithm QueryIntervalTree (?, R)

• Input root ? of interval tree and query point qx
• Output All intervals that contain qx
• 1 if ? is not a leaf
• 2 then if (qx lt xmid(?)
• 3 then walk along list Lleft(?), starting
  at leftmost endpoint, reporting all the intervals
  that contain qx. Stop as soon intervall does not
  contain qx.
• 4 QueryIntervallTree (lc(?), qx)
• 5 else walk along list Lright(?),
  starting at rightmost endpoint,reporting all the
  intervals that contain qx. Stop as soon
  intervalldoes not contain qx.
• 6 QueryIntervallTree (rc(?), qx)

16
Komplexität QueryIntervalTree

• Ein Query an jedem Node braucht O(1kv) Zeit (kv
  sind die Imid Intervallen am Node ?
  zurückgegeben) und für alle Nodes braucht man
  O(log n k) Zeit.

17
Priorität-Suchbäume

• Wir nehmen wieder an, die Punkte sind
  zweidimensional und haben paarweise verschiedene
  x- und y-Koordinaten. Wir suchen nach allen
  Punkten in einem Range (-8, qx qy, q'y) im
  Baum T.

18
Der Baum wird so gebaut

• wenn P 0 dann der Baum hat ein leeres Blatt
• sonst sei pmin der Punkt in P mit kleinster
  x-Koordinate. Es sei ymid
• Medien von den y-Koordinate. Dann ist
• Pbelow p ? P\pmin py lt ymid
• Pabove p ? P\pmin py gt ymid
• So jeder (Unter)baum hat Node ? und die x- und
  y-Koordinate vom Node sind gespeichert.
• linker Unterbaum von ? is Priorität-Suchbaum von
  Pbelow
• rechter Unterbaum von ? is Priorität-Suchbaum von
  Pabove

19
Algorithm QueryPrioSearchTree (T , (-1, qx
qy, q')

• Input A priority search tree and a range,
  unbounded to the left.
• Output All points lying in the range.
• 1 Search with qy and q'y in T . Let ?split be
  the node where the
• two search paths split.
• 2 for each node ? on the search path of qy or
  q'y
• 3 do if p(?) in (-1, qxxqy, q'ythen report
  p(v)
• 4 for each node ? on the path of qy in the left
  subtree of vsplit
• 5 do if the search path goes left at ?
• 6 then ReportInSubtree(rc(?), qx)
• 7 for each node ? on the path of qy in the right
  subtree of vsplit
• 8 do if the search path goes left at ?
• 9 then ReportInSubtree(rc(?), qx)

20
Algorithm ReportInSubtree (?,qx)

• Input The root ? of a subtree of a priority
  search tree and value qx
• Output All points in the subtree with
  x-coordinate at most qx
• 1 if ? is not leaf and (p(?))x lt qx
• 2 then report P(?))
• 3 ReportInSubtree (lc(?), qx)
• 4 ReportInSubtree (rc(?), qx)

21
Komplexität QueryPrioSearchTree

• Der Algorithmus braucht O(n) Platz (jeder Punkt
  einmal gespeichert) und kann in O(n log n)
  aufgebaut sein.
• Für eine Anfrage brauchen wir O(log n k) Zeit.

22
Segment-Bäume

• Elementares Segment
• Segment-Bäume
• Vollständige Binärbäume
• Jeder Blatt präsentiert ein elementares Segment
• Jeder Innerknoten präsentiert eine Vereingung der
  Blätten an seinen Teilbäumen.

23
Konstruieren

• Sortiere alle Endepunkte
• Bauen einen leeren vollständigen Binärbaum
• Fügen die elementare Segmente ein
• Fügen die Vereinigung der elementaren Segmenten
  an die Innerknoten ein

24
Intervalllist

• Fügen die Knoten in die Intervalllist ein.

25
Intervalllist

• Das Einfügen eines Intervalls ist in O(logN)
  Schritten ausführbar.

26
Komlexität

• Speicherbedarf O(n log n)
• Aufbauzeit O(n log n)

27

• Danke Frage ?