ForHosting KIT · Strumenti per sviluppatori

Calcolatore nodi albero di ricorsione

Conti i nodi di un albero di ricorsione divide et impera livello per livello: due sottoproblemi di metà dimensione partendo da 16 danno 5 livelli con 1, 2, 4, 8 e 16 nodi, 31 in tutto e 16 foglie. Verifichi gli esercizi senza disegnare l'albero. Gratis nel suo browser.

  • Gratis
  • Funziona nel suo browser
  • Senza registrazione
  • I suoi dati restano sul dispositivo
Usalo da WebAPIEmailTelegramApp presto
Se inserisce
Fattore di ramificazione
2
Rapporto di riduzione
2
Dimensione dell'input
16
Ottiene
Numero di livelli
5
Altezza dell'albero
4
Totale dei nodi
31
Nodi foglia
16

Le ricorrenze di tipo divide et impera della forma T di n uguale a volte T di n su b più il lavoro non ricorsivo compaiono in ogni corso di algoritmi quando merge sort, partizioni spaziali binarie o ricorsione multiway vengono disegnati come alberi. Gli studenti hanno bisogno di un conteggio affidabile di quanti nodi stiano a ogni livello e di quanto in profondità cresca l'albero prima che i sottoproblemi raggiungano il caso base. Questo calcolatore di nodi dell'albero di ricorsione accetta il fattore di ramificazione a, il rapporto di riduzione b e la dimensione di ingresso della radice n, percorre l'albero finché la dimensione del sottoproblema è al più uno, e restituisce il conteggio dei livelli, l'altezza, i totali di nodi e foglie, la sequenza di nodi per livello, le dimensioni dei sottoproblemi e due distribuzioni frazionarie del lavoro. Una assume costo unitario per nodo; l'altra assume lavoro proporzionale alla dimensione del sottoproblema, come nel disegno classico del merge sort in cui ogni livello pieno compie ancora lavoro lineare in n.

Cosa conta un albero di ricorsione e come si definiscono i livelli

Un albero di ricorsione è l'immagine di ogni sottoproblema creato da un algoritmo divide et impera il cui tempo soddisfa T di n uguale a volte T di n su b più f di n. La radice rappresenta l'istanza originale di dimensione n. Ogni nodo interno ha esattamente a figli, ciascuno risolve un problema la cui dimensione è quella del genitore divisa per b.

I livelli sono numerati da zero alla radice. Al livello i ci sono a elevato a i nodi, e ciascuno di essi ha dimensione di sottoproblema n divisa per b elevato a i, purché le dimensioni restino reali e positive. La scansione continua finché la dimensione corrente è strettamente maggiore di uno; il primo livello la cui dimensione è minore o uguale a uno viene tenuto come livello foglia dei casi base, poi la scansione si ferma.

Questa convenzione coincide con la condizione di arresto dei manuali nel risolvere direttamente ingressi di dimensione costante. L'altezza dell'albero è il conteggio dei livelli meno uno, il numero di archi su un cammino dalla radice a una foglia. I nodi foglia equivalgono ad a elevato all'altezza quando le dimensioni raggiungono uno su una potenza esatta e, in generale, al conteggio nodi dell'ultimo livello registrato.

I nodi interni sono il totale meno le foglie. Con fattore di ramificazione uno l'albero è una sola spina di lunghezza pari al numero di divisioni successive finché la dimensione è al più uno.

Dove contare i nodi dell'albero aiuta

I corsi di algoritmi e le piattaforme di tutoraggio usano un calcolatore di nodi dell'albero di ricorsione affinché gli apprendisti verifichino profondità e ampiezza per a, b e n arbitrari senza disegnare centinaia di nodi a mano. I generatori di esami necessitano di un oracolo deterministico che segni come errato un preteso conteggio di foglie o di livelli invece di accettare stime asintotiche vaghe.

Gli strumenti di preparazione ai colloqui e i visualizzatori di complessità abbinano gli array per livello a grafici così i candidati vedono perché un divide et impera bilanciato spesso spende lo stesso lavoro a ogni livello quando a è uguale a b. I notebook di ingegneria che prototipano splitter multiway o grafi di task paralleli possono validare il fan-out prima di scrivere scheduler di produzione. La validazione fallita non consuma saldo.

Compiti e tutoraggio di algoritmi

Consenta agli studenti di inviare a, b e n per T(n)=a T(n/b)+f(n) e di verificare conteggio livelli, foglie e la sequenza geometrica di nodi rispetto ai disegni del manuale.

Correzione automatica di esami e LMS

Valuti gli item di albero di ricorsione con un oracolo deterministico di nodi totali e altezza invece di accettare stime asintotiche come risposte esatte.

Quanti nodi ha l'albero di ricorsione del merge sort?

Con un input di 16 diviso in due metà a ogni chiamata, ci sono 5 livelli con 1, 2, 4, 8 e 16 nodi. In totale sono 31 nodi, di cui 16 foglie e 15 nodi interni.

Quando smette di crescere l'albero?

Al primo livello in cui la dimensione del sottoproblema scende a 1 o meno. Quel livello contiene i casi base. L'altezza è il numero di livelli meno uno, quindi 5 livelli danno un'altezza di 4.

Che cosa mostrano le due distribuzioni del lavoro?

Una presuppone che ogni nodo costi uguale, quindi la maggior parte del lavoro sta nelle foglie. L'altra presuppone un lavoro proporzionale alla dimensione, come nel merge sort, dove ognuno dei 5 livelli svolge un quinto del lavoro.

E se ogni chiamata crea un solo sottoproblema?

Allora l'albero è una sola catena, lunga quanto il numero di divisioni necessarie a portare la dimensione a 1. Il rapporto di riduzione deve essere sempre maggiore di uno, altrimenti i sottoproblemi non diventerebbero mai più piccoli.

Tutto quello che vedi in questa pagina è disponibile anche via API. Questa sezione è per i team che vogliono integrarlo nei propri sistemi; chi non ne ha bisogno può semplicemente usare lo strumento qui sopra.

POSThttps://api.kit.forhosting.com/dev/recursion-tree-nodes

Autenticazione con Bearer token: un POST mette in coda l'attività e il risultato arriva via webhook o link firmato.

curl -X POST https://api.kit.forhosting.com/dev/recursion-tree-nodes \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"branching_factor":2,"shrink_ratio":2,"input_size":16}'
{
  "branching_factor": 2,
  "shrink_ratio": 2,
  "input_size": 16
}
{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "dev.recursion_tree_nodes",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

L'API è asincrona: ricevi subito un task_id e puoi fare polling fino a 1 richiesta al secondo.

per richiesta$0.002

Prezzo pubblicato, senza token né crediti. Se l'attività fallisce, non paghi.

HTTPCodiceSignificato
401unauthorizedChiave API mancante o non valida: controlla l'header Authorization.
402insufficient_balanceCredito esaurito: ricarica per continuare a eseguire attività.
404unknown_typeTipo di attività sconosciuto: controlla il campo type della richiesta.
429rate_limitedTroppe richieste in poco tempo: rallenta e riprova tra qualche secondo.

Cosa conta un albero di ricorsione e come si definiscono i livelli

Con fattore maggiore di uno la forma chiusa del totale nodi su L livelli è a elevato a L meno uno, il tutto su a meno uno; questo endpoint lo ricalcola sommando la serie geometrica affinché dimensioni frazionarie e casi base precoci restino coerenti con la scansione.

Contratto di ingresso, campi di risposta e viste della ripartizione del lavoro

La stringa recurrence riafferma T di n in termini di a e b, e il campo formula riassume la regola dei livelli e la forma chiusa del totale nodi. Combinazioni patologiche che supererebbero un tetto sicuro di livelli o nodi vengono rifiutate con un messaggio chiaro così i client non restano bloccati su un albero che esplode. Esempio: fattore di ramificazione due, rapporto di riduzione due, dimensione di ingresso sedici produce cinque livelli con conteggi uno, due, quattro, otto, sedici, trentuno nodi totali e sedici foglie — il classico albero di ricorsione binario perfetto del merge sort su un array potenza di due. Invii un corpo JSON con POST con tre numeri finiti obbligatori: branching_factor, intero maggiore o uguale a uno; shrink_ratio, numero finito strettamente maggiore di uno così i sottoproblemi si riducono; e input_size, numero finito almeno uno per la radice. Sono accettate stringhe numeriche; campi mancanti, valori non finiti, fattori di ramificazione non interi o minori di uno, rapporti di riduzione non maggiori di uno e dimensioni di radice sotto uno falliscono con invalid_input e non vengono addebitati. In caso di successo il corpo riecheggia i tre input e riporta level_count, tree_height, total_nodes, leaf_nodes e internal_nodes. L'array nodes_per_level elenca quanti nodi stiano a ogni livello dalla radice in giù. L'array subproblem_size_per_level elenca la dimensione condivisa da ogni nodo di quel livello, arrotondata a dodici decimali per uguaglianza stabile tra runtime. Due array di frazioni paralleli sommano a uno: node_fraction_per_level divide il conteggio nodi di ogni livello per il totale generale, modellando lavoro unitario per chiamata ricorsiva; size_work_fraction_per_level pesa ogni livello per nodi per dimensione del sottoproblema, modellando lavoro non ricorsivo proporzionale alla dimensione in quel nodo.

Dove un'API di nodi dell'albero di ricorsione rende utile il servizio

Poiché l'implementazione è pure parse di tier A, ogni chiamata riuscita costa il prezzo base pubblicato $0.002 senza token di modello e senza rete in uscita.

Visualizzatori di complessità e colloqui

Alimenti nodes_per_level e size_work_fraction_per_level in grafici affinché i candidati vedano come il lavoro si distribuisce tra i livelli per alberi in stile merge sort.

Come si contano i nodi in un albero di ricorsione divide et impera?

Invii branching_factor a intero ≥ 1, shrink_ratio b > 1 e input_size n ≥ 1. L'API percorre i livelli con a^i nodi di dimensione n/b^i fino a size ≤ 1 e restituisce totali più array per livello.

Qual è la differenza tra level_count e tree_height?

level_count è il numero di livelli inclusa la radice (almeno 1). tree_height è level_count meno 1, il numero di archi su un cammino dalla radice a una foglia.

Come si calcola la distribuzione del lavoro?

node_fraction_per_level è il conteggio nodi di ogni livello su total_nodes. size_work_fraction_per_level pesa ogni livello per nodi per dimensione del sottoproblema, allineato al lavoro non ricorsivo Θ(size) per chiamata.

Quando il calcolatore rifiuta l'ingresso?

Campi mancanti o non finiti, branching_factor non intero o minore di uno, shrink_ratio ≤ 1, input_size < 1, o alberi che superano il tetto sicuro di livelli o nodi falliscono con invalid_input e non vengono addebitati.

Quanto costa il calcolatore di nodi dell'albero di ricorsione?

Lo strumento nel browser è gratuito. Le richieste API usano il saldo prepagato KIT a $0.002 per chiamata riuscita; l'ingresso non valido non viene addebitato.

Leggi la documentazione completa del KIT →