GLib: Mnohonásobné stromy (3)

Prohledávání stromu

GNode* g_node_find(GNode *root,
                   GTraverseType order,
                   GTraverseFlags flags,
                   gpointer data);

…prohledá celý strom s kořenem root a vrátí pointer na první uzel GNode, který uchovává zadaná data. V případě neúspěchu vrátí  NULL.

Způsob prohledávání můžete ovlivnit dvojicí parametrů order a flags. Argumentem order se volí způsob procházení stromem ( G_IN_ORDER, G_PRE_ORDER, G_POST_ORDER nebo G_LEVEL_ORDER) a flags určuje, které druhy uzlů se mají brát v úvahu ( G_TRAVERSE_ALL, G_TRAVERSE_LEAFS nebo G_TRAVERSE_NON_LEAFS). O obou volbách jste se mohli dočíst více v předcházejícím dílu článku.

Práce s následníky

void g_node_reverse_children(GNode *node); 

Tato funkce obrátí pořadí potomků. Tzn. potomek, který byl až dosud první, bude poslední, druhý bude předposlední atd. S potomky těchto potomků (vnuky) se nestane nic.

GNode* g_node_find_child(GNode *node, GTraverseFlags flags, gpointer data); 

…vrátí pointer na prvního následníka uzlu node, který obsahuje zadaná data. Navíc můžete parametrem flags specifikovat, které typy uzlů se budou prohledávat ( G_TRAVERSE_ALL, G_TRAVERSE_LEAFS nebo G_TRAVERSE_NON_LEAFS). V případě neúspěchu bude návratovou hodnotou NULL. Pozor! Prohledávají se jen přímí potomci uzlu node (tj. synové). Chcete-li realizovat prohledávání více do hloubky, budete muset použít něco jiného, třeba  g_node_find().

gint g_node_child_position(GNode *node, GNode *child); 

…vrátí index uzlu child vzhledem k jeho sourozencům. child musí být potomkem uzlu node. Potomci jsou číslováni od nuly, tedy první následník má index 0, druhý 1 atd.

gint g_node_child_index(GNode *node, gpointer data); 

…vrátí index prvního potomka uzlu node, který obsahuje předaná data. V případě neúspěchu vrátí –1.

#define g_node_first_child(node) 

…vrátí pointer na prvního potomka uzlu node. Nemá-li node žádné následníky, vrátí  NULL.

GNode* g_node_last_child(GNode *node); 

…vrátí pointer na posledního potomka uzlu node nebo NULL, v případě neúspěchu.

GNode* g_node_nth_child(GNode *node, guint n); 

…vrátí n-tého potomka uzlu node. Je-li index n mimo povolený rozsah (0 až ???), vrátí  NULL.

guint g_node_n_children(GNode *node); 

…vrátí počet následníků uzlu node. (Synů. Vnuci, pravnuci apod. se nepočítají.)

Konstrukce foreach

void g_node_children_foreach(GNode *node, GTraverseFlags flags,
                             GNodeForeachFunc func,
                             gpointer data);

void(*GNodeForeachFunc)(GNode *node, gpointer data);

Funkce g_node_children_fo­reach() zavolá uživatelskou funkci func na každého následovníka uzlu node. Procházejí se jen přímí potomci (synové), takže nečekejte, že algoritmus bude sestupovat do hloubky. Parametrem flags můžete specifikovat, kteří z potomků se mají brát v úvahu ( G_TRAVERSE_ALL, G_TRAVERSE_LEAFS nebo G_TRAVERSE_NON_LEAFS  – viz předcházející díl článku).

Uživatelská funkce func, jejíž hlavička musí odpovídat typu GNodeForeachFunc, dostane při každém volání jako první parametr pointer na potomka uzlu node a uživatelská data, která jsou zároveň čtvrtým parametrem funkce g_node_children_fo­reach().

Práce se sourozenci

GNode* g_node_first_sibling(GNode *node); 

…vrátí první GNode v seznamu sourozenců (prvního sourozence uzlu node). Samozřejmě může být vrácen i samotný  node.

#define g_node_next_sibling(node) 

…vrátí následujícího sourozence uzlu node nebo NULL, pokud node je NULL nebo posledním sourozencem.

#define g_node_prev_sibling(node) 

…vrátí předcházejícího sourozence uzlu node nebo NULL, pokud node je NULL nebo prvním sourozencem.

GNode* g_node_last_sibling(GNode *node); 

…vrátí posledního sourozence uzlu node. Je-li posledním sourozencem právě node, vrátí samozřejmě jeho pointer.

A to je pro dnešek vše. Příště povídání o mnohonásobných stromech dokončíme a ukážeme si nějaký příklad, který snad do věci přivede trochu víc jasno.