1 / 150

Datenstrukturen, Algorithmen und Programmierung 2 (DAP2)

Datenstrukturen, Algorithmen und Programmierung 2 (DAP2). Datenstrukturen. Heapsort (A) 1. Build -Heap(A) 2. for i  length [A] downto 2 do 3. A[1]  A[i] 4. heap-size [A]  heap-size [A]-1 5. Heapify (A,1). 3. 2. 6. 5. 4. 1. 1. 11. 3. 2. 7. 10.

arvid
Télécharger la présentation

Datenstrukturen, Algorithmen und Programmierung 2 (DAP2)

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Datenstrukturen, Algorithmen und Programmierung 2 (DAP2)

  2. Datenstrukturen Heapsort(A) 1. Build-Heap(A) 2. fori  length[A] downto 2 do 3. A[1]  A[i] 4. heap-size[A]  heap-size[A]-1 5. Heapify(A,1) 3 2 6 5 4 1 1 11 3 2 7 10 6 5 4 3 4 2

  3. Datenstrukturen Heapsort(A) 1. Build-Heap(A) 2. fori  length[A] downto 2 do 3. A[1]  A[i] 4. heap-size[A]  heap-size[A]-1 5. Heapify(A,1) 3 2 6 5 4 1 1 11 3 2 7 10 6 5 4 3 4 2

  4. Datenstrukturen Heapsort(A) 1. Build-Heap(A) 2. fori  length[A] downto 2 do 3. A[1]  A[i] 4. heap-size[A]  heap-size[A]-1 5. Heapify(A,1) 3 2 6 5 4 1 i 1 11 3 2 7 10 6 5 4 3 4 2

  5. Datenstrukturen Heapsort(A) 1. Build-Heap(A) 2. fori  length[A] downto 2 do 3. A[1]  A[i] 4. heap-size[A]  heap-size[A]-1 5. Heapify(A,1) 3 2 6 5 4 1 i 1 4 3 2 7 10 6 5 4 3 11 2

  6. Datenstrukturen Heapsort(A) 1. Build-Heap(A) 2. fori  length[A] downto 2 do 3. A[1]  A[i] 4. heap-size[A]  heap-size[A]-1 5. Heapify(A,1) 3 2 6 5 4 1 i 1 4 3 2 7 10 5 4 3 2

  7. Datenstrukturen Heapsort(A) 1. Build-Heap(A) 2. fori  length[A] downto 2 do 3. A[1]  A[i] 4. heap-size[A]  heap-size[A]-1 5. Heapify(A,1) 3 2 6 5 4 1 i 1 10 3 2 7 4 5 4 3 2

  8. Datenstrukturen Heapsort(A) 1. Build-Heap(A) 2. fori  length[A] downto 2 do 3. A[1]  A[i] 4. heap-size[A]  heap-size[A]-1 5. Heapify(A,1) 3 2 6 5 4 1 i 1 10 3 2 7 4 5 4 3 2

  9. Datenstrukturen Heapsort(A) 1. Build-Heap(A) 2. fori  length[A] downto 2 do 3. A[1]  A[i] 4. heap-size[A]  heap-size[A]-1 5. Heapify(A,1) 3 2 6 5 4 1 i 1 2 3 2 7 4 5 4 3 10

  10. Datenstrukturen Heapsort(A) 1. Build-Heap(A) 2. fori  length[A] downto 2 do 3. A[1]  A[i] 4. heap-size[A]  heap-size[A]-1 5. Heapify(A,1) 3 2 6 5 4 1 i 1 2 3 2 7 4 4 3

  11. Datenstrukturen Heapsort(A) 1. Build-Heap(A) 2. fori  length[A] downto 2 do 3. A[1]  A[i] 4. heap-size[A]  heap-size[A]-1 5. Heapify(A,1) 3 2 6 5 4 1 i 1 7 3 2 3 4 4 2

  12. Datenstrukturen Heapsort(A) 1. Build-Heap(A) 2. fori  length[A] downto 2 do 3. A[1]  A[i] 4. heap-size[A]  heap-size[A]-1 5. Heapify(A,1) 3 2 6 5 4 1 i 1 7 3 2 3 4 4 2

  13. Datenstrukturen Heapsort(A) 1. Build-Heap(A) 2. fori  length[A] downto 2 do 3. A[1]  A[i] 4. heap-size[A]  heap-size[A]-1 5. Heapify(A,1) 3 2 6 5 4 1 i 1 2 3 2 3 4 4 7

  14. Datenstrukturen Heapsort(A) 1. Build-Heap(A) 2. fori  length[A] downto 2 do 3. A[1]  A[i] 4. heap-size[A]  heap-size[A]-1 5. Heapify(A,1) 3 2 6 5 4 1 i 1 2 3 2 3 4

  15. Datenstrukturen Heapsort(A) 1. Build-Heap(A) 2. fori  length[A] downto 2 do 3. A[1]  A[i] 4. heap-size[A]  heap-size[A]-1 5. Heapify(A,1) 3 2 6 5 4 1 i 1 4 3 2 3 2

  16. Datenstrukturen Heapsort(A) 1. Build-Heap(A) 2. fori  length[A] downto 2 do 3. A[1]  A[i] 4. heap-size[A]  heap-size[A]-1 5. Heapify(A,1) 3 2 6 5 4 1 i 1 4 3 2 3 2

  17. Datenstrukturen Heapsort(A) 1. Build-Heap(A) 2. fori  length[A] downto 2 do 3. A[1]  A[i] 4. heap-size[A]  heap-size[A]-1 5. Heapify(A,1) 3 2 6 5 4 1 i 1 2 3 2 3 4

  18. Datenstrukturen Heapsort(A) 1. Build-Heap(A) 2. fori  length[A] downto 2 do 3. A[1]  A[i] 4. heap-size[A]  heap-size[A]-1 5. Heapify(A,1) 3 2 6 5 4 1 i 1 2 2 3

  19. Datenstrukturen Heapsort(A) 1. Build-Heap(A) 2. fori  length[A] downto 2 do 3. A[1]  A[i] 4. heap-size[A]  heap-size[A]-1 5. Heapify(A,1) 3 2 6 5 4 1 i 1 3 2 2

  20. Datenstrukturen Heapsort(A) 1. Build-Heap(A) 2. fori  length[A] downto 2 do 3. A[1]  A[i] 4. heap-size[A]  heap-size[A]-1 5. Heapify(A,1) 3 2 6 5 4 1 i 1 3 2 2

  21. Datenstrukturen Heapsort(A) 1. Build-Heap(A) 2. fori  length[A] downto 2 do 3. A[1]  A[i] 4. heap-size[A]  heap-size[A]-1 5. Heapify(A,1) 3 2 6 5 4 1 i 1 2 2 3

  22. Datenstrukturen Heapsort(A) 1. Build-Heap(A) 2. fori  length[A] downto 2 do 3. A[1]  A[i] 4. heap-size[A]  heap-size[A]-1 5. Heapify(A,1) 3 2 6 5 4 1 i 1 2

  23. Datenstrukturen Heapsort(A) 1. Build-Heap(A) 2. fori  length[A] downto 2 do 3. A[1]  A[i] 4. heap-size[A]  heap-size[A]-1 5. Heapify(A,1) 3 2 6 5 4 1 i 1 2

  24. Datenstrukturen Heapsort(A) 1. Build-Heap(A) 2. fori  length[A] downto 2 do 3. A[1]  A[i] 4. heap-size[A]  heap-size[A]-1 5. Heapify(A,1) 3 2 6 5 4 1

  25. Datenstrukturen Heapsort(A) 1. Build-Heap(A) 2. fori  length[A] downto 2 do 3. A[1]  A[i] 4. heap-size[A]  heap-size[A]-1 5. Heapify(A,1) Laufzeit • O(n log n) 3 2 6 5 4 1

  26. Datenstrukturen Zusammenfassung (Halden) • Einfügen, Löschen, Maximum extrahieren in O(log n) Zeit • Sortieren mit Hilfe von Halden in O(n log n) • Heapsort braucht keinen zusätzlichen Speicherplatz • Einfache Implementierung

  27. Graphalgorithmen Definition • Ein Graph G ist ein Paar (V,E). V heißt Knotenmenge und EVV Kantenmenge des Graphen. Darstellung von Graphen • Adjazenzlisten (dünne Graphen, |E|<<|V|²) • Adjazenzmatrix (dichte Graphen, |E| nah an |V|²) Arten von Graphen • Ungerichtet, gerichtet • Ungewichtet, gewichtet

  28. Graphalgorithmen Adjazenzmatrixdarstellung • Knoten sind nummeriert von 1 bis |V| • |V||V| Matrix A = (a ) mit • Bei ungerichteten Graphen gilt A = A ij 1, if (i,j)E a = ij 0, sonst T

  29. Graphalgorithmen Beispiel 5 4 3 2 1 1 1 2 2 3 3 4 5 4 5

  30. Graphalgorithmen Adjazenzlistendarstellung • Feld Adj mit |V| Listen (eine pro Knoten) • Für Knoten v enthält Adj[v] eine Liste aller Knoten u mit (v,u)E • Die Knoten in Adj[u] heißen zu u adjazent • Ist G ungerichtet, so gilt: vAdj[u]  uAdj[v] Gewichtete Graphen • Kanten haben Gewicht gegeben durch Funktion w: ER • Gewicht w(u,v) von Kante (u,v) wird mit Knoten v in u‘s Adjazenzliste gespeichert

  31. Graphalgorithmen Beispiel 1 / 5 2 1 2 2 3 4 / 5 1 3 3 4 2 / 5 4 5 / 4 3 2 5 / 2 4 1

  32. Graphalgorithmen Kürzeste Wege in Graphen • Gegeben (möglicherweise gewichteter) Graph G=(V,E) • Frage: Was ist der kürzeste Weg Knoten v nach Knoten u? • Länge des Weges: Summe der Kantengewichte (bzw. Anzahl Kanten, wenn ungewichtet) 10 2 u 3 5 4 2 1 v 12 6 8 5 4 4

  33. Graphalgorithmen Kürzeste Wege in Graphen • Gegeben (möglicherweise gewichteter) Graph G=(V,E) • Frage: Was ist der kürzeste Weg Knoten v nach Knoten u? • Länge des Weges: Summe der Kantengewichte (bzw. Anzahl Kanten, wenn ungewichtet) 10 2 u 3 5 4 2 1 v 12 6 8 5 4 4

  34. Graphalgorithmen Single Source Shortest Path (SSSP) • Startknoten s • Aufgabe: Berechne kürzeste Wege von s zu allen anderen Knoten All Pairs Shortest Path (APSP) • Aufgabe: Berechne kürzeste Wege zwischen allen Knotenpaaren SSSP in ungerichteten Graphen (Breitensuche) • Graph in Adjazenzlistendarstellung • Startknoten s • Nutze Kanten von G, um alle Knoten zu finden, die von s aus erreichbar sind • Finde kürzeste Distanz (Anzahl Kanten) zu jedem anderen Knoten

  35. Graphalgorithmen Invariante (Breitensuche) • Knoten haben 3 Farben: weiß, grau und schwarz • Zu Beginn: Alle Knoten sind weiß • Ein nicht-weißer Knoten heißt „entdeckt“ • Unterscheidung grau-schwarz dient zur Steuerung des Algorithmus • Wenn (u,v)E ist und u ist schwarz, dann sind seine adjazenten Knoten grau oder schwarz • Graue Knoten können adjazente weiße Knoten haben

  36. Graphalgorithmen Beispiel (mögl. Zustand bei einer Breitensuche) s

  37. Graphalgorithmen Breitensuche • Baut Breitensuche Baum (BFS Baum) • Zu Beginn enthält der Baum nur die Wurzel, nämlich s • Wenn weißer Knoten beim Durchsuchen der Adjazenzliste eines entdeckten Knotens entdeckt wird, dann werden v und (u,v) dem Baum hinzugefügt • u ist dann Vaterknoten von v s u

  38. Graphalgorithmen Breitensuche • Baut Breitensuche Baum (BFS Baum) • Zu Beginn enthält der Baum nur die Wurzel, nämlich s • Wenn weißer Knoten beim Durchsuchen der Adjazenzliste eines entdeckten Knotens entdeckt wird, dann werden v und (u,v) dem Baum hinzugefügt • u ist dann Vaterknoten von v Knoten v wird von Knoten u aus entdeckt v s u

  39. Graphalgorithmen Datenstruktur Schlange • Operationen: head, enqueue, dequeue • head: Gibt Referenz auf das erste in der Schlange gespeicherte Element zurück • enqueue: Fügt neues Element ans Ende der Schlage • dequeue: Entfernt Kopf der Schlange Wir verwenden • Doppelt verkettete Liste • Zusätzlich halten wir Zeiger auf das letzte Element aufrecht • Alle Operationen in O(1) Zeit

  40. Graphalgorithmen BFS(G,s) 1. „initialisiere BFS“ 2.while Qdo 3. u  head[Q] 4. for each vAdj[u] do 5. if color[v]=weiß then 6. color[v]  grau 7. d[v]  d[u]+1; p[v]  u 8. enqueue(Q,v) 9. dequeue(Q) 10. color[u]  schwarz

  41. Graphalgorithmen d[u]: Abstand zu s (zu Beginn ) p[u]: Vaterknoten von u (zu Beginn nil) BFS(G,s) 1. „initialisiere BFS“ 2.while Qdo 3. u  head[Q] 4. for each vAdj[u] do 5. if color[v]=weiß then 6. color[v]  grau 7. d[v]  d[u]+1; p[v]  u 8. enqueue(Q,v) 9. dequeue(Q) 10. color[u]  schwarz

  42. Graphalgorithmen • Für jeden Knoten u: • color[u] = weiß • d[u] =  • p[u] = nil BFS(G,s) 1. „initialisiere BFS“ 2.while Qdo 3. u  head[Q] 4. for each vAdj[u] do 5. if color[v]=weiß then 6. color[v]  grau 7. d[v]  d[u]+1; p[v]  u 8. enqueue(Q,v) 9. dequeue(Q) 10. color[u]  schwarz

  43. Graphalgorithmen • Für jeden Knoten u: • color[u] = weiß • d[u] =  • p[u] = nil BFS(G,s) 1. „initialisiere BFS“ 2.while Qdo 3. u  head[Q] 4. for each vAdj[u] do 5. if color[v]=weiß then 6. color[v]  grau 7. d[v]  d[u]+1; p[v]  u 8. enqueue(Q,v) 9. dequeue(Q) 10. color[u]  schwarz • Für Knoten s: • color[s] = grau • d[s]=0 • p[s]=nil • s wird in Schlange Q eingefügt

  44. Graphalgorithmen d a e h BFS(G,s) 1. „initialisiere BFS“ 2.while Qdo 3. u  head[Q] 4. for each vAdj[u] do 5. if color[v]=weiß then 6. color[v]  grau 7. d[v]  d[u]+1; p[v]  u 8. enqueue(Q,v) 9. dequeue(Q) 10. color[u]  schwarz c g s 0 f b i Q: s

  45. Graphalgorithmen d a e h BFS(G,s) 1. „initialisiere BFS“ 2.while Qdo 3. u  head[Q] 4. for each vAdj[u] do 5. if color[v]=weiß then 6. color[v]  grau 7. d[v]  d[u]+1; p[v]  u 8. enqueue(Q,v) 9. dequeue(Q) 10. color[u]  schwarz c g s 0 u f b i Q: s

  46. Graphalgorithmen d v=a e h BFS(G,s) 1. „initialisiere BFS“ 2.while Qdo 3. u  head[Q] 4. for each vAdj[u] do 5. if color[v]=weiß then 6. color[v]  grau 7. d[v]  d[u]+1; p[v]  u 8. enqueue(Q,v) 9. dequeue(Q) 10. color[u]  schwarz c g s 0 u f b i Q: s

  47. Graphalgorithmen d v=a e h BFS(G,s) 1. „initialisiere BFS“ 2.while Qdo 3. u  head[Q] 4. for each vAdj[u] do 5. if color[v]=weiß then 6. color[v]  grau 7. d[v]  d[u]+1; p[v]  u 8. enqueue(Q,v) 9. dequeue(Q) 10. color[u]  schwarz c g s 0 u f b i Q: s

  48. Graphalgorithmen d v=a e h BFS(G,s) 1. „initialisiere BFS“ 2.while Qdo 3. u  head[Q] 4. for each vAdj[u] do 5. if color[v]=weiß then 6. color[v]  grau 7. d[v]  d[u]+1; p[v]  u 8. enqueue(Q,v) 9. dequeue(Q) 10. color[u]  schwarz c g s 0 u f b i Q: s

  49. Graphalgorithmen d v=a e h BFS(G,s) 1. „initialisiere BFS“ 2.while Qdo 3. u  head[Q] 4. for each vAdj[u] do 5. if color[v]=weiß then 6. color[v]  grau 7. d[v]  d[u]+1; p[v]  u 8. enqueue(Q,v) 9. dequeue(Q) 10. color[u]  schwarz 1 c g s 0 u f b i Q: s

  50. Graphalgorithmen d v=a e h BFS(G,s) 1. „initialisiere BFS“ 2.while Qdo 3. u  head[Q] 4. for each vAdj[u] do 5. if color[v]=weiß then 6. color[v]  grau 7. d[v]  d[u]+1; p[v]  u 8. enqueue(Q,v) 9. dequeue(Q) 10. color[u]  schwarz 1 c g s 0 u f b i Q: s, a

More Related