Calcolatore degli indici dei figli di un heap binario
Un heap binario memorizza un albero in un array lineare, quindi per passare da un nodo padre ai figli serve un piccolo ma importante calcolo degli indici.
Esegui gratis nel browser
Questo strumento restituisce le posizioni esatte dei figli sinistro e destro del nodo indicato. Lei può scegliere l’indicizzazione da zero, comune nei linguaggi di programmazione, oppure quella da uno, spesso adottata nei manuali e nello pseudocodice. Il risultato è deterministico, immediato e convalidato per escludere radici non valide o operazioni oltre l’intervallo degli interi sicuri di JavaScript.
Scelga lo schema di indicizzazione prima di applicare la formula
Gli heap binari conservano la stessa struttura ad albero indipendentemente dalla numerazione dell’array, ma le formule dei figli dipendono dal punto iniziale. Con l’indicizzazione da zero, la radice occupa l’indice 0. Il figlio sinistro di un nodo all’indice i si trova quindi in 2i + 1, mentre quello destro è in 2i + 2. Con l’indicizzazione da uno, la radice occupa l’indice 1 e le formule diventano 2i per il figlio sinistro e 2i + 1 per il destro. Scelga lo schema impiegato dall’array o dall’algoritmo che sta esaminando: cambiare schema senza modificare l’indice del nodo indica una posizione fisica differente. Lo strumento riporta lo schema scelto e l’indice originale accanto a entrambi i risultati, rendendo esplicita l’interpretazione. Ciò è particolarmente utile quando si confronta il codice sorgente con un manuale, perché molti linguaggi usano array da zero, mentre le spiegazioni didattiche possono riservare la posizione 0 e far iniziare l’heap dalla posizione 1. Verificare prima la convenzione evita un risultato spostato di una posizione che potrebbe comunque apparire plausibile.
Inserisca un indice valido e legga entrambe le posizioni figlie
Indichi la posizione intera del nodo padre e selezioni lo schema di indicizzazione dell’array. Per un heap indicizzato da zero, l’indice del nodo può essere 0 o qualsiasi intero sicuro maggiore. Per un heap indicizzato da uno, deve essere almeno 1, perché la posizione 0 non appartiene a tale convenzione. La risposta fornisce left_child_index e right_child_index come interi utilizzabili direttamente per esaminare un array, costruire una visita o verificare un’implementazione. Questi valori sono posizioni strutturali, non la prova che nelle posizioni esistano davvero degli elementi. Un heap con meno elementi può non avere nessuno dei due figli oppure avere soltanto il figlio sinistro alla fine dell’array. Confronti ogni indice restituito con i limiti dell’array prima di accedervi nel codice. Nell’indicizzazione da zero, un figlio esiste solo se il suo indice è inferiore alla lunghezza dell’array. Nell’indicizzazione da uno, il limite corretto dipende dal fatto che la posizione 0 sia fisicamente riservata; usi quindi la rappresentazione adottata dal Suo programma. Questa distinzione mantiene preciso il calcolo senza presumere la dimensione dell’heap.
Usi il risultato per testare e correggere le operazioni sull’heap
Gli indici dei figli sono fondamentali per la discesa, la costruzione dell’heap, la rimozione da una coda di priorità e la visualizzazione dell’albero. Durante la discesa, un’implementazione calcola entrambe le posizioni, controlla quali figli siano presenti, confronta le priorità memorizzate e scambia il padre con il figlio appropriato quando la proprietà dell’heap viene violata. Una convenzione errata può saltare il vero figlio sinistro, leggere oltre l’array o confrontare elementi non correlati, pur producendo codice dall’aspetto matematicamente ragionevole. Questo strumento offre una verifica indipendente e rapida per esempi, test unitari, esercizi tecnici e revisioni del codice. Provi la radice, un nodo interno e un nodo vicino alla fine dell’heap per coprire i casi più significativi. Il calcolo accetta solo interi sicuri e rifiuta risultati oltre l’intervallo intero esatto, evitando indici arrotondati silenziosamente con input irrealisticamente grandi. Non esegue richieste di rete e non usa valori casuali o dipendenti dall’ora. Il calcolo nel browser e il gestore API condividono la stessa funzione pura, quindi lo stesso input produce lo stesso output in entrambi gli ambienti al costo di $0.002 per richiesta API.
Casi d'uso
Correggere un’operazione di discesa
Verifichi che una coda di priorità esamini le due posizioni corrette dell’array dopo la rimozione della radice.
Trasformare le formule di un manuale in codice
Confronti pseudocodice indicizzato da uno con un linguaggio indicizzato da zero senza introdurre errori di posizione.
Creare casi di test per un heap
Generi le posizioni attese dei figli per radici, nodi interni e casi limite in test deterministici.
Domande frequenti
Quali formule si usano con l’indicizzazione da zero?
Per un nodo all’indice i, il figlio sinistro si trova in 2i + 1 e quello destro in 2i + 2.
Quali formule si usano con l’indicizzazione da uno?
Per un nodo all’indice i, il figlio sinistro si trova in 2i e quello destro in 2i + 1.
Un indice restituito garantisce che il figlio esista?
No. Il risultato fornisce posizioni strutturali. Confronti ogni posizione con i limiti reali dell’array prima di leggere un elemento.
Perché l’indice zero non è valido nella modalità da uno?
Un heap indicizzato da uno colloca la radice alla posizione 1, quindi la posizione 0 non rappresenta un nodo in tale schema.
Quanto costa il calcolo tramite API?
Ogni richiesta API costa $0.002. Lei può anche eseguire lo stesso calcolo deterministico nel browser.
Per sviluppatori — accesso via API
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.
Endpoint
Autenticazione con Bearer token: un POST mette in coda l'attività e il risultato arriva via webhook o link firmato.
Chiamala dal tuo stack
curl -X POST https://api.kit.forhosting.com/dev/heap-children-index \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"node_index":5}'const res = await fetch("https://api.kit.forhosting.com/dev/heap-children-index", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"node_index": 5
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev/heap-children-index",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"node_index": 5
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/heap-children-index", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"node_index":5}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"node_index":5}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/heap-children-index", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Esempio di richiesta
{
"node_index": 5
}Esempio di risposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.heap_children_index",
"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.
Prezzi
Prezzo pubblicato, senza token né crediti. Se l'attività fallisce, non paghi.
Errori
| HTTP | Codice | Significato |
|---|---|---|
401 | unauthorized | Chiave API mancante o non valida: controlla l'header Authorization. |
402 | insufficient_balance | Credito esaurito: ricarica per continuare a eseguire attività. |
404 | unknown_type | Tipo di attività sconosciuto: controlla il campo type della richiesta. |
429 | rate_limited | Troppe richieste in poco tempo: rallenta e riprova tra qualche secondo. |