Symbole
- &
- int_set, Wenn man Minimum und Maximum im Voraus kennt (Klasse int_set)
- ()
- random_source, Der ganzzahlige Modus
- string, Tipps zum Gebrauch der Klasse string
- (a,b)-Baum
- niveau-verbundener, Fingersuche und schnelles Einfügen
- +
- date, Datumsangaben (Klasse date)
- string, Weitere Operationen auf Strings
- ++
- date, Datumsangaben (Klasse date)
- +=
- string, Zeichenketten (Klasse string)
- -
- date, Datumsangaben (Klasse date)
- --
- date, Datumsangaben (Klasse date)
- -MDd
- Compileroption, Übersetzen, binden und starten
- -Tp
- Compileroption, Übersetzen, binden und starten
- .gml (Siehe gml-Format)
- .gw (Siehe Standardformat)
- <
- set, Vereinigung, Schnitt und Differenz von Mengen
- =, Einfach strukturierte Typen und deren Kopierkonzept
- (Siehe auch Typen- und Kopierkonzept)
- bei einfach strukturierten Typen, Einfach strukturierte Typen und deren Kopierkonzept
- list, Kopieren von Objekten von item-basiertem Typ
- string, Weitere Operationen auf Strings
- ==, Vergleichen von LEDA-Objekten
- (Siehe auch Gleichheitsprädikat)
- list, Vergleichen von LEDA-Objekten
- string, Zeichenketten (Klasse string)
- >>
- random_source, Der ganzzahlige Modus, Der Bit-Modus
- []
- array, Definieren von Arrays und Zugriff auf Elemente
- d_array, Dictionary-Arrays (Klasse
d_array)
- dictionary, Wörterbücher (Klasse dictionary)
- edge_map, Knoten-Maps und Kanten-Maps
- GRAPH, Die Klasse GRAPH, Graph-Iteratoren
- list, Listen und das Item-Container-Konzept
- map, Maps (Klasse map)
- node_array, Knoten-Arrays und Kanten-Arrays
- node_map, Knoten-Maps und Kanten-Maps
- string, Zeichenketten (Klasse string)
- |
- int_set, Wenn man Minimum und Maximum im Voraus kennt (Klasse int_set)
- ~
- int_set, Wenn man Minimum und Maximum im Voraus kennt (Klasse int_set)
A
- Abhängigkeitsgraph, Wie man anfängt
- Abstand
- zweier Knoten, Ein Anwendungsbeispiel: Breitensuche in einem Graphen
- Acht-Damen-Problem, Übungen
- adj_edges(v), Gerichtete Graphen in LEDA
- adj_pred()
- graph, Die Reihenfolge in in_edges(v) und out_edges(v) beeinflussen
- adj_succ()
- graph, Die Reihenfolge in in_edges(v) und out_edges(v) beeinflussen
- adjazent, Grundlagen, Ungerichtete Graphen in LEDA
- Adjazenzliste, Gerichtete Graphen in LEDA
- Zyklischer Vorgänger und Nachfolger, Face-Zyklen
- AdjIt, Graph-Iteratoren
- Algorithmic Solutions, LEDA erwerben
- ALL_PAIRS_SHORTEST_PATHS(), Laufzeiten und weitere Informationen
- Amortisierte Analyse, Amortisierte Analyse
- Anagramm, Ein Beispiel: Listen von String-Paaren bei der Berechnung von Anagrammen
- Animation
- in GraphWin, Spring Embedding
- animation_steps
- GraphWin, Spring Embedding
- Anti-Symmetrie, Lineare Ordnungen
- Append
- an Schlange, Schlangen
- append()
- list, Anhängen und Entfernen von Elementen am Ende einer Liste
- queue, Schlangen mit unbeschränkter Elementanzahl (Klasse queue)
- apply()
- list, Weitere Operationen, die Listen verändern
- äquivalent (Siehe vergleichs-äquivalent)
- Äquivalenz
- bei linearer Ordnung, Lineare Ordnungen
- Array, Felder
- dynamisches Vergrößern, Dynamisches Vergrößern von Arrays
- Elemente rotieren, Übungen
- Gegensatz zu Liste, Lineare Listen (Klasse list)
- Konstruktor, Definieren von Arrays und Zugriff auf Elemente
- und Mengen, Mengen (Klasse set)
- Verdoppelungsstrategie, Übungen
- von Arrays, Zweidimensionale Felder (Klasse array2)
- zweidimensionales, Zweidimensionale Felder (Klasse array2)
- (Siehe auch array2)
- array2, Zweidimensionale Felder (Klasse array2)
- Konstruktor, Zweidimensionale Felder (Klasse array2)
- Artikulationspunkt, Einfach und zweifach zusammenhängende Graphen
- assign()
- list, Listen und das Item-Container-Konzept
- assignment problem, Matching-Algorithmen
- asymptotisch, Die O-Notation
- Attribut
- eines Items, Listen und das Item-Container-Konzept
- Ausdruck
- arithmetischer
- Auswertung auf Stapel, Stapel mit unbeschränkter Elementanzahl (Klasse stack)
- unvollständig geklammerter, Übungen
- vollständig geklammerter, Übungen
- Ausgangsgrad, Grundlagen
- Ausnahme, Fehlerbehandlung
- Automat
- zellulärer, Zweidimensionale Felder (Klasse array2)
- Automatische Bereichsüberprüfung (Siehe range checking)
B
- b_node_pq, Spezielle Hilfsdatenstrukturen für Graphenalgorithmen
- b_pq_item, Prioritäts-Warteschlangen mit beschränkten, ganzzahligen Prioritäten
(Klasse b_priority_queue)
- b_priority_queue, Prioritäts-Warteschlangen, Prioritäts-Warteschlangen mit beschränkten, ganzzahligen Prioritäten
(Klasse b_priority_queue)
- b_queue, Schlangen, Schlangen mit beschränkter Elementanzahl (Klasse b_queue)
- Konstruktor, Schlangen mit beschränkter Elementanzahl (Klasse b_queue)
- b_stack, Stapel, Stapel mit beschränkter Elementanzahl (Klasse b_stack)
- Konstruktor, Stapel mit beschränkter Elementanzahl (Klasse b_stack)
- back()
- list, Listen verändern und in Listen suchen
- Bag
- Implementierung durch assoziativen Containertyp, array, list,
stack, queue, set und d_int_set im
Vergleich
- basic_graph_alg.h, Ein erstes Programm, Grundlegende Graphenalgorithmen
- Baum
- aufspannender, Minimale aufspannende Bäume
- minimaler, Minimale aufspannende Bäume
- Darstellung durch graph, Übungen
- niveauverbundener, Fingersuche und schnelles Einfügen
- Unterschied zu Graph, Übungen
- Belegungsfaktor, Hashing mit Verkettung und Tafelverdoppelung
- Benutzer-Koordinatensystem
- Position von Objekten erfragen und setzen, Spring Embedding
- Bereichsüberprüfung
- automatische, Der ganzzahlige Modus
- Bernoulli-Wahrscheinlichkeit, Der Bit-Modus
- BFS(), Die Klasse GRAPH
- BICONNECTED_COMPONENTS(), Laufzeiten und weitere Informationen
- Binärsuche, Nützliche Methoden der Klasse array, Übungen
- binary_locate()
- array, Nützliche Methoden der Klasse array
- binary_search()
- array, Nützliche Methoden der Klasse array
- Binomialkoeffizient, Dynamisches Vergrößern von Arrays
- Binomialverteilung, Der Bit-Modus, Schlangen mit unbeschränkter Elementanzahl (Klasse queue)
- Blatt, Übungen
- border_color
- GraphWin, Attribute von GraphWin
- border_width
- GraphWin, Attribute von GraphWin
- Boxverein
- Paarungen erzeugen, Übungen
- breadth first search (Siehe Breitensuche)
- Breitensuche, Ein Anwendungsbeispiel: Breitensuche in einem Graphen, Algorithmen für kürzeste Wege
- mit BFS(), Die Klasse GRAPH
- bucket_sort()
- list, Listen sortieren
- bucket_sort_nodes()
- graph, Iterieren über alle Knoten und Kanten
C
- change_inf()
- dictionary, Wörterbücher (Klasse dictionary)
- p_queue, Prioritäts-Warteschlangen mit unbeschränkten Prioritäten (Klasse p_queue)
- sortseq, Grundfunktionalität
- choose()
- set, Elemente einfügen und Test auf Enthaltensein
-
Christian
Uhrig
, Was wir nicht beschrieben haben
- clear()
- d_array, Dictionary-Arrays (Klasse
d_array)
- int_set, Wenn man Minimum und Maximum im Voraus kennt (Klasse int_set)
- map, Maps (Klasse map)
- queue, Schlangen mit unbeschränkter Elementanzahl (Klasse queue)
- set, Vereinigung, Schnitt und Differenz von Mengen
- stack, Stapel mit unbeschränkter Elementanzahl (Klasse stack)
- color
- GraphWin, Attribute von GraphWin
- compare(), Listen sortieren, Paare, Tripel und Quadrupel (Klassen two_tuple, three_tuple, four_tuple)
- anhand von Polarkoordinaten, Übungen
- mehrere lineare Ordnungen auf einem Typ definieren, Mehrere lineare Ordnungen auf einem Typ
- und lineare Ordnung, Linear geordnete Typen
- und Namensraum leda, Einen eigenen Typ linear geordnet machen
- complete_graph()
- graph, Graph-Generatoren
- Completion-Nummer, Ein Beispiel: Visualisierung von DFS_NUM()
- COMPONENTS(), Starke Zusammenhangskomponenten
- compute_faces()
- graph, Face-Zyklen
- conc()
- list, Weitere Operationen, die Listen verändern
- sortseq, Aufspalten, aneinanderhängen und zusammenmischen
- Container
- assoziativer
- Anforderungen an Schlüsseltyp, Reihenfolge der Paare in einem assoziativen Container und Anforderungen an den Schlüsseltyp
- und Items, Listen und das Item-Container-Konzept
- Containertyp, Definieren von Arrays und Zugriff auf Elemente, Listen füllen und leeren
- assoziativer, Assoziative Containertypen
- Reihenfolge der Elemente, Reihenfolge der Paare in einem assoziativen Container und Anforderungen an den Schlüsseltyp
- Vergleich der Typen von LEDA, dictionary, d_array, h_array, map und sortseq im Vergleich
- einfacher, Einfache Datentypen und einfache Containertypen
- Vergleich der Typen von LEDA, array, list,
stack, queue, set und d_int_set im
Vergleich
- contents()
- list, Listen und das Item-Container-Konzept
- Conways Spiel des Lebens, Zweidimensionale Felder (Klasse array2)
- CopyGraph(), Graphen kopieren
- core module, Die Struktur der Include-Verzeichnisse ab LEDA 5.0
- cut (Siehe Schnitt)
- cut edge (Siehe Schnittkante)
- cut vertex (Siehe Artikulationspunkt)
- cyclic_adj_pred()
- graph, Die Reihenfolge in in_edges(v) und out_edges(v) beeinflussen, Face-Zyklen
- cyclic_adj_succ()
- graph, Die Reihenfolge in in_edges(v) und out_edges(v) beeinflussen, Face-Zyklen
- cyclic_pred()
- list, Listen und das Item-Container-Konzept
- cyclic_succ()
- list, Listen und das Item-Container-Konzept
D
- d_array, Dictionary-Arrays (Klasse
d_array)
- Konstruktor und Default-Wert, Dictionary-Arrays (Klasse
d_array)
- d_int_set, Mengen von ganzen Zahlen, Wenn Minimum oder Maximum unbekannt sind (Klasse d_int_set)
- Konstruktor, Wenn Minimum oder Maximum unbekannt sind (Klasse d_int_set)
- Data-Label, Lesen aus einer Datei und Schreiben in eine Datei
- date, Datumsangaben (Klasse date)
- Konstruktor, Datumsangaben (Klasse date)
- Datei
- Informationen erhalten über, Mit Verzeichnissen und Dateien umgehen
- Datentyp
- abstrakter, Implementierungsparameter
- einfacher, Einfache Datentypen und einfache Containertypen
- Datumsangabe (Siehe date)
- decrease_inf()
- b_priority_queue, Prioritäts-Warteschlangen mit beschränkten, ganzzahligen Prioritäten
(Klasse b_priority_queue)
- decrease_p()
- p_queue, Prioritäts-Warteschlangen mit unbeschränkten Prioritäten (Klasse p_queue)
- Default-Initialisierung, Zeichenketten (Klasse string)
- Default-Ordnung, Ein Beispiel: Listen von String-Paaren bei der Berechnung von Anagrammen, Linear geordnete Typen
- DEFINE_LINEAR_ORDER, Mehrere lineare Ordnungen auf einem Typ
- defined()
- d_array, Dictionary-Arrays (Klasse
d_array)
- map, Maps (Klasse map)
- degree (Siehe Grad)
- degree()
- graph, Ein Beispiel
- del()
- dictionary, Wörterbücher (Klasse dictionary)
- int_set, Wenn man Minimum und Maximum im Voraus kennt (Klasse int_set)
- set, Elemente einfügen und Test auf Enthaltensein
- string, Weitere Operationen auf Strings
- del_edge()
- graph, Ein erstes Programm
- del_item()
- list, Listen verändern und in Listen suchen
- p_queue, Prioritäts-Warteschlangen mit unbeschränkten Prioritäten (Klasse p_queue)
- del_message()
- GraphWin, Die Programmierschnittstelle der Klasse GraphWin
- del_min()
- p_queue, Prioritäts-Warteschlangen mit unbeschränkten Prioritäten (Klasse p_queue)
- del_node()
- graph, Ein erstes Programm
- delete, Effiziente Speicherverwaltung für eigene Typen
- Delete_Loops(), Weitere Funktionen
- dependency graph (Siehe Abhängigkeitsgraph)
- depth first search (Siehe Tiefensuche)
- DFS(), Algorithmen zum systematischen Durchsuchen
- DFS-Nummer, Ein Beispiel: Visualisierung von DFS_NUM()
- DFS_NUM(), Ein Beispiel: Visualisierung von DFS_NUM()
- dic_item, Wörterbücher (Klasse dictionary)
- dictionary, Wörterbücher (Klasse dictionary)
- dictionary array (Siehe Wörterbuch-Array)
- diff()
- set, Vereinigung, Schnitt und Differenz von Mengen
- Differenz
- symmetrische, Vereinigung, Schnitt und Differenz von Mengen
- von Mengen, Vereinigung, Schnitt und Differenz von Mengen
- direction
- GraphWin, Attribute von GraphWin
- Diskrete Ereignissimulation, Prioritäts-Warteschlangen
- display()
- GraphWin, Die Programmierschnittstelle der Klasse GraphWin
- Distanz
- zweier Knoten, Algorithmen für kürzeste Wege
- dynamic_markov_chain, Die Klasse dynamic_markov_chain
- dynamic_random_variate, Zufallsvariablen, Dynamische Zufallsvariablen (Klasse dynamic_random_variate)
- Konstruktor, Dynamische Zufallsvariablen (Klasse dynamic_random_variate)
- dynamic_trees, Was wir nicht beschrieben haben
E
- edge, Ein Anwendungsbeispiel: Breitensuche in einem Graphen, Grundlagen
- (Siehe auch Kante)
- edge, Ein erstes Programm
- edge_array, Ein erstes Programm, Knoten-Arrays und Kanten-Arrays
- Konstruktor mit Angabe der maximalen Knotenanzahl, Knoten-Arrays und Kanten-Arrays
- edge_map, Knoten-Maps und Kanten-Maps
- statt map<edge,V>, Anwendungsfälle für map
- edge_set, Spezielle Hilfsdatenstrukturen für Graphenalgorithmen
- EdgeIt, Graph-Iteratoren
- edit()
- GraphWin, Die Programmierschnittstelle der Klasse GraphWin
- Edit-and-Run-Schema, Die Programmierschnittstelle der Klasse GraphWin
- Einbettung
- ordnungserhaltende, Ordnungserhaltende Einbettungen
- planare, Planare Einbettungen, Spring Embedding
- Straight Line, Straight Line Embedding
- Tutte, Übungen
- vs. Zeichnung, Spring Embedding
- Eingangsgrad, Grundlagen
- Element
- einer Liste, Listen und das Item-Container-Konzept
- eines Containertyps, Definieren von Arrays und Zugriff auf Elemente
- empty()
- list, Listen füllen und leeren
- queue, Schlangen mit unbeschränkter Elementanzahl (Klasse queue)
- set, Vereinigung, Schnitt und Differenz von Mengen
- stack, Stapel mit unbeschränkter Elementanzahl (Klasse stack)
- Error-Handler, Fehlerbehandlung
- Euler-Tour, Übungen, Übungen
F
- f(n)=O(g(n))), Die O-Notation
- Face, Face-Zyklen
- äußeres, Faces und Face-Zyklen
- und umgebender Face-Zyklus, Faces und Face-Zyklen
- Face-Zyklus, Face-Zyklen
- Face-Zyklus-Nachfolger, Face-Zyklen
- Face-Zyklus-Vorgänger, Face-Zyklen
- face_array, Die Klassen face_array und face_map
- face_cycle_pred()
- graph, Face-Zyklen
- face_cycle_succ()
- graph, Face-Zyklen
- face_map, Die Klassen face_array und face_map
- Färbungsproblem, Färbungsprobleme und duale Graphen
- Fehlerbehandlung, Fehlerbehandlung
- Feld (Siehe Array)
- Fibonacci-Heap
- bei der Implementierung von Prioritäts-Warteschlangen, Prioritäts-Warteschlangen mit unbeschränkten Prioritäten (Klasse p_queue)
- FIFO-Prinzip, Schlangen, Prioritäts-Warteschlangen
- (Siehe auch Schlange)
- file.h, Mit Verzeichnissen und Dateien umgehen
- file_istream, Was wir nicht beschrieben haben
- file_ostream, Was wir nicht beschrieben haben
- find_min()
- p_queue, Prioritäts-Warteschlangen mit unbeschränkten Prioritäten (Klasse p_queue)
- Finger, Fingersuche und schnelles Einfügen
- finger_locate()
- sortseq, Fingersuche und schnelles Einfügen
- finger_locate_from_front()
- sortseq, Fingersuche und schnelles Einfügen
- finger_locate_from_rear()
- sortseq, Fingersuche und schnelles Einfügen
- Fingersuche, Fingersuche und schnelles Einfügen
- first()
- list, Listen und das Item-Container-Konzept
- two_tuple, Paare, Tripel und Quadrupel (Klassen two_tuple, three_tuple, four_tuple)
- first-in-first-out (Siehe FIFO-Prinzip)
- FIVE_COLOR(), Färbungsprobleme und duale Graphen
- flow (Siehe Fluss)
- Fluss, Maximale Flüsse
- maximaler, Maximale Flüsse
- maximaler mit minimalen Kosten, Maximale Flüsse mit minimalen Kosten
- Flusserhaltung, Maximale Flüsse
- forall
- Realisierung durch Makro-Expansion, Ein genauerer Blick auf die forall-Makros
- über d_array, Iteration und Iterationsreihenfolge
- über list, Iterieren mit den forall-Makros
- über set, Elemente einfügen und Test auf Enthaltensein
- forall_adj_edges
- auf graph, Iterieren über die zu einem Knoten adjazenten Kanten und Knoten
- forall_adj_nodes
- auf graph, Iterieren über die zu einem Knoten adjazenten Kanten und Knoten
- forall_defined
- über d_array, Iteration und Iterationsreihenfolge
- forall_edges
- auf graph, Ein erstes Programm, Iterieren über alle Knoten und Kanten
- forall_face_edges
- auf graph, Face-Zyklen
- forall_faces
- auf graph, Face-Zyklen
- forall_in_edges
- auf graph, Iterieren über die zu einem Knoten adjazenten Kanten und Knoten
- forall_inout_edges
- auf graph, Iterieren über die zu einem Knoten adjazenten Kanten und Knoten
- forall_items
- Realisierung durch Makro-Expansion, Ein genauerer Blick auf die forall-Makros
- über dictionary, Wörterbücher (Klasse dictionary)
- über list, Listen und das Item-Container-Konzept
- forall_nodes
- auf graph, Ein erstes Programm, Iterieren über alle Knoten und Kanten
- forall_out_edges
- auf graph, Iterieren über die zu einem Knoten adjazenten Kanten und Knoten
- forall_rev
- über list, Iterieren mit den forall-Makros
- forall_rev_edges
- auf graph, Iterieren über alle Knoten und Kanten
- forall_rev_items
- über list, Listen und das Item-Container-Konzept
- forall_rev_nodes
- auf graph, Iterieren über alle Knoten und Kanten
- forest (Siehe Wald)
- four_tuple, Paare, Tripel und Quadrupel (Klassen two_tuple, three_tuple, four_tuple)
- fourth()
- four_tuple, Paare, Tripel und Quadrupel (Klassen two_tuple, three_tuple, four_tuple)
- front()
- list, Listen verändern und in Listen suchen
- Fünf-Farben-Satz, Färbungsprobleme und duale Graphen
- Fünffärbung, Färbungsprobleme und duale Graphen
G
- Galton-Brett, Der Bit-Modus
- Gebiet, Landkarten und Gebiete im täglichen Leben
- äußeres, Landkarten und Gebiete im täglichen Leben
- Gegenkante, Bidirektionale Graphen
- generate()
- random_variate, Statische Zufallsvariablen (Klasse random_variate)
- Geordnete Folge (Siehe sortseq)
- get_day()
- date, Datumsangaben (Klasse date)
- get_day_of_week()
- date, Datumsangaben (Klasse date)
- get_directories(), Mit Verzeichnissen und Dateien umgehen
- get_files, Mit Verzeichnissen und Dateien umgehen
- get_msg()
- leda_exception, Fehlerbehandlung
- get_num()
- leda_exception, Fehlerbehandlung
- get_position()
- GraphWin, Spring Embedding
- get_selected_nodes()
- GraphWin, Algorithmen für kürzeste Wege
- get_xmax()
- GraphWin, Spring Embedding
- get_xmin()
- GraphWin, Spring Embedding
- get_ymax()
- GraphWin, Spring Embedding
- get_ymin()
- GraphWin, Spring Embedding
- Gewicht
- einer Zufallsvariablen, Statische Zufallsvariablen (Klasse random_variate)
- gleich (Siehe Gleichheit von Objekten)
- Gleichheit von Objekten, Vergleichen von LEDA-Objekten, Hashing in LEDA
- Gleichheitsprädikat
- und LEDA-Objekte, Vergleichen von LEDA-Objekten
- gml-Format, Das gml-Format
- Grad, Grundlagen
- Grammatik
- kontextfreie, Übungen
- Graph, Ein Anwendungsbeispiel: Breitensuche in einem Graphen, Grundlagen
- (Siehe auch graph)
- (Siehe auch GRAPH)
- Abhängigkeits-, Wie man anfängt
- Algorithmen zum Zeichnen, Algorithmen zum Zeichnen von Graphen
- azyklischer, Weitere Funktionen
- bidirektionaler, Bidirektionale Graphen
- bipartiter, Planare Einbettungen, Weitere Funktionen
- dualer, Färbungsprobleme und duale Graphen
- dynamischer, Die Klasse GRAPH
- einfach zusammenhängender, Einfach und zweifach zusammenhängende Graphen
- einfacher, Weitere Funktionen
- eingebetteter, Planare Einbettungen
- genetischer, Ein selbstgeschriebener Graphenalgorithmus
- gerichtete Version eines ungerichteten, Grundlagen
- gerichteter, Grundlagen
- gerichteter vs. ungerichteter in LEDA, Gerichtete und ungerichtete Graphen
- Informationen assoziieren, Graphen und assoziierte Informationen, Knoten-Arrays und Kanten-Arrays
- Vergleich der Möglichkeiten, Ein Vergleich der Möglichkeiten
- Kuratowski-, Planare Einbettungen
- parametrisierter, Die Klasse GRAPH
- Pfad finden, der jede Kante einmal in beiden Richtungen durchläuft, Übungen
- planar eingebetteter, Ordnungserhaltende Einbettungen
- planarer, Übungen, Planare Einbettungen
- Algorithmen für, Algorithmen für planare Graphen
- regulärer vom Grad r, Übungen
- stark zusammenhängender, Grundlagen, Starke Zusammenhangskomponenten
- statischer, Statische Graphen
- ungerichtete Version eines gerichteten, Grundlagen
- ungerichteter, Grundlagen
- Unterschied zu Baum, Übungen
- Unterteilung, Planare Einbettungen
- vollständiger, Graph-Generatoren
- zusammenhängender, Grundlagen
- zweifach zusammenhängender, Einfach und zweifach zusammenhängende Graphen
- zyklischer, Grundlagen
- graph, Ein erstes Programm
- bidirektional, Ungerichtete Graphen in LEDA
- Eingabe mit GraphWin, Interaktive Eingabe mit dem Editor GraphWin
- generieren mit Graph-Generator, Graph-Generatoren
- gerichtet, Gerichtete Graphen in LEDA
- gerichtet vs. ungerichtet, Der wahre Unterschied zwischen gerichteten und ungerichteten Graphen in LEDA
- isomorphe Kopie anlegen, Graphen kopieren
- iterieren über Knoten und Kanten, Über Knoten und Kanten iterieren und in Graphen
navigieren
- Kanten zwischenzeitlich verbergen, Kanten zwischenzeitlich verbergen
- Konstruktor mit Angabe der Slotanzahl, Knoten-Arrays und Kanten-Arrays, Knoten-Maps und Kanten-Maps
- lesen aus und schreiben in Datei, Lesen aus einer Datei und Schreiben in eine Datei
- navigieren in, Navigieren
- Reihenfolge der Kanten in den Adjazenzlisten beeinflussen, Die Reihenfolge in in_edges(v) und out_edges(v) beeinflussen
- Selbstschleifen entfernen, Weitere Funktionen
- speichern im Standardformat (Siehe Standardformat)
- über Knoten und Kanten iterieren, Iterieren über alle Knoten und Kanten
- ungerichtet, Ungerichtete Graphen in LEDA
- GRAPH, Die Klasse GRAPH
- Graph-Generator, Graph-Generatoren
- Graph-Iterator, Graph-Iteratoren
- graph_draw.h, Algorithmen zum Zeichnen von Graphen
- graph_gen.h, Graph-Generatoren
- graph_iterator.h, Graph-Iteratoren
- graph_misc.h, Übungen, Algorithmen für grundlegende Eigenschaften
- Graphenalgorithmus
- selbst schreiben, Ein selbstgeschriebener Graphenalgorithmus
- vorgefertigter, Vorgefertigte Graphenalgorithmen
- GraphWin, Interaktive Eingabe mit dem Editor GraphWin
- Animationen, Spring Embedding
- Bedienung der Benutzeroberfläche, Interaktive Eingabe mit dem Editor GraphWin
- Edit-and-Run-Schema, Die Programmierschnittstelle der Klasse GraphWin
- Knoten- und Kantenattribute, Attribute von GraphWin
- Position von Knoten und Kanten explizit angeben, Spring Embedding
- Programmierschnittstelle, Die Programmierschnittstelle der Klasse GraphWin
- Größenordnung
- eines Verfahrens, Die O-Notation
H
- h_array, Hashing in LEDA, Hashing-Arrays (Klasse h_array)
- Default-Wert und Konstruktor, Hashing-Arrays (Klasse h_array)
- initiale Tafelgröße festlegen, Hashing-Arrays (Klasse h_array)
- Hallo Welt!, Hallo LEDA-Welt! - Das erste Programm
- Handle-Schema, Handle-Typen und handle-ähnliche Typen
- Handle-Technik, Schlangen mit unbeschränkter Elementanzahl (Klasse queue)
- Handle-Typ, Handle-Typen und handle-ähnliche Typen
- Handshaking-Lemma, Übungen
- Hash, Die Grundidee von Hashing
- Iterationsreihenfolge, Iterationsreihenfolge
- Hash(), Hashing in LEDA
- Hash-Funktion, Die Grundidee von Hashing
- gute und schlechte, Gute und schlechte Hash-Funktionen
- Hash-Tabelle (Siehe Hash)
- Hash-Tafel (Siehe Hash)
- Hash-Wert, Hashende Typen
- Hashing, Hashende Typen
- bei Knoten- und Kanten-Maps, Knoten-Maps und Kanten-Maps
- beliebige Informationen speichern, Zahlen und andere Schlüssel
- einstufige und zweistufige Verfahren, Hashing in LEDA
- mit Verkettung, Hashing mit Verkettung und Tafelverdoppelung
- Tafelverdoppelung, Hashing in LEDA
- Hashing-Array (Siehe h_array)
- head (Siehe Kopf)
- head()
- list, Anhängen und Entfernen von Elementen am Ende einer Liste
- string, Weitere Operationen auf Strings
- Header-Datei, Die Header-Dateien von LEDA
- Header-Dateien
- die alte Include-Struktur mit einer LEDA Version >= 5.0 benutzen, Die Struktur der Include-Verzeichnisse ab LEDA 5.0
- height
- GraphWin, Attribute von GraphWin
- Heiratsproblem, Matching-Algorithmen
- Heiratsvermittlung, Vereinigung, Schnitt und Differenz von Mengen
- Hewlett-Packard (Siehe Taschenrechner mit UPN)
- hidden_edges()
- graph, Kanten zwischenzeitlich verbergen
- hide_edge()
- graph, Kanten zwischenzeitlich verbergen
- high()
- array, Nützliche Methoden der Klasse array
- high1()
- array2, Zweidimensionale Felder (Klasse array2)
- high2()
- array2, Zweidimensionale Felder (Klasse array2)
- Huffman-Kodierung, Ein Anwendungsbeispiel: Huffman-Kodierung
I
- identical(), Vergleichen von LEDA-Objekten
- identisch (Siehe Identität von Objekten)
- Identität von Objekten, Vergleichen von LEDA-Objekten
- Identitäts-Prädikat (Siehe identical())
- Implementierung
- konkrete eines abstrakten Datentyps, Implementierungsparameter
- Implementierungsparameter, Implementierungsparameter
- in-degree (Siehe Eingangsgrad)
- in_edges(v), Gerichtete Graphen in LEDA
- InAdjIt, Graph-Iteratoren
- indeg()
- graph, Ein Beispiel
- inf()
- b_priority_queue, Prioritäts-Warteschlangen mit beschränkten, ganzzahligen Prioritäten
(Klasse b_priority_queue)
- dictionary, Wörterbücher (Klasse dictionary)
- graph, Die Klasse GRAPH
- p_queue, Prioritäts-Warteschlangen mit unbeschränkten Prioritäten (Klasse p_queue)
- sortseq, Grundfunktionalität
- Infix-Notation, Stapel mit unbeschränkter Elementanzahl (Klasse stack)
- init()
- AdjIt, Graph-Iteratoren
- array, Nützliche Methoden der Klasse array
- InAdjIt, Graph-Iteratoren
- NodeIt, Graph-Iteratoren
- OutAdjIt, Graph-Iteratoren
- window, Spring Embedding
- insert()
- b_priority_queue, Prioritäts-Warteschlangen mit beschränkten, ganzzahligen Prioritäten
(Klasse b_priority_queue)
- dictionary, Wörterbücher (Klasse dictionary)
- int_set, Wenn man Minimum und Maximum im Voraus kennt (Klasse int_set)
- list, Listen und das Item-Container-Konzept
- p_dictionary, Persistente Wörterbücher
- p_queue, Prioritäts-Warteschlangen mit unbeschränkten Prioritäten (Klasse p_queue)
- set, Elemente einfügen und Test auf Enthaltensein
- sortseq, Grundfunktionalität
- string, Weitere Operationen auf Strings
- insert_at()
- sortseq, Schnelles Einfügen
- int_set, Mengen von ganzen Zahlen
- Konstruktor, Wenn man Minimum und Maximum im Voraus kennt (Klasse int_set)
- intersect()
- set, Vereinigung, Schnitt und Differenz von Mengen
- Invariante, Definieren von Arrays und Zugriff auf Elemente
- IP-Adresse, Elemente einfügen und Test auf Enthaltensein
- Is_Acyclic(), Weitere Funktionen
- Is_Biconnected(), Einfach und zweifach zusammenhängende Graphen
- is_bidirected()
- graph, Bidirektionale Graphen
- Is_Bipartite(), Weitere Funktionen
- Is_Connected(), Einfach und zweifach zusammenhängende Graphen
- is_directed()
- graph, Der wahre Unterschied zwischen gerichteten und ungerichteten Graphen in LEDA
- is_hidden()
- graph, Kanten zwischenzeitlich verbergen
- Is_Planar(), Übungen
- Is_Plane_Map()
- graph, Ordnungserhaltende Einbettungen
- Is_Simple(), Weitere Funktionen
- Item, Listen und das Item-Container-Konzept
- Item-Container-Konzept, Listen und das Item-Container-Konzept
- Item-Typ
- abhängiger, Listen und das Item-Container-Konzept, Vergleichen von LEDA-Objekten
- unabhängiger, Listen und das Item-Container-Konzept, Vergleichen von LEDA-Objekten
- Iterator
- auf graph, Graph-Iteratoren
- Kanten-, Graph-Iteratoren
- Knoten-, Graph-Iteratoren
K
- K3,3, Übungen, Planare Einbettungen
- K5, Planare Einbettungen
- Kante, Ein Anwendungsbeispiel: Breitensuche in einem Graphen, Grundlagen
- adjazente
- in einem gerichteten graph, Gerichtete Graphen in LEDA
- in einem ungerichteten graph, Ungerichtete Graphen in LEDA
- adjazente vs. inzidente, Gerichtete Graphen in LEDA
- ausgehende, Grundlagen
- gerichtete, Grundlagen
- inzidente, Grundlagen
- umgekehrte (Siehe Rückwärtskante)
- Kanten-Array (Siehe edge_array)
- Kanten-Map (Siehe edge_map)
- Kapazität, Maximale Flüsse
- Kapazitätsbeschränkung, Maximale Flüsse
- Kardinalitäts-Matching
- allgemeines, Maximale allgemeine, ungewichtete Matchings
- bipartites, Maximale bipartite, ungewichtete Matchings
- Keller (Siehe Stapel)
- Kellerautomat, Stapel mit unbeschränkter Elementanzahl (Klasse stack)
- key (Siehe Schlüssel)
- key()
- b_priority_queue, Prioritäts-Warteschlangen mit beschränkten, ganzzahligen Prioritäten
(Klasse b_priority_queue)
- dictionary, Wörterbücher (Klasse dictionary)
- sortseq, Grundfunktionalität
- Kind
- eines Knotens, Übungen
- Kirchhoff'sches Gesetz, Maximale Flüsse
- Knoten, Ein Anwendungsbeispiel: Breitensuche in einem Graphen, Grundlagen
- adjazenter, Grundlagen
- über einen Pfad erreichbarer, Grundlagen
- Knoten-Array (Siehe node_array)
- Knoten-Map (Siehe node_map)
- Kodierung
- mit fixer Länge, Ein Anwendungsbeispiel: Huffman-Kodierung
- mit variabler Länge, Ein Anwendungsbeispiel: Huffman-Kodierung
- präfixfreie, Ein Anwendungsbeispiel: Huffman-Kodierung
- optimale, Ein Anwendungsbeispiel: Huffman-Kodierung
- Kollision
- bei Hashing, Hashing mit Verkettung und Tafelverdoppelung
- Komplexität
- Platz-, Platzkomplexität
- quadratische, Zeitkomplexität
- Zeit-, Zeitkomplexität
- Kompressionsrate, Ein Anwendungsbeispiel: Huffman-Kodierung
- Kompressionsverfahren
- Huffman-Kodierung, Ein Anwendungsbeispiel: Huffman-Kodierung
- konstant
- Zeitkomplexität, Die O-Notation
- Konstruktor
- mit Angabe der linearen Ordnung, Mehrere lineare Ordnungen auf einem Typ
- Kopf
- einer Schlange, Schlangen
- Kopie
- isomorphe eines Graphen, Graphen kopieren
- Kruskals Algorithmus, Was wir nicht beschrieben haben
-
Kuratowksi
Kazimierz
, Planare Einbettungen
- Kuratowski-Graph, Planare Einbettungen
- Kürzeste-Wege-Problem, Algorithmen für kürzeste Wege
- Kürzester Weg, Ein Anwendungsbeispiel: Breitensuche in einem Graphen
- Algorithmen aus shortest_path.h, Algorithmen für kürzeste Wege
L
- label_color
- GraphWin, Attribute von GraphWin
- label_pos
- GraphWin, Attribute von GraphWin
- label_type
- GraphWin, Attribute von GraphWin
- Labyrinth
- Ausweg finden, Übungen
- Landau'sches Symbol, Die O-Notation
- Landkarte, Landkarten und Gebiete im täglichen Leben
- last()
- list, Listen und das Item-Container-Konzept
- last-in-first-out (Siehe LIFO-Prinzip)
- Lateinische Zufallstexte erzeugen, Ein Anwendungsbeispiel: Lateinische Zufallstexte erzeugen
- layer (Siehe Schicht)
- LD_LIBRARY_PATH, Starten
- LEDA, Was ist LEDA?
- Bibliotheken, Binden
- Error-Handler, Fehlerbehandlung
- erwerben, Vorbereitungen
- Guide, An wen wendet sich dieses Tutorium?, Wo gibt es Hilfe?
- Header-Dateien, Die Header-Dateien von LEDA
- Hilfe erhalten, Vorbereitungen
- Hinzubinden der Bibliothek libG, Ein erstes Programm
- Hinzubinden der Bibliotheken libW und libP, Ein erstes Programm
- Include-Verzeichnisse (Siehe LEDA-Header-Datei)
- installieren, Vorbereitungen
- integrierte Entwicklungsumgebung, Die MS-Windows-Welt
- Klassifizierung der Datentypen, Klassifizierung der LEDA-Datentypen
- Kompendium, An wen wendet sich dieses Tutorium?
- Online-Manual, An wen wendet sich dieses Tutorium?, Wo gibt es Hilfe?
- Programme binden, LEDA-Programme übersetzen, binden und starten
- Programme kompilieren, LEDA-Programme übersetzen, binden und starten
- Programme starten, LEDA-Programme übersetzen, binden und starten
- Regelwerk, Das LEDA-Regelwerk, Die goldenen LEDA-Regeln
- (Siehe auch LEDA-Regel)
- Übersicht, Die goldenen LEDA-Regeln
- Speichermanager, Effiziente Speicherverwaltung für eigene Typen
- Typen- und
Kopierkonzept, Einfach strukturierte Typen und deren Kopierkonzept
- unter MS-Windows, Die MS-Windows-Welt
- unter Unix, Die Unix-Welt
- leda
- Namensraum, Der Namensraum leda, Einen eigenen Typ linear geordnet machen
- LEDA-Regel
- Anforderungen an gehashte Typen, Hashing in LEDA
- Anforderungen an linear geordnete Typen, Linear geordnete Typen
- Anforderungen an Typparameter, Benutzerdefinierte Typparameter
- Definition mit Initialisierung durch Kopieren, Das LEDA-Regelwerk
- Gleichheit und Identität, Vergleichen von LEDA-Objekten
- Illegaler Zugriff über Item, Listen verändern und in Listen suchen
- Kopie eines Wertes, Einfach strukturierte Typen und deren Kopierkonzept, Kopieren von Objekten von item-basiertem Typ
- Spezifikation der zu durchlaufenden Struktur in forall-Makros, Ein genauerer Blick auf die forall-Makros
- Verändern von
Objekten eines item-basierten Containertyps während einer
Iteration darüber, Ein genauerer Blick auf die forall-Makros
- leda::after, Listen und das Item-Container-Konzept, Weitere Operationen, die Listen verändern
- leda::before, Listen und das Item-Container-Konzept, Weitere Operationen, die Listen verändern
- LEDA_CHECKING_OFF, Automatische Bereichsüberprüfung (Range Checking)
- leda_exception, Fehlerbehandlung
- leda_mdd.dll, Die MS-Windows-Welt
- leda_mdd.lib, Die MS-Windows-Welt
- LEDA_MEMORY(T), Effiziente Speicherverwaltung für eigene Typen
- LEDAROOT, Übersetzen
- Leerstring, Zeichenketten (Klasse string)
- lib3D, Binden
- libG, Binden
- libG2, Binden
- libGeoWin, Binden
- libL, Binden
- libleda, Binden
- libm, Binden
- libP, Binden
- libW, Binden
- LIFO-Prinzip, Stapel
- list, Lineare Listen (Klasse list)
- Liste, Lineare Listen (Klasse list)
- (Siehe auch list)
- (Siehe auch slist)
- aneinanderhängen, Listen verändern und in Listen suchen
- auftrennen, Listen verändern und in Listen suchen
- doppelt verkettete, Anhängen und Entfernen von Elementen am Ende einer Liste, Listen und das Item-Container-Konzept
- einfach verkettete, Einfach verkettete Listen (Klasse slist)
- einfügen in, Listen und das Item-Container-Konzept
- Element löschen, Listen verändern und in Listen suchen
- lineare, Lineare Listen (Klasse list)
- löschen aus, Listen und das Item-Container-Konzept
- permutieren, Listen verändern und in Listen suchen
- sortieren, Listen sortieren
- suchen in, Listen verändern und in Listen suchen
- umdrehen, Listen verändern und in Listen suchen
- und Mengen, Mengen (Klasse set)
- vs. Array, Lineare Listen (Klasse list)
- Zugriff auf Elemente, Listen und das Item-Container-Konzept
- Listenelement, Listen und das Item-Container-Konzept
- locate()
- sortseq, Grundfunktionalität
- locate_pred()
- sortseq, Grundfunktionalität
- logarithmisch
- Zeitkomplexität, Die O-Notation
- lookup()
- dictionary, Wörterbücher (Klasse dictionary)
- sortseq, Grundfunktionalität
- Lottoziehung
- Variationen erzeugen, Eine Anwendung: Variationen erzeugen
- low()
- array, Nützliche Methoden der Klasse array
- low1()
- array2, Zweidimensionale Felder (Klasse array2)
- low2()
- array2, Zweidimensionale Felder (Klasse array2)
M
- Make_Biconnected(), Einfach und zweifach zusammenhängende Graphen
- make_bidirected()
- graph, Ungerichtete Graphen in LEDA, Bidirektionale Graphen
- Make_Connected(), Einfach und zweifach zusammenhängende Graphen
- make_directed()
- graph, Die Methoden make_directed() und make_undirected()
- make_map()
- graph, Maps
- make_undirected()
- graph, Ungerichtete Graphen in LEDA, Die Methoden make_directed() und make_undirected()
- Makefile
- generisches, Binden
- Makro-Expansion
- der forall-Makros, Ein genauerer Blick auf die forall-Makros
- map, Hashing in LEDA, Maps (Klasse map)
- Anwendungsfälle, Anwendungsfälle für map
- Map, Maps
- ebene, Ordnungserhaltende Einbettungen
- zweidimensionale (Siehe map2)
- map2, Zweidimensionale Maps
- Markov-Kette, Markov-Ketten (Klassen markov_chain und dynamic_markov_chain)
- (Siehe auch markov_chain)
- markov_chain, Markov-Ketten (Klassen markov_chain und dynamic_markov_chain)
- marriage problem (Siehe Heiratsproblem)
- Matching, Matching-Algorithmen
- allgemeines, gewichtetes, Maximale allgemeine, gewichtete Matchings
- allgemeines, ungewichtetes, Maximale allgemeine, ungewichtete Matchings
- bipartites, gewichtetes, Maximale bipartite, gewichtete Matchings
- bipartites, ungewichtetes, Maximale bipartite, ungewichtete Matchings
- maximales, Matching-Algorithmen
- perfektes, Matching-Algorithmen
- Mathematiker-Problem, Übungen
- max()
- int_set, Wenn man Minimum und Maximum im Voraus kennt (Klasse int_set)
- list, Weitere Informationen zur Klasse list
- Max-Planck-Institut für Informatik, Was ist LEDA?
- MAX_CARD_BIPARTITE_MATCHING(), Maximale bipartite, ungewichtete Matchings
- MAX_CARD_MATCHING(), Maximale allgemeine, ungewichtete Matchings
- MAX_FLOW(), Maximale Flüsse
- max_flow.h, Maximale Flüsse
- max_item()
- sortseq, Grundfunktionalität
- MAX_WEIGHT_BIPARTITE_MATCHING(), Maximale bipartite, gewichtete Matchings
- MAX_WEIGHT_MATCHING(), Maximale allgemeine, gewichtete Matchings
- maximum flow (Siehe maximaler Fluss)
- with minimum cost (Siehe maximaler Fluss mit minimalen Kosten)
- MAXNONREPMIRP-Zahl, Übungen
- mc_matching.h, Maximale allgemeine, ungewichtete Matchings
- mcb_matching.h, Maximale bipartite, ungewichtete Matchings
- member()
- int_set, Wenn man Minimum und Maximum im Voraus kennt (Klasse int_set)
- set, Elemente einfügen und Test auf Enthaltensein
- Memory-Manager (Siehe Speichermanager)
- Menge, Mengen (Klasse set)
- (Siehe auch set)
- fraktale, Ein Beispiel: Fraktale Mengen erzeugen
- von ganzen Zahlen, Mengen von ganzen Zahlen
- merge()
- list, Listen sortieren
- sortseq, Aufspalten, aneinanderhängen und zusammenmischen
- merge_sort()
- list, Listen sortieren
- Mergesort, Übungen
- message()
- GraphWin, Die Programmierschnittstelle der Klasse GraphWin
- min()
- int_set, Wenn man Minimum und Maximum im Voraus kennt (Klasse int_set)
- list, Weitere Informationen zur Klasse list
- MIN_COST_FLOW(), Weitere Informationen
- min_cost_flow.h, Maximale Flüsse mit minimalen Kosten
- MIN_COST_MAX_FLOW(), Maximale Flüsse mit minimalen Kosten
- MIN_CUT(), Minimale Schnitte
- min_cut.h, Minimale Schnitte
- min_item()
- sortseq, Grundfunktionalität
- min_span.h, Minimale aufspannende Bäume
- MIN_SPANNING_TREE(), Minimale aufspannende Bäume
- Minimaler aufspannender Baum, Minimale aufspannende Bäume
- minimum cut (Siehe minimaler Schnitt)
- minimum spanning forest (Siehe minimaler aufspannender Wald)
- minimum spanning tree (Siehe minimaler aufspannender Baum)
- misc.h, Definieren von Arrays und Zugriff auf Elemente, Einige nützliche Funktionen
- Modul, Die Struktur der Include-Verzeichnisse ab LEDA 5.0
- core, Die Struktur der Include-Verzeichnisse ab LEDA 5.0
- MPII (Siehe Max-Planck-Institut für Informatik)
- Multikanten
- in einem gerichteten graph, Gerichtete Graphen in LEDA
- Multimenge, Mengen (Klasse set)
- Multiset (Siehe Multimenge)
- mw_matching.h, Maximale allgemeine, gewichtete Matchings
- mwb_matching.h, Maximale bipartite, gewichtete Matchings
N
- Nachbarknoten, Grundlagen
- Nachfahre
- eines Knotens, Übungen
- Namensraum
- leda, Der Namensraum leda
- Namespace (Siehe Namensraum)
- neighbor node (Siehe Nachbarknoten)
- network flow (Siehe Netzwerk-Fluss)
- Netzwerk, Maximale Flüsse
- Netzwerk-Fluss (Siehe Fluss)
- Netzwerk-Fluss-Algorithmus, Netzwerk-Fluss-Algorithmen
- new, Effiziente Speicherverwaltung für eigene Typen
- new_edge()
- graph, Ein erstes Programm, Die Reihenfolge in in_edges(v) und out_edges(v) beeinflussen
- GRAPH, Die Klasse GRAPH
- new_node()
- graph, Ein erstes Programm
- GRAPH, Die Klasse GRAPH
- node, Ein Anwendungsbeispiel: Breitensuche in einem Graphen, Grundlagen
- (Siehe auch Knoten)
- node, Ein erstes Programm
- node_array, Ein erstes Programm, Knoten-Arrays und Kanten-Arrays
- gültig auf Graph, Knoten-Arrays und Kanten-Arrays
- Konstruktor mit Angabe der maximalen Knotenanzahl, Knoten-Arrays und Kanten-Arrays
- node_list, Spezielle Hilfsdatenstrukturen für Graphenalgorithmen, Algorithmen für kürzeste Wege
- node_map, Knoten-Maps und Kanten-Maps
- statt map<node,V>, Anwendungsfälle für map
- node_map2, Die Klassen node_matrix und node_map2
- node_matrix, Die Klassen node_matrix und node_map2
- node_partition, Spezielle Hilfsdatenstrukturen für Graphenalgorithmen
- node_pq, Spezielle Hilfsdatenstrukturen für Graphenalgorithmen
- node_set, Spezielle Hilfsdatenstrukturen für Graphenalgorithmen
- NodeIt, Graph-Iteratoren
- number_of_nodes()
- graph, Ein erstes Programm
- number_of_visits()
- markov_chain, Markov-Ketten (Klassen markov_chain und dynamic_markov_chain)
- Numerischer Typ
- als Template-Parameter von Graphenalgorithmen, Mit numerischen Typen templatisierte Funktionen
O
- O(log(n)), Die O-Notation
- O(n), Die O-Notation
- O(n^2), Die O-Notation
- O-Notation, Die O-Notation
- Theta, Die O-Notation
- opposite()
- graph, Die Klasse GRAPH, Navigieren
- Ordnung
- benutzer-definierte, Ein Beispiel: Listen von String-Paaren bei der Berechnung von Anagrammen
- lineare, Lineare Ordnungen, Paare, Tripel und Quadrupel (Klassen two_tuple, three_tuple, four_tuple)
- mehrere auf einem Typ, Mehrere lineare Ordnungen auf einem Typ
- out-degree (Siehe Ausgangsgrad)
- out_edges(v), Gerichtete Graphen in LEDA
- OutAdjIt, Graph-Iteratoren
- outdeg()
- graph, Ein Beispiel
P
- p_dictionary, Persistente Wörterbücher
- p_queue, Schlangen mit unbeschränkter Elementanzahl (Klasse queue), Prioritäts-Warteschlangen, Prioritäts-Warteschlangen mit unbeschränkten Prioritäten (Klasse p_queue)
- Paar, Paare, Tripel und Quadrupel (Klassen two_tuple, three_tuple, four_tuple)
- (Siehe auch two_tuple)
- Paarungen erzeugen, Übungen
- Palindrom, Zeichenketten (Klasse string)
- partition, Was wir nicht beschrieben haben
- Pascal'sches Dreieck, Dynamisches Vergrößern von Arrays
- permute()
- array, Nützliche Methoden der Klasse array
- list, Weitere Operationen, die Listen verändern
- Persistenz von Variablen, Persistenz von Variablen
- Pfad, Grundlagen
- einfacher, Grundlagen
- kürzester, Algorithmen für kürzeste Wege
- Länge, Grundlagen, Algorithmen für kürzeste Wege
- place_into_win()
- GraphWin, Straight Line Embedding
- PLANAR(), Ordnungserhaltende Einbettungen, Algorithmen für planare Graphen, Übungen
- planar_map, Die Klassen planar_map und PLANAR_MAP
- PLANAR_MAP, Die Klassen planar_map und PLANAR_MAP
- plane_graph_alg.h, Ordnungserhaltende Einbettungen, Algorithmen für planare Graphen
- Platzkomplexität, Platzkomplexität
- Polarkoordinaten
- und compare(), Übungen
- pop()
- list, Listen füllen und leeren
- queue, Schlangen mit unbeschränkter Elementanzahl (Klasse queue)
- stack, Stapel, Stapel mit unbeschränkter Elementanzahl (Klasse stack)
- pop_back()
- list, Anhängen und Entfernen von Elementen am Ende einer Liste
- pos()
- string, Weitere Operationen auf Strings
- position
- GraphWin, Attribute von GraphWin
- Postfix-Notation, Stapel mit unbeschränkter Elementanzahl (Klasse stack)
- pp_dictionary, Persistente Wörterbücher
- pq_item, Prioritäts-Warteschlangen mit unbeschränkten Prioritäten (Klasse p_queue)
- Precondition (Siehe Vorbedingung)
- pred()
- list, Listen und das Item-Container-Konzept
- sortseq, Grundfunktionalität
- predecessor (Siehe Vorgänger)
- print()
- array, Nützliche Methoden der Klasse array
- list, Listen sortieren
- print_statistics(), Effiziente Speicherverwaltung für eigene Typen
- prio()
- p_queue, Prioritäts-Warteschlangen mit unbeschränkten Prioritäten (Klasse p_queue)
- Priorität, Prioritäts-Warteschlangen
- Prioritäts-Warteschlange, Prioritäts-Warteschlangen
- mit beschränkten, ganzzahligen Prioritäten (Siehe b_priority_queue)
- mit unbeschränkten Prioritäten (Siehe p_queue)
- priority queue (Siehe Prioritäts-Warteschlange)
- Profiling, Nützliche Kleinigkeiten
- Pseudo-Zufallszahl, Zufallszahlen (Klasse random_source)
- Push
- auf Schlange, Schlangen
- Push Down Automaton (Siehe Kellerautomat)
- push()
- list, Listen füllen und leeren
- stack, Stapel, Stapel mit unbeschränkter Elementanzahl (Klasse stack)
R
- rand_int, Die Saat
- Random Walk, Dynamische Zufallsvariablen (Klasse dynamic_random_variate)
- und Markov-Kette, Markov-Ketten (Klassen markov_chain und dynamic_markov_chain)
- random_graph()
- graph, Graph-Generatoren
- random_source, Zufallszahlen (Klasse random_source)
- Bit-Modus, Der Bit-Modus
- erzeugen von double, Ein Beispiel: Fraktale Mengen erzeugen
- ganzzahliger Modus, Der ganzzahlige Modus
- Konstruktor, Der ganzzahlige Modus, Der Bit-Modus
- Präzision, Der Bit-Modus
- statt random_variate, Schlangen mit unbeschränkter Elementanzahl (Klasse queue)
- random_variate, Zufallsvariablen, Statische Zufallsvariablen (Klasse random_variate), Schlangen mit unbeschränkter Elementanzahl (Klasse queue)
- Konstruktor, Statische Zufallsvariablen (Klasse random_variate)
- range checking (Siehe automatische Bereichsüberprüfung)
- read()
- graph, Lesen aus einer Datei und Schreiben in eine Datei
- list, Weitere Informationen zur Klasse list
- string, Listen füllen und leeren
- read_line()
- string, Zeichenketten (Klasse string), Eingebaute Sortiermethoden
- read_string(), Definieren von Arrays und Zugriff auf Elemente
- redraw()
- GraphWin, Die Programmierschnittstelle der Klasse GraphWin
- Reference Counting (Siehe Referenzzählung)
- Referenzzählung, Handle-Typen und handle-ähnliche Typen
- Reflexivität, Lineare Ordnungen
- Regel (Siehe LEDA-Regel)
- Rehash, Hashing mit Verkettung und Tafelverdoppelung
- rel_freq_of_visit()
- markov_chain, Markov-Ketten (Klassen markov_chain und dynamic_markov_chain)
- replace()
- string, Weitere Operationen auf Strings
- replace_all()
- string, Weitere Operationen auf Strings
- resize()
- array, Beliebige Intervalle als Indexmengen, Nützliche Methoden der Klasse array, Dynamisches Vergrößern von Arrays, Grundlegende Operationen auf Listen
- Verdoppelungsstrategie bei array, Dynamische Zufallsvariablen (Klasse dynamic_random_variate)
- restore_all_edges()
- graph, Kanten zwischenzeitlich verbergen
- restore_edge()
- graph, Kanten zwischenzeitlich verbergen
- reversal edge (Siehe Gegenkante)
- reverse edge (Siehe Rückwärtskante)
- reverse()
- list, Weitere Operationen, die Listen verändern
- reverse_items()
- list, Weitere Operationen, die Listen verändern
- Rückwärtskante, Grundlagen, Ungerichtete Graphen in LEDA
- einfügen durch make_bidirected(), Starke Zusammenhangskomponenten
S
- s-t-cut (Siehe s-t-Schnitt)
- s-t-Schnitt, Minimale Schnitte
- Saarbrücker Hauptbahnhof, Schlangen mit unbeschränkter Elementanzahl (Klasse queue)
- Saat, Die Saat
- SCC (Siehe strongly connected component)
- Schachturnier
- Paarungen erzeugen, Übungen
- Schicht, Ein Anwendungsbeispiel: Breitensuche in einem Graphen
- Schlange, Schlangen
- mit begrenzter Elementanzahl (Siehe b_queue)
- mit unbegrenzter Elementanzahl (Siehe queue)
- Schlüssel
- eines Schlüssel-Wert-Paares, Assoziative Containertypen
- Schnitt
- durch Netzwerk, Minimale Schnitte
- minimaler, Minimale Schnitte
- von Mengen, Vereinigung, Schnitt und Differenz von Mengen
- Schnittkante, Minimale Schnitte
- Schranke
- asymptotische obere, Die O-Notation
- asymptotische untere, Die O-Notation
- search()
- list, Weitere Operationen, die Listen verändern
- second()
- two_tuple, Paare, Tripel und Quadrupel (Klassen two_tuple, three_tuple, four_tuple)
- Selbstschleife, Grundlagen
- self-loop (Siehe Selbstschleife)
- Senke
- in Netzwerk, Maximale Flüsse
- Sentinel (Siehe Wächter)
- seq_item, Grundfunktionalität
- set, Mengen (Klasse set)
- set (Siehe Menge)
- set_animation_steps()
- GraphWin, Spring Embedding
- set_border_width()
- GraphWin, Die Programmierschnittstelle der Klasse GraphWin
- set_default_value()
- d_array, Dictionary-Arrays (Klasse
d_array)
- set_directory(), Mit Verzeichnissen und Dateien umgehen
- set_edge_label_pos()
- GraphWin, Face-Zyklen
- set_edge_label_type()
- GraphWin, Face-Zyklen
- set_error_handler(), Fehlerbehandlung
- set_flush()
- GraphWin, Die Programmierschnittstelle der Klasse GraphWin
- set_node_border_width()
- GraphWin, Die Programmierschnittstelle der Klasse GraphWin
- set_position()
- GraphWin, Spring Embedding
- set_precision()
- random_source, Der Bit-Modus
- set_range()
- random_source, Der ganzzahlige Modus
- set_reversal()
- graph, Maps
- set_seed()
- random_source, Die Saat
- set_to_current_date()
- date, Datumsangaben (Klasse date)
- set_weight()
- dynamic_markov_chain, Die Klasse dynamic_markov_chain
- dynamic_random_variate, Dynamische Zufallsvariablen (Klasse dynamic_random_variate)
- shape
- GraphWin, Attribute von GraphWin
- shortest path (Siehe kürzester Weg)
- SHORTEST_PATH(), Algorithmen für kürzeste Wege
- shortest_path.h, Algorithmen für kürzeste Wege
- Signatur, Ein Beispiel: Listen von String-Paaren bei der Berechnung von Anagrammen
- Simulation
- diskrete Ereignis-, Prioritäts-Warteschlangen
- single pass, Wie man anfängt
- size()
- array, Nützliche Methoden der Klasse array
- d_array, Dictionary-Arrays (Klasse
d_array)
- dictionary, Wörterbücher (Klasse dictionary)
- list, Anhängen und Entfernen von Elementen am Ende einer Liste
- p_queue, Ein Anwendungsbeispiel: Huffman-Kodierung
- queue, Schlangen mit unbeschränkter Elementanzahl (Klasse queue)
- set, Vereinigung, Schnitt und Differenz von Mengen
- stack, Stapel mit unbeschränkter Elementanzahl (Klasse stack)
- size_of_file(), Mit Verzeichnissen und Dateien umgehen
- Skiplist, Fingersuche und schnelles Einfügen
- als Implementierungsparameter, Implementierungsparameter
- slist, Einfach verkettete Listen (Klasse slist)
- Slot, Die Grundidee von Hashing
- sort()
- array, Eingebaute Sortiermethoden, Die O-Notation
- list, Listen sortieren
- sort_edges()
- graph, Ein erstes Programm
- sort_nodes()
- graph, Ein erstes Programm, Iterieren über alle Knoten und Kanten
- Sortieralgorithmus
- stabiler, Listen sortieren
- Sortieren
- durch Minimumsuche, Definieren von Arrays und Zugriff auf Elemente, Zeitkomplexität, Platzkomplexität und die O-Notation
- von verschiedenen, ganzen Zahlen, Wenn man Minimum und Maximum im Voraus kennt (Klasse int_set)
- sortseq, Schlangen mit unbeschränkter Elementanzahl (Klasse queue), Geordnete Folgen (Klasse sortseq)
- source (Siehe Quelle)
- source()
- graph, Navigieren
- spanning forest (Siehe aufspannender Wald)
- spanning tree (Siehe aufspannender Baum)
- SPANNING_TREE(), Minimale aufspannende Bäume
- Speichermanager, Effiziente Speicherverwaltung für eigene Typen
- split()
- list, Weitere Operationen, die Listen verändern
- sortseq, Aufspalten, aneinanderhängen und zusammenmischen
- Spring Embedder, Spring Embedding
- SPRING_EMBEDDING(), Spring Embedding
- Stack (Siehe Stapel)
- stack, Stapel, Stapel mit unbeschränkter Elementanzahl (Klasse stack)
- Standardformat, Das Standardformat
- Stapel, Stapel
- (Siehe auch stack)
- Starke Zusammenhangskomponente, Starke Zusammenhangskomponenten
- std
- Namensraum, Der Namensraum leda
- step()
- markov_chain, Markov-Ketten (Klassen markov_chain und dynamic_markov_chain)
- Straight Line Embedding, Straight Line Embedding
- STRAIGHT_LINE_EMBEDDING(), Straight Line Embedding
- String, Zeichenketten (Klasse string)
- (Siehe auch string)
- Leer-, Zeichenketten (Klasse string)
- string, Zeichenketten (Klasse string)
- Konstruktor, Handle-Typen und handle-ähnliche Typen
- string.h, Die Header-Dateien von LEDA
- string_istream, Was wir nicht beschrieben haben
- string_ostream, Was wir nicht beschrieben haben
- STRONG_COMPONENTS(), Starke Zusammenhangskomponenten
- strongly connected component (Siehe starke Zusammenhangskomponente)
- style
- GraphWin, Attribute von GraphWin
- Subskript-Operator (Siehe [])
- succ()
- list, Listen und das Item-Container-Konzept
- Suchbaum, Balancierte Suchbäume
- symdiff()
- set, Vereinigung, Schnitt und Differenz von Mengen
T
- tac, Grundlegende Operationen auf Listen
- tail()
- list, Anhängen und Entfernen von Elementen am Ende einer Liste
- string, Weitere Operationen auf Strings
- target (Siehe Ziel)
- target()
- graph, Navigieren
- Taschenrechner
- mit UPN, Stapel mit unbeschränkter Elementanzahl (Klasse stack)
- Teilbaum, Übungen
- Teilgraph, Übungen
- Theta(f(n)), Die O-Notation
- third()
- three_tuple, Paare, Tripel und Quadrupel (Klassen two_tuple, three_tuple, four_tuple)
- three_tuple, Paare, Tripel und Quadrupel (Klassen two_tuple, three_tuple, four_tuple)
- Tic-Tac-Toe, Übungen
- Tiefensuche (Siehe depth first search)
- mit DFS(), Algorithmen zum systematischen Durchsuchen
- mit DFS_NUM(), Ein Beispiel: Visualisierung von DFS_NUM()
- Top of Queue, Schlangen
- Top of Stack, Stapel
- top()
- queue, Schlangen mit unbeschränkter Elementanzahl (Klasse queue)
- stack, Stapel mit unbeschränkter Elementanzahl (Klasse stack)
- Topologische Sortierung, Wie man anfängt, Ein Beispiel: Eine Implementierung von TOPSORT()
- Zyklus erkennen, Übungen
- TOPSORT(), Ein erstes Programm
- Implementierung, Ein Beispiel: Eine Implementierung von TOPSORT()
- TORWAT-Algorithmus, Ein Beispiel: Fraktale Mengen erzeugen
- Tradeoff
- Zeit vs. Platz, Platzkomplexität
- Transitivität, Lineare Ordnungen
- Traveller, Schlangen mit unbeschränkter Elementanzahl (Klasse queue)
- tree_collection, Was wir nicht beschrieben haben
- Tripel, Paare, Tripel und Quadrupel (Klassen two_tuple, three_tuple, four_tuple)
- (Siehe auch three_tuple)
- try-catch, Fehlerbehandlung
- Tutte Embedder, Übungen
- TUTTE_EMBEDDING(), Übungen
- two_tuple, Paare, Tripel und Quadrupel (Klassen two_tuple, three_tuple, four_tuple)
- Typ
- abhängiger Item-, Vergleichen von LEDA-Objekten
- einfach strukturierter, Einfach strukturierte Typen und deren Kopierkonzept
- gehashter, Hashing in LEDA
- Handle-, Handle-Typen und handle-ähnliche Typen
- handle-ähnlicher, Handle-Typen und handle-ähnliche Typen
- hashender, Hashende Typen
- item-basierter strukturierter, Listen und das Item-Container-Konzept
- linear geordneter, Ein Beispiel: Listen von String-Paaren bei der Berechnung von Anagrammen, Lineare Ordnungen
- nicht item-basierter, Einfach strukturierte Typen und deren Kopierkonzept
- nicht-primitiver (Siehe strukturierter)
- primitiver, Einfach strukturierte Typen und deren Kopierkonzept
- strukturierter, Einfach strukturierte Typen und deren Kopierkonzept
- unabhängiger Item-, Vergleichen von LEDA-Objekten
- Verbund-, Paare, Tripel und Quadrupel (Klassen two_tuple, three_tuple, four_tuple)
- Typen- und Kopierkonzept, Kopieren von Objekten von item-basiertem Typ
- Typparameter, Definieren von Arrays und Zugriff auf Elemente, Benutzerdefinierte Typparameter
U
- ugraph, Die Klasse ugraph
- Umdrehen der Standardeingabe (Siehe tac)
- Umgekehrt Polnische Notation (Siehe Postfix-Notation)
- undefine()
- d_array, Dictionary-Arrays (Klasse
d_array)
- Unifikations-Problem, Listen sortieren
- und Mengen, Elemente einfügen und Test auf Enthaltensein
- unique()
- array, Nützliche Methoden der Klasse array
- list, Listen sortieren
- Universalität der Binärkodierung, Hashende Typen
- Unterteilung
- eines Graphen, Planare Einbettungen
- update_graph()
- GraphWin, Die Programmierschnittstelle der Klasse GraphWin, Face-Zyklen
- UPN (Siehe Postfix-Notation)
- use_node_data()
- graph, Knoten-Arrays und Kanten-Arrays, Knoten-Maps und Kanten-Maps
- used_time(), Einige nützliche Funktionen
- user_label
- GraphWin, Attribute von GraphWin
- using-Deklaration, Der Namensraum leda
- using-Direktive, Der Namensraum leda
V
- value (Siehe Wert)
- Variable
- persistente, Persistenz von Variablen
- Variation
- erzeugen durch Permutieren einer Liste, Eine Anwendung: Variationen erzeugen
- Vater
- eines Knotens, Übungen
- VCVARS32.BAT, Setzen der Umgebungsvariablen für Visual C++
- Vektor (Siehe Array)
- Verbundtyp, Paare, Tripel und Quadrupel (Klassen two_tuple, three_tuple, four_tuple)
- Verdoppelungsstrategie
- bei Arrays, Übungen
- Vereinigung
- von Mengen, Vereinigung, Schnitt und Differenz von Mengen
- vergleichs-äquivalent, Linear geordnete Typen
- vertex (Siehe Knoten)
- Verzeichnis
- durchwandern, Mit Verzeichnissen und Dateien umgehen
- Vier-Farben-Satz, Färbungsprobleme und duale Graphen
- Visual C++, Setzen der Umgebungsvariablen für Visual C++
- Visual Studio, Die MS-Windows-Welt
- Von MANN zu FRAU, Ein Anwendungsbeispiel: Breitensuche in einem Graphen
- mit BFS(), Die Klasse GRAPH
- Vorbedingung, Vorbedingungen (Preconditions), Fehlerbehandlung
- Vorfahre
- eines Knotens, Übungen
- Vorgänger, Ein Anwendungsbeispiel: Breitensuche in einem Graphen
- Vorwärtsreferenz, Wie man anfängt
W
- Wächter, Zweidimensionale Felder (Klasse array2)
- wait()
- GraphWin, Die Programmierschnittstelle der Klasse GraphWin
- Wald, Übungen, Ein Beispiel: Visualisierung von DFS_NUM()
- aufspannender, Minimale aufspannende Bäume
- minimaler, Minimale aufspannende Bäume
- Warteschlange
- Simulation, Schlangen mit unbeschränkter Elementanzahl (Klasse queue)
- Wert
- eines Netzwerk-Flusses, Maximale Flüsse
- eines Schlüssel-Wert-Paares, Assoziative Containertypen
- eines Schnitts, Minimale Schnitte
- width
- GraphWin, Attribute von GraphWin
- window, Interaktive Eingabe mit dem Editor GraphWin
- Wörterbuch, Wörterbücher (Klasse dictionary)
- (Siehe auch dictionary)
- persistentes, Persistente Wörterbücher
- Wörterbuch-Array, Dictionary-Arrays (Klasse
d_array)
- (Siehe auch d_array)
- Wörterbuchtyp, Wörterbücher (Klasse dictionary)
- write()
- graph, Lesen aus einer Datei und Schreiben in eine Datei
- Würfel
- gerechter, Der ganzzahlige Modus
- gezinkter, Statische Zufallsvariablen (Klasse random_variate)
- Wurzel, Übungen
Z
- Zeichenkette (Siehe String)
- Zeichnung
- eines Graphen vs. Einbettung, Spring Embedding
- Zeiger
- als Elemente eines Containertyps, Schlangen mit unbeschränkter Elementanzahl (Klasse queue)
- Zeit
- amortisierte, Amortisierte Analyse
- erwartete, Die O-Notation
- konstante, Die O-Notation
- lineare, Die O-Notation
- logarithmische, Die O-Notation
- Zeit-Platz-Tradeoff, Platzkomplexität
- Zeitkomplexität, Zeitkomplexität
- Ziel
- eines Knotens, Grundlagen
- Zufall, Zufallszahlen (Klasse random_source)
- Zufälliger Spaziergang (Siehe Random Walk)
- Zufallstext, Ein Anwendungsbeispiel: Lateinische Zufallstexte erzeugen
- Zufallsvariable, Zufallsvariablen
- gleichverteilte, Der ganzzahlige Modus, Zufallsvariablen
- nicht-gleichverteilte, Zufallsvariablen
- Zufallszahl, Zufallszahlen (Klasse random_source)
- Zusammenhangskomponente, Übungen
- starke, Starke Zusammenhangskomponenten
- Zuweisungsoperator
- und LEDA-Objekte, Kopieren von Objekten von item-basiertem Typ
- (Siehe auch Typen- und Kopierkonzept)
- Zuweisungsproblem, Matching-Algorithmen
- Zyklus, Grundlagen
- negativer in Abstands-Graph, Algorithmen für kürzeste Wege
