È necessario prendere il nodo foglia che ha profondità minima. Non riesco a pensare ad un buon modo per farlo senza memorizzare informazioni aggiuntive in ogni nodo, si prega di suggerire, grazie mille.
trovare il più piccolo nodo foglia di profondità in BST
voti
1
2 risposte
voti 2
2
La soluzione di forza bruta è un breadth-first ricerca che termina alla prima foglia trovato, questo sarà più facile da implementare in modo iterativo che in modo ricorsivo.
Si veda ad esempio la pseudo-codice in mia risposta a "Larghezza Prima Vs Depth First" basta aggiungere un'altra condizione al ciclo while.
BTW - Questo ti porterà una foglia con la profondità minima, in quanto vi possono essere più di uno a quella profondità. Ottenere il set completo di foglie minimi di profondità è un po 'più difficile. Credo che andare con una strategia di approfondimento iterativo .
Scoprire cosa livello che il nodo è uno.
Tre scelte:
Trova il primo nodo e la ricerca verso il basso l'albero per esso. Sembra uno spreco, ma che richiede seconda ricerca visitare solo il numero di nodi come il livello, quindi è veramente veloce.
In alternativa è possibile tenere traccia, come si va. Si utilizza tre contatori levelCounter, thisLevelCountere nextLevelCounter. Ogni volta di più per un nuovo nodo si decrementa thisLevelCounter, e quando raggiunge lo zero si è spostato verso il basso un livello in modo da fare
levelCounter++
thisLevelCounter = nextLevelCounter
nextLevelCounter = 0
Ogni volta che si aggiunge un nodo figlio alla lista di ricerca, incrementare nextLevelCounter. Ogni volta che si memorizza un nuovo incremento nodo figlionextLevelCounter
Infine, la strategia di approfondimento iterativo ti dà il livello di sucesso per libero (che iterazione lo trova ...) e ha lo stesso ordine di esecuzione (anche se un moltiplicatore leggermente superiore) come la ricerca in ampiezza.
voti 0
0
Ecco la versione di codice (spero di non aver perso alcun controllo degli errori):
void min_leaf(node_t *t, int *min, int lev, node_t **n) {
if (!t) {
return;
}
if (lev > *min) {
printf("Back from %d at lev %d, min: %d already found\n",
t->key,
lev,
*min);
return;
}
if (!t->left && !t->right) {
if (*min > lev) {
*min = lev;
*n = t;
}
} else {
min_leaf(t->left, min, lev+1, n);
min_leaf(t->right, min, lev+1, n);
}
}
void bst_print_min_leaf(bst_t* bst) {
int min = 10000; /* Replace it with some really large number */
node_t *minn = NULL;
min_leaf(bst->root, &min, 0, &minn); /*level: root is level 0 */
if (minn) printf("min leaf is at depth: %d: (%p:%d)\n", min, minn, minn->key);
}