Come trovare in modo efficiente ultima chiave e il valore d'GTree

Question

Come trovare in modo efficiente ultima chiave e il valore d'GTree

voti

0

Ho bisogno di sviluppare una serie di funzioni per estendere glib2 GTreecon:

trovare primo elemento
trovare lo scorso
trovare più vicino (piano, ceil, grande meno di, almeno maggiore di)

Trovare prima è facile. È sufficiente fermare il g_tree_foreach()Calback dopo la prima. Ma come trovare l'ultimo elemento , senza attraversare tutto l'albero ?

Ho pensato che avrei potuto usare g_tree_search()con un callback che continua a tornare un valore positivo fino trovato, ma come faccio a sapere che sono attualmente l'ultimo elemento?

#include <stdio.h>
#include <sys/types.h>
#include <string.h>

#include <glib.h>

static
gint compare_int(gconstpointer p1, gconstpointer p2) {
    int i1 = GPOINTER_TO_INT(p1);
    int i2 = GPOINTER_TO_INT(p2);
    //printf(%d %d\n, i1, i2);
    return i1 == i2 ? 0 : i1 > i2 ? 1 : -1;
}


static
gboolean traverse(gpointer key, gpointer value, gpointer data) {
    //int ikey = GPOINTER_TO_INT(key);
    const char *sval = (const char *)value;
    printf(%s\n, sval);
    return FALSE;
}

static
gint find_last(gconstpointer p, gpointer user_data) {
    return 1;
}

static inline const char *NULS(const char *s) {
    return s ? s : NULL;
}

int main(int argc, char *argv[]) {
    GTree *tree = g_tree_new(compare_int);
    g_tree_insert(tree, GINT_TO_POINTER(10), ten);
    g_tree_insert(tree, GINT_TO_POINTER(-99), minus ninety-nine);
    g_tree_insert(tree, GINT_TO_POINTER(8), eight);
    g_tree_foreach(tree, traverse, NULL);
    printf(=======\n%s\n, NULS((const char*)g_tree_search(tree, (GCompareFunc)find_last, NULL)));
    return 0;
}

c binary-search-tree glib

È pubblicato 03/06/2017 alle 21:33
fonte dall'utente basin

In altre lingue...

1 risposte

basin · Accepted Answer · 2017-07-04 17:47

Non volevo attuare pienamente il mio albero, perché volevo eseguire la ricerca avanzata sulle GTreeistanze ricevute dal codice 3rd-party.

Invece ho pensato che gli autori Glib sarebbero difficilmente cambiare le loro strutture interne in questi giorni e che ho potuto usare i loro campi direttamente.

Il risultato è la versione estesa della funzione interna g_tree_find_node()da gtree.c. Ho aggiunto due parametri per controllare se voglio primo, ultimo o il nodo più vicino. L'algoritmo per i nodi più vicini differisce da Java di TreeMap, perché il nostro nodo non ha un puntatore al suo genitore. Codice completo con il test di unità è qui: gtreeex.c.

typedef enum {
    FIND_EXACT = 0,
    FIND_FLOOR = 0x2,
    FIND_CEIL  = 0x20,
    FIND_LOWER = (FIND_FLOOR + 1),
    FIND_HIGHER = (FIND_CEIL + 1)
} find_mode;

static GTreeNode *
g_tree_find_node_ex (GTree        *tree,
                  gconstpointer key,
                  GCompareDataFunc key_compare,
                  find_mode mode
                  )
{
    GTreeNode *node;
    gint cmp;
    GTreeNode *last_lesser_node = NULL;
    GTreeNode *last_greater_node = NULL;

    node = tree->root;
    if (!node)
        return NULL;

    while (1)
        {
            cmp = key_compare (key, node->key, tree->key_compare_data);
            if (cmp == 0) {
                if (mode == FIND_LOWER) {
                    cmp = -1;
                } else if (mode == FIND_HIGHER) {
                    cmp = 1;
                } else {
                    return node;
                }
            }

            if (cmp < 0)
                {
                    if (!node->left_child) {
                        if ( (mode & FIND_FLOOR) ) {
                            return last_lesser_node; /* can be null */
                        }
                        if ( (mode & FIND_CEIL) ) {
                            return node;
                        }
                        return NULL;
                    }

                    last_greater_node = node;
                    node = node->left;
                }
            else
                {
                    if (!node->right_child) {
                        if ( (mode & FIND_CEIL) ) {
                            return last_greater_node; /* can be null */
                        }
                        if ( (mode & FIND_FLOOR) ) {
                            return node;
                        }
                        return NULL;
                    }

                    last_lesser_node = node;
                    node = node->right;
                }
        }
}

Per ottenere migliori prestazioni è possibile utilizzare le macro preprocessore invece dei due nuovi parametri, sostituire ifcon #ife includono i bit di intestazione più volte.