Perché C ++ STL non fornisce contenitori "ad albero"?

Perché il C ++ STL non fornisce alcun contenitore "albero", e qual è la cosa migliore da usare invece?

Voglio memorizzare una gerarchia di oggetti come un albero, piuttosto che usare un albero come miglioramento delle prestazioni ...

Esistono due motivi per cui potresti voler utilizzare un albero:

Volete rispecchiare il problema usando una struttura ad albero:
per questo abbiamo una libreria di grafici boost

Oppure vuoi un contenitore con caratteristiche di accesso ad albero. Per questo abbiamo

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

Fondamentalmente le caratteristiche di questi due contenitori sono tali che praticamente devono essere implementate usando alberi (sebbene questo non sia effettivamente un requisito).

Vedi anche questa domanda: implementazione dell'albero C.

Probabilmente per lo stesso motivo per cui non esiste un contenitore di alberi in boost. Esistono molti modi per implementare un tale contenitore e non esiste un buon modo per soddisfare tutti coloro che lo userebbero.

Alcuni problemi da considerare:

• Il numero di figli per un nodo è fisso o variabile?
• Quanto sovraccarico per nodo? - vale a dire, hai bisogno di puntatori genitore, puntatori di pari livello, ecc.
• Quali algoritmi fornire? - diversi iteratori, algoritmi di ricerca, ecc.

Alla fine, il problema finisce per essere che un contenitore per alberi che sarebbe abbastanza utile per tutti, sarebbe troppo pesante per soddisfare la maggior parte delle persone che lo usano. Se stai cercando qualcosa di potente, Boost Graph Library è essenzialmente un superset di ciò per cui una libreria ad albero potrebbe essere utilizzata.

Ecco alcune altre implementazioni di alberi generici:

• Kasper Peeters 'tree.hh
• Foresta di Adobe
• nucleo :: albero

La filosofia della STL è quella di scegliere un container basato su garanzie e non sulla base dell'implementazione del container. Ad esempio, la scelta del contenitore potrebbe essere basata sulla necessità di ricerche rapide. Per quanto ti interessa, il contenitore può essere implementato come un elenco unidirezionale - fintanto che la ricerca è molto veloce sarai felice. Questo perché non tocchi comunque gli interni, stai usando iteratori o funzioni membro per l'accesso. Il tuo codice non è legato alla modalità di implementazione del contenitore, ma alla sua velocità, se ha un ordine fisso e definito, o se è efficiente nello spazio e così via.

"Voglio memorizzare una gerarchia di oggetti come un albero"

Il C ++ 11 è venuto e se ne è andato e ancora non vedevano la necessità di fornire un std::tree, sebbene l'idea sia venuta fuori (vedi qui ). Forse il motivo per cui non l'hanno aggiunto è che è banalmente facile costruirne uno proprio sopra i contenitori esistenti. Per esempio...

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

Un semplice attraversamento avrebbe usato la ricorsione ...

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

Se vuoi mantenere una gerarchia e vuoi che funzioni con gli algoritmi STL , le cose potrebbero complicarsi. È possibile creare i propri iteratori e ottenere una certa compatibilità, tuttavia molti degli algoritmi semplicemente non hanno alcun senso per una gerarchia (tutto ciò che cambia l'ordine di un intervallo, ad esempio). Anche definire un intervallo all'interno di una gerarchia potrebbe essere un affare disordinato.

Se stai cercando un'implementazione dell'albero RB, allora stl_tree.h potrebbe essere adatto anche a te.

la std :: map si basa su un albero nero rosso . Puoi anche utilizzare altri contenitori per aiutarti a implementare i tuoi tipi di alberi.

In un certo senso, std :: map è un albero (è necessario che abbia le stesse caratteristiche prestazionali di un albero binario bilanciato) ma non espone altre funzionalità dell'albero. Il probabile ragionamento alla base del non includere una struttura di dati ad albero reale era probabilmente solo una questione di non includere tutto nello stl. Lo stl può essere considerato come un framework da utilizzare per implementare i propri algoritmi e strutture dati.

In generale, se c'è una funzionalità di libreria di base che si desidera, che non è nello stl, la correzione è guardare BOOST .

Altrimenti, ci sono un sacco di librerie là fuori , a seconda delle esigenze del tuo albero.

Tutti i contenitori STL sono rappresentati esternamente come "sequenze" con un meccanismo di iterazione. Gli alberi non seguono questo linguaggio.

Perché STL non è una libreria "tutto". Contiene essenzialmente le strutture minime necessarie per costruire le cose.

Questo sembra promettente e sembra essere quello che stai cercando: http://tree.phi-sci.com/

IMO, un'omissione. Ma penso che ci siano buone ragioni per non includere una struttura ad albero nell'STL. C'è molta logica nel mantenere un albero, che è meglio scritto come funzioni membro TreeNodenell'oggetto base . Quando TreeNodeè racchiuso in un'intestazione STL, diventa solo più incasinato.

Per esempio:

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); } 
} ;

Penso che ci siano diverse ragioni per cui non ci sono alberi STL. Principalmente gli alberi sono una forma di struttura di dati ricorsiva che, come un contenitore (elenco, vettore, set), ha una struttura fine molto diversa che rende difficili le scelte corrette. Sono anche molto facili da costruire in forma base usando l'STL.

Un albero con radice finita può essere pensato come un contenitore che ha un valore o un payload, ad esempio un'istanza di una classe A e, eventualmente, una raccolta vuota di (radici) alberi con radici; gli alberi con raccolta di sottotitoli vuoti sono considerati foglie.

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
{};

Bisogna pensare un po 'al design dell'iteratore ecc. E quali operazioni di prodotto e coprodotto si consentono di definire ed essere efficienti tra gli alberi - e l'STL originale deve essere ben scritto - in modo che il contenitore vuoto di set, vettore o elenco sia veramente vuoto di qualsiasi payload nel caso predefinito.

Gli alberi svolgono un ruolo essenziale in molte strutture matematiche (vedere gli articoli classici di Butcher, Grossman e Larsen; anche gli articoli di Connes e Kriemer per esempi di essi possono essere uniti e come vengono utilizzati per elencare). Non è corretto pensare che il loro ruolo sia semplicemente quello di facilitare alcune altre operazioni. Piuttosto facilitano tali compiti a causa del loro ruolo fondamentale come struttura di dati.

Tuttavia, oltre agli alberi ci sono anche "co-alberi"; gli alberi hanno soprattutto la proprietà che se si elimina la radice si elimina tutto.

Considera gli iteratori sull'albero, probabilmente verrebbero realizzati come una semplice pila di iteratori, su un nodo e sul suo genitore, ... fino alla radice.

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

Tuttavia, puoi averne quanti ne desideri; collettivamente formano un "albero" ma dove tutte le frecce scorrono nella direzione verso la radice, questo co-albero può essere ripetuto attraverso iteratori verso il banale iteratore e radice; tuttavia non può essere navigato attraverso o verso il basso (gli altri iteratori non gli sono noti) né è possibile eliminare l'insieme di iteratori se non tenendo traccia di tutte le istanze.

Gli alberi sono incredibilmente utili, hanno molta struttura, questo rende una sfida seria ottenere l'approccio definitivamente corretto. A mio avviso, questo è il motivo per cui non sono implementati nell'STL. Inoltre, in passato, ho visto persone diventare religiose e trovare stimolante l'idea di un tipo di contenitore contenente istanze del proprio tipo - ma devono affrontarlo - questo è ciò che rappresenta un tipo di albero - è un nodo che contiene un raccolta forse vuota di alberi (più piccoli). La lingua corrente lo consente senza difficoltà fornendo il costruttore predefinito per container<B>non allocare spazio sull'heap (o in qualsiasi altro luogo) per un B, ecc.

Per quanto mi riguarda sarei contento se questo, in una buona forma, trovasse la sua strada nello standard.

Leggendo le risposte qui, i motivi comuni citati sono che non si può iterare attraverso l'albero o che l'albero non assume l'interfaccia simile ad altri contenitori STL e non si possono usare algoritmi STL con tale struttura ad albero.

Tenendo presente ciò, ho cercato di progettare la mia struttura di dati ad albero che fornirà un'interfaccia simile a STL e sarà utilizzabile il più possibile con algoritmi STL esistenti.

La mia idea era che l'albero deve essere basato sui contenitori STL esistenti e che non deve nascondere il contenitore, in modo che sia accessibile da usare con gli algoritmi STL.

L'altra caratteristica importante che l'albero deve fornire sono gli iteratori che attraversano.

Ecco cosa sono riuscito a inventare: https://github.com/igagis/utki/blob/master/src/utki/tree.hpp

Ed ecco i test: https://github.com/igagis/utki/blob/master/tests/tree/tests.cpp

Tutti i contenitori STL possono essere utilizzati con iteratori. Non puoi avere un iteratore e un albero, perché non hai un modo "giusto" per attraversare l'albero.