Contenitori tabella hash
Preveda 1.000 chiavi con un fattore di carico di 0,75 e le servono almeno 1.334 contenitori, arrotondati a 2.048 come potenza di due. Vede anche il carico reale, quante chiavi entrano e il margine che resta. Gratis nel suo browser.
- Gratis
- Funziona nel suo browser
- Senza registrazione
- I suoi dati restano sul dispositivo
Esegui gratis nel browser
Esempio risolto
- Elementi
- 1000
- Fattore di carico
- 0,75
- Arrotondamento
- Power of two
- Minimo di bucket
- 1334
- Bucket
- 2048
- Fattore di carico effettivo
- 0,48828125
- Capacità
- 1536
Una tabella hash è veloce solo se l'array che la sostiene ha la misura giusta. Se Lei memorizza n chiavi in m contenitori, il fattore di carico α = n / m decide quanto si allungano le catene, quando l'indirizzamento aperto si agglomera e con quale frequenza scatta un ridimensionamento. Un m troppo piccolo e ogni ricerca attraversa un mucchio di collisioni. Un m troppo grande e Lei paga RAM per slot vuoti che non migliorano la latenza. Questo calcolatore del numero di contenitori prende il conteggio previsto degli elementi, un fattore di carico obiettivo come il valore predefinito 0.75 di Java HashMap e una strategia di arrotondamento, poi restituisce la tabella assegnabile più piccola che tiene l'occupazione a quel traguardo o sotto. Calcola prima il soffitto grezzo ceil(n / α) e poi arrotonda quel pavimento alla potenza di due successiva o al primo successivo — le due misure che le mappe di produzione assegnano davvero. Le misure potenza di due coincidono con le mappe a maschera che indicizzano con l'AND bit a bit dell'hash e (m meno uno). Le misure prime coincidono con le mappe a modulo che indicizzano con hash mod m.
Perché il fattore di carico, e non un numero tondo, deve scegliere i contenitori
Il fattore di carico è l'unico numero di occupazione che viaggia tra i linguaggi. Java HashMap vale 0.75 per impostazione predefinita e si ridimensiona quando la dimensione supera la capacità per quel fattore. Rust hashbrown e molti porting Swiss-table restano vicino a 0.875 prima di crescere.
Il codice didattico classico a concatenamento separato mira spesso a 0.5 o 1.0. In ogni caso l'identità di pianificazione è la stessa: servono almeno ceil(n / α) slot se n chiavi devono restare al traguardo α o sotto. Quel soffitto grezzo quasi mai è il numero che si assegna.
Le implementazioni a maschera esigono che m sia una potenza di due così l'indice è un solo AND bit a bit, ed è per questo che 1 000 chiavi a 0.75 diventano 2 048 contenitori e non 1 334. Le implementazioni a modulo preferiscono un primo così un hash debole si sparge ancora tra le classi di residui, ed è per questo che le stesse 1 000 chiavi diventano il primo successivo maggiore o uguale a 1 334. Usi insieme quelle cinque cifre.
Una tabella salita di molto fino alla potenza di due successiva ha un carico effettivo comodo e un headroom ampio; una caduta su un primo vicino è più stretta e più prossima a un ridimensionamento. Indovinare 1 024 o 4 096 perché quei numeri sembrano informatica è il modo in cui un servizio spreca una pagina di RAM o subisce un ridimensionamento nel primo minuto di traffico.
Quando dimensionare così una tabella, e i suoi limiti
Usi lo strumento del browser quando sceglie la capacità iniziale di un HashMap, scrive un commento che deve difendere perché l'array è 2 048 e non 1 334, o guida una revisione attraverso la differenza tra una tabella a maschera e una a modulo. Percorra il fattore di carico finché il headroom copre il prossimo picco di crescita, poi tenga l'm arrotondato.
Confronti il risultato con un calcolatore di collisioni attese una volta noto m: quel fratello risponde quante chiavi condividono un contenitore, mentre questa pagina risponde quanti contenitori assegnare per primi. Le due ricerche sono ticket distinti e non devono cannibalizzarsi. I risultati sono pienamente deterministici: gli stessi items, fattore di carico e arrotondamento producono sempre lo stesso vettore, così Lei può fissare esempi in prove e materiali didattici.
Non c'è modello linguistico, né servizio statistico esterno, né casualità.
Casi d'uso
Capacità iniziale di HashMap e dizionario
Indichi la misura prevista dell'insieme di lavoro e 0.75 (o il valore predefinito del Suo ambiente) per ottenere l'array potenza di due che Java, Rust e la maggior parte delle mappe a maschera devono assegnare.
Tabelle a modulo di misura prima
Dimensioni le mappe classiche a concatenamento separato o in stile Hashtable che indicizzano con hash modulo m arrotondando il pavimento di occupazione al primo successivo.
Generatori, revisioni e oracoli di CI
I generatori di codice e le piattaforme di colloquio chiamano un oracolo di dimensionamento deterministico che rifiuta un conteggio elementi assente e restituisce lo stesso campo buckets per gli stessi n e α.
Domande frequenti
Conviene arrotondare il numero di contenitori a una potenza di due o a un primo?
Usi prime per le mappe a modulo come l'Hashtable classico di Java, così un hash debole si sparge ancora tra le classi di residui.
Il calcolatore di contenitori di tabella hash è gratuito?
Lo strumento del browser gira gratis sul Suo dispositivo.
Quale fattore di carico conviene scegliere?
Dipende dalla tabella che userà. L'HashMap di Java usa 0,75 per impostazione predefinita, molte tabelle in stile Swiss table, come hashbrown di Rust, stanno intorno a 0,875, e il codice didattico punta spesso a 0,5 o 1,0. Adatti l'obiettivo alla tabella che conterrà i dati.
Cosa indicano capacità e margine?
La capacità è quante chiavi la tabella arrotondata accoglie prima di superare il carico obiettivo; il margine è la capacità meno le sue chiavi. Con 1.000 chiavi a 0,75 in 2.048 contenitori, la capacità è 1.536 e il margine 536.
Perché il carico reale resta sotto il mio obiettivo?
Perché il numero di contenitori viene arrotondato per eccesso a una dimensione che le tabelle allocano davvero. Passare da 1.334 a 2.048 lascia un carico reale di 0,48828125, ben sotto 0,75, e allontana il prossimo ridimensionamento.
Strumenti correlati
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/hash-table-capacity \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"items":1000,"load_factor":0.75}'const res = await fetch("https://api.kit.forhosting.com/dev/hash-table-capacity", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"items": 1000,
"load_factor": 0.75
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev/hash-table-capacity",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"items": 1000,
"load_factor": 0.75
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/hash-table-capacity", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"items":1000,"load_factor":0.75}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"items":1000,"load_factor":0.75}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/hash-table-capacity", 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
{
"items": 1000,
"load_factor": 0.75
}Esempio di risposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.hash_table_capacity",
"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.
Limiti
max_items | 1000000000 |
min_load_factor | 0.05 |
max_load_factor | 1 |
max_buckets | 34359738368 |
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. |
Note tecniche
Perché il fattore di carico, e non un numero tondo, deve scegliere i contenitori
Questo calcolatore rende esplicita quella decisione in due passi: riporta min_buckets (il pavimento di occupazione), buckets (l'assegnazione arrotondata), actual_load_factor (n / m, sempre al traguardo o sotto dopo l'arrotondamento), capacity (quante chiavi entrano prima di superare il traguardo) e headroom (capacity meno n).
Contratto di ingresso, modi di arrotondamento, formule e errori
Le potenze di due si trovano raddoppiando, non con trucchi a 32 bit, così le misure oltre due alla trentuno restano interi sicuri esatti. I primi si trovano per divisione di prova sui candidati dispari. Invii con POST un corpo JSON con due campi obbligatori e uno facoltativo. items è il conteggio previsto delle chiavi, un intero da uno a un miliardo; si accettano gli alias n, count, expected e keys. load_factor è la α obiettivo, un numero finito da 0.05 a 1 incluso; si accettano gli alias load e alpha. 0.75 è l'esempio e il valore predefinito di Java; 1.0 è una tabella piena; i valori sotto 0.05 vengono rifiutati perché descrivono un array quasi vuoto anziché una mappa di lavoro. rounding è un enum, power_of_two o prime, e vale power_of_two se omesso; si accettano gli alias mode e strategy. Un dominio finito appartiene all'enum così il modulo disegna un elenco a discesa e l'API rifiuta grafie inventate. Dopo la convalida il motore calcola min_buckets = ceil(items / load_factor), corregge un solo passo in virgola mobile se il prodotto restasse sotto n, poi imposta buckets alla potenza di due successiva o al primo successivo maggiore o uguale a quel pavimento. Il JSON ripete items, load_factor e rounding, poi restituisce min_buckets, buckets, actual_load_factor, capacity, headroom, is_power_of_two, is_prime, un campo bits solo sul percorso potenza di due (logaritmo in base due di m) e una stringa formula. Se manca items, il fattore di carico è fuori dall'intervallo pubblicato, il conteggio non è intero o l'arrotondamento è sconosciuto, l'operazione fallisce con invalid_input nominando il campo e non viene fatturata. Questo è un oracolo di dimensionamento, non un conteggio di collisioni attese: lo accoppi a uno strumento di occupazione palline e urne se Le serve anche quante chiavi condivideranno uno slot dopo aver scelto m.
Dove un'API sul numero di contenitori vale il costo, limiti e tariffa
Usi l'API quando un generatore di codice, un ambiente di colloquio, un pianificatore di frammenti di cache o un controllo di integrazione continua ha bisogno di JSON stabile per molte coppie (n, α) sotto un solo contratto. Ogni richiesta riuscita è un articolo fatturabile a $0.002; la convalida fallita non consuma il saldo. Gli intervalli pubblicati tengono ogni conteggio restituito entro interi sicuri IEEE-754 ordinari e coprono ogni mappa in memoria che Lei dimensionerebbe a mano, da un esempio d'aula di otto chiavi a una tabella di internamento da un miliardo di voci. Colleghi l'endpoint a tutorial sulle tabelle hash, a back-end di compilatore che emettono una tabella statica e a modelli di servizio che devono scegliere una capacità prima del primo inserimento.
Domande tecniche
Come si sceglie il numero di contenitori di una tabella hash da n elementi e un fattore di carico?
Invii items (o n) e load_factor (ad esempio 0.75). Il calcolatore restituisce min_buckets = ceil(n/α) e buckets arrotondato alla potenza di due successiva o al primo successivo, più il carico effettivo, capacity e headroom.
Qual è la differenza tra min_buckets e buckets?
min_buckets è il pavimento di occupazione ceil(items / load_factor). buckets è quel pavimento arrotondato a una misura assegnabile. Quindi actual_load_factor = items / buckets resta al traguardo o sotto.
Che succede se manca items o il fattore di carico è fuori intervallo?
La richiesta fallisce con invalid_input nominando il campo. items deve essere un intero da 1 a 1 000 000 000; load_factor deve essere un numero finito da 0.05 a 1. I fallimenti di convalida non vengono fatturati.