Warum stellt die C ++ STL keine "Baum" -Container bereit?

Warum bietet die C ++ STL keine "Baum" -Container und was ist stattdessen die beste Verwendung?

Ich möchte eine Hierarchie von Objekten als Baum speichern, anstatt einen Baum als Leistungssteigerung zu verwenden ...

Es gibt zwei Gründe, warum Sie einen Baum verwenden möchten:

Sie möchten das Problem mithilfe einer baumartigen Struktur spiegeln:
Dafür haben wir eine Boost-Graph-Bibliothek

Oder Sie möchten einen Container mit baumartigen Zugriffseigenschaften. Dafür haben wir

• std::map(und std::multimap)
• std::set(und std::multiset)

Grundsätzlich sind die Eigenschaften dieser beiden Container so, dass sie praktisch mithilfe von Bäumen implementiert werden müssen (obwohl dies eigentlich keine Anforderung ist).

Siehe auch diese Frage: C-Baum-Implementierung

Wahrscheinlich aus dem gleichen Grund, dass kein Baumcontainer in Boost ist. Es gibt viele Möglichkeiten, einen solchen Container zu implementieren, und es gibt keine gute Möglichkeit, alle zufrieden zu stellen, die ihn verwenden würden.

Einige zu berücksichtigende Punkte:

• Ist die Anzahl der untergeordneten Elemente für einen Knoten fest oder variabel?
• Wie viel Overhead pro Knoten? - Benötigen Sie übergeordnete Zeiger, Geschwisterzeiger usw.
• Welche Algorithmen sind bereitzustellen? - verschiedene Iteratoren, Suchalgorithmen usw.

Am Ende besteht das Problem darin, dass ein Baumcontainer, der für alle nützlich genug wäre, zu schwer wäre, um die meisten Benutzer zufrieden zu stellen. Wenn Sie nach etwas Mächtigem suchen, ist Boost Graph Library im Wesentlichen eine Obermenge dessen, wofür eine Baumbibliothek verwendet werden könnte.

Hier sind einige andere generische Baumimplementierungen:

• Kasper Peeters 'Baum.hh
• Adobes Wald
• core :: tree

Die STL-Philosophie lautet, dass Sie einen Container basierend auf Garantien und nicht basierend auf der Implementierung des Containers auswählen. Zum Beispiel kann Ihre Wahl des Containers auf der Notwendigkeit einer schnellen Suche beruhen. Bei allem, was Sie interessiert, kann der Container als unidirektionale Liste implementiert werden - solange die Suche sehr schnell ist, wären Sie glücklich. Das liegt daran, dass Sie die Interna sowieso nicht berühren, sondern Iteratoren oder Elementfunktionen für den Zugriff verwenden. Ihr Code ist nicht daran gebunden, wie der Container implementiert wird, sondern daran, wie schnell er ist oder ob er eine feste und definierte Reihenfolge hat oder ob er platzsparend ist und so weiter.

"Ich möchte eine Hierarchie von Objekten als Baum speichern"

C ++ 11 ist gekommen und gegangen und sie sahen immer noch keine Notwendigkeit, eine bereitzustellen std::tree, obwohl die Idee aufkam (siehe hier ). Vielleicht liegt der Grund dafür, dass sie dies nicht hinzugefügt haben, darin, dass es trivial einfach ist, eigene auf den vorhandenen Containern aufzubauen. Zum Beispiel...

template< typename T >
struct tree_node
   {
   T t;
   std::vector<tree_node> children;
   };

Eine einfache Durchquerung würde Rekursion verwenden ...

template< typename T >
void tree_node<T>::walk_depth_first() const
   {
   cout<<t;
   for ( auto & n: children ) n.walk_depth_first();
   }

Wenn Sie eine Hierarchie pflegen wollen und Sie wollen , dass es für die Arbeit mit STL - Algorithmen , dann können die Dinge kompliziert werden. Sie könnten Ihre eigenen Iteratoren erstellen und eine gewisse Kompatibilität erreichen, jedoch machen viele der Algorithmen für eine Hierarchie einfach keinen Sinn (alles, was beispielsweise die Reihenfolge eines Bereichs ändert). Sogar das Definieren eines Bereichs innerhalb einer Hierarchie kann ein chaotisches Geschäft sein.

Wenn Sie nach einer RB-Tree-Implementierung suchen, ist stl_tree.h möglicherweise auch für Sie geeignet.

Die std :: map basiert auf einem rot-schwarzen Baum . Sie können auch andere Container verwenden , um Ihre eigenen Baumarten zu implementieren.

In gewisser Weise ist std :: map ein Baum (es muss dieselben Leistungsmerkmale wie ein ausgeglichener Binärbaum aufweisen), es werden jedoch keine anderen Baumfunktionen verfügbar gemacht. Die wahrscheinliche Begründung dafür, dass keine echte Baumdatenstruktur aufgenommen wurde, bestand wahrscheinlich nur darin, nicht alles in die stl aufzunehmen. Die stl kann als Framework für die Implementierung Ihrer eigenen Algorithmen und Datenstrukturen angesehen werden.

Wenn Sie eine grundlegende Bibliotheksfunktionalität wünschen, die nicht in der STL enthalten ist, sollten Sie sich im Allgemeinen BOOST ansehen .

Ansonsten gibt es ein Bündel von Bibliotheken aus dort , je nach den Bedürfnissen des Baumes.

Alle STL-Container werden extern als "Sequenzen" mit einem Iterationsmechanismus dargestellt. Bäume folgen dieser Redewendung nicht.

Weil die STL keine "Alles" -Bibliothek ist. Es enthält im Wesentlichen die Mindeststrukturen, die zum Bauen von Dingen erforderlich sind.

Dieser sieht vielversprechend aus und scheint das zu sein, wonach Sie suchen: http://tree.phi-sci.com/

IMO, eine Auslassung. Aber ich denke, es gibt gute Gründe, keine Baumstruktur in die STL aufzunehmen. Es gibt eine Menge von Logik in einen Baum gehalten wird , die sich am besten als geschrieben Member - Funktionen in das TreeNodeBasisobjekt . Wenn TreeNodees in einen STL-Header eingeschlossen ist, wird es nur noch unordentlicher.

Zum Beispiel:

template <typename T>
struct TreeNode
{
  T* DATA ; // data of type T to be stored at this TreeNode

  vector< TreeNode<T>* > children ;

  // insertion logic for if an insert is asked of me.
  // may append to children, or may pass off to one of the child nodes
  void insert( T* newData ) ;

} ;

template <typename T>
struct Tree
{
  TreeNode<T>* root;

  // TREE LEVEL functions
  void clear() { delete root ; root=0; }

  void insert( T* data ) { if(root)root->insert(data); } 
} ;

Ich denke, es gibt mehrere Gründe, warum es keine STL-Bäume gibt. In erster Linie sind Bäume eine Form der rekursiven Datenstruktur, die wie ein Container (Liste, Vektor, Menge) eine sehr unterschiedliche Feinstruktur aufweist, was die richtige Auswahl schwierig macht. Sie sind auch sehr einfach in Grundform mit der STL zu konstruieren.

Ein Baum mit endlichen Wurzeln kann als Container mit einem Wert oder einer Nutzlast betrachtet werden, beispielsweise als Instanz einer Klasse A und als möglicherweise leere Sammlung von verwurzelten (Unter-) Bäumen. Bäume mit leerer Sammlung von Teilbäumen werden als Blätter betrachtet.

template<class A>
struct unordered_tree : std::set<unordered_tree>, A
{};

template<class A>
struct b_tree : std::vector<b_tree>, A
{};

template<class A>
struct planar_tree : std::list<planar_tree>, A
{};

Man muss ein wenig über das Iterator-Design usw. nachdenken und darüber, welche Produkt- und Nebenproduktoperationen zwischen Bäumen definiert und effizient sein können - und die ursprüngliche STL muss gut geschrieben sein -, damit der leere Satz, Vektor oder Listencontainer vorhanden ist im Standardfall wirklich leer von jeglicher Nutzlast.

Bäume spielen in vielen mathematischen Strukturen eine wesentliche Rolle (siehe die klassischen Arbeiten von Butcher, Grossman und Larsen; auch die Arbeiten von Connes und Kriemer für Beispiele, wie sie zusammengefügt werden können und wie sie zur Aufzählung verwendet werden). Es ist nicht richtig zu glauben, dass ihre Rolle einfach darin besteht, bestimmte andere Operationen zu erleichtern. Sie erleichtern diese Aufgaben vielmehr aufgrund ihrer grundlegenden Rolle als Datenstruktur.

Neben Bäumen gibt es jedoch auch "Co-Bäume"; Die Bäume haben vor allem die Eigenschaft, dass Sie beim Löschen des Stamms alles löschen.

Betrachten Sie Iteratoren im Baum, wahrscheinlich würden sie als einfacher Stapel von Iteratoren für einen Knoten und dessen übergeordnetes Element bis zur Wurzel realisiert.

template<class TREE>
struct node_iterator : std::stack<TREE::iterator>{
operator*() {return *back();}
...};

Sie können jedoch so viele haben, wie Sie möchten. zusammen bilden sie einen "Baum", aber wo alle Pfeile in Richtung der Wurzel fließen, kann dieser Co-Baum durch Iteratoren in Richtung des trivialen Iterators und der Wurzel iteriert werden; Es kann jedoch nicht über oder nach unten navigiert werden (die anderen Iteratoren sind ihm nicht bekannt), und das Ensemble von Iteratoren kann nur gelöscht werden, wenn alle Instanzen im Auge behalten werden.

Bäume sind unglaublich nützlich, sie haben viel Struktur, was es zu einer ernsthaften Herausforderung macht, den definitiv richtigen Ansatz zu finden. Aus meiner Sicht sind sie deshalb nicht in der STL implementiert. Darüber hinaus habe ich in der Vergangenheit gesehen, wie Menschen religiös wurden und die Idee eines Containertyps mit Instanzen seines eigenen Typs als herausfordernd empfanden - aber sie müssen sich dem stellen - das ist, was ein Baumtyp darstellt - es ist ein Knoten, der a enthält möglicherweise leere Sammlung von (kleineren) Bäumen. Die aktuelle Sprache erlaubt es ohne Herausforderung, wenn der Standardkonstruktor für container<B>keinen Speicherplatz auf dem Heap (oder irgendwo anders) für ein Busw. reserviert .

Ich würde mich freuen, wenn dies in guter Form den Weg in den Standard finden würde.

Wenn man die Antworten hier durchliest, sind die häufig genannten Gründe, dass man den Baum nicht durchlaufen kann oder dass der Baum nicht die ähnliche Schnittstelle zu anderen STL-Containern annimmt und man keine STL-Algorithmen mit einer solchen Baumstruktur verwenden kann.

Vor diesem Hintergrund habe ich versucht, eine eigene Baumdatenstruktur zu entwerfen, die eine STL-ähnliche Schnittstelle bietet und so gut wie möglich mit vorhandenen STL-Algorithmen verwendet werden kann.

Meine Idee war, dass der Baum auf den vorhandenen STL-Containern basieren muss und dass er den Container nicht verbergen darf, damit er für die Verwendung mit STL-Algorithmen zugänglich ist.

Das andere wichtige Merkmal, das der Baum bereitstellen muss, sind die durchlaufenden Iteratoren.

Folgendes konnte ich mir einfallen lassen: https://github.com/igagis/utki/blob/master/src/utki/tree.hpp

Und hier sind die Tests: https://github.com/igagis/utki/blob/master/tests/tree/tests.cpp

Alle STL-Container können mit Iteratoren verwendet werden. Sie können keinen Iterator und keinen Baum haben, weil Sie keinen richtigen Weg haben, um durch den Baum zu gehen.