Hashtabelle-Fächerzahl
Planen Sie 1.000 Schlüssel bei einem Lastfaktor von 0,75, brauchen Sie mindestens 1.334 Fächer, aufgerundet auf 2.048 als Zweierpotenz. Dazu sehen Sie die tatsächliche Last, wie viele Schlüssel passen und den verbleibenden Puffer. Kostenlos in Ihrem Browser.
- Kostenlos
- Läuft in Ihrem Browser
- Ohne Anmeldung
- Ihre Daten bleiben auf Ihrem Gerät
Im Browser ausführen – kostenlos
Rechenbeispiel
- Elemente
- 1.000
- Lastfaktor
- 0,75
- Rundung
- Power of two
- Mindestanzahl Buckets
- 1.334
- Buckets
- 2.048
- Tatsächlicher Lastfaktor
- 0,48828125
- Kapazität
- 1.536
Eine Hashtabelle ist nur so schnell wie das Array dahinter gut bemessen ist. Speichern Sie n Schlüssel in m Fächern, entscheidet der Auslastungsfaktor α = n / m, wie lang Ketten wachsen, wann offenes Adressieren klumpt und wie oft eine Vergrößerung zündet. Wählen Sie m zu klein, läuft jede Suche durch einen Haufen Kollisionen. Wählen Sie m viel zu groß, zahlen Sie RAM für leere Plätze, die der Latenz nicht helfen. Dieser Rechner für die Fächerzahl einer Hashtabelle nimmt die erwartete Elementzahl, einen Ziel-Auslastungsfaktor wie den Java-HashMap-Standard 0.75 und eine Rundungsstrategie und liefert die kleinste zuweisbare Tabelle, die die Belegung bei oder unter diesem Ziel hält. Zuerst berechnet er die rohe Decke ceil(n / α) und rundet diese Untergrenze auf die nächste Zweierpotenz oder die nächste Primzahl — die zwei Größen, die Produktionsmaps tatsächlich anlegen. Zweierpotenzgrößen passen zu maskenbasierten Maps, die mit dem bitweisen UND des Hashs und (m minus eins) indizieren. Primzahlen passen zu modulobasierten Maps, die mit hash mod m indizieren.
Warum der Auslastungsfaktor, nicht eine runde Schätzung, die Fächerzahl bestimmen soll
Der Auslastungsfaktor ist die einzige Belegungszahl, die zwischen Sprachen wandert. Java HashMap steht standardmäßig bei 0.75 und vergrößert, wenn die Größe die Kapazität mal diesen Faktor übersteigt. Rust hashbrown und viele Swiss-table-Portierungen liegen nahe 0.875, bevor sie wachsen.
Klassischer Lehrcode mit getrennter Verkettung zielt oft auf 0.5 oder 1.0. In jedem Fall gilt dieselbe Planungsidentität: Sie brauchen mindestens ceil(n / α) Plätze, wenn n Schlüssel bei oder unter dem Ziel α bleiben sollen. Diese rohe Decke ist fast nie die Zahl, die Sie zuweisen.
Maskenbasierte Implementierungen verlangen, dass m eine Zweierpotenz ist, damit der Index ein einziges bitweises UND ist; deshalb werden aus 1 000 Schlüsseln bei 0.75 genau 2 048 Fächer statt 1 334. Modulobasierte Implementierungen bevorzugen eine Primzahl, damit ein schwacher Hash sich weiter über Restklassen verteilt; deshalb werden dieselben 1 000 Schlüssel zur nächsten Primzahl bei oder über 1 334. Nutzen Sie diese fünf Kennzahlen gemeinsam.
Eine Tabelle, die weit zur nächsten Zweierpotenz hochgerundet hat, hat eine bequeme tatsächliche Last und großen headroom; eine, die auf einer nahen Primzahl landete, sitzt enger und näher an einer Vergrößerung. 1 024 oder 4 096 zu raten, weil diese Zahlen nach Informatik aussehen, ist der Weg, auf dem Dienste entweder eine RAM-Seite verschwenden oder in der ersten Verkehrsminute eine Vergrößerung auslösen.
Wann sich diese Dimensionierung lohnt, und ihre Grenzen
Nutzen Sie das Browser-Werkzeug, wenn Sie die Anfangskapazität einer HashMap wählen, einen Kommentar schreiben, der begründen muss, warum das Array 2 048 und nicht 1 334 ist, oder eine Prüfung durch den Unterschied zwischen Maskentabelle und Modulo-Tabelle führen. Streichen Sie den Auslastungsfaktor, bis der headroom die nächste Wachstumsspitze deckt, und behalten Sie das gerundete m. Stellen Sie das Ergebnis einem Rechner für erwartete Kollisionen gegenüber, sobald m bekannt ist: jener Geschwister beantwortet, wie viele Schlüssel ein Fach teilen, während diese Seite beantwortet, wie viele Fächer Sie zuerst zuweisen.
Die zwei Suchen sind verschiedene Tickets und dürfen einander nicht kannibalisieren. Die Ergebnisse sind vollständig deterministisch: dieselben items, Lastfaktor und Rundung ergeben stets denselben Vektor, sodass Sie Beispiele in Tests und Unterrichtsmaterial festnageln können. Es gibt kein Sprachmodell, keinen externen Statistikdienst und keine Zufälligkeit.
Verdrahten Sie den Endpunkt in Hashtabellen-Tutorien, Compiler-Backends, die eine statische Tabelle ausgeben, und Dienstvorlagen, die eine Kapazität vor dem ersten Einfügen wählen müssen.
Anwendungsfälle
Anfängliche HashMap- und Wörterbuchkapazität
Geben Sie die erwartete Arbeitsmenggröße und 0.75 (oder den Standard Ihrer Laufzeit) ein, um das Zweierpotenz-Array zu erhalten, das Java, Rust und die meisten maskenbasierten Maps anlegen sollen.
Primzahlgroße Modulo-Tabellen
Bemessen Sie klassische Tabellen mit getrennter Verkettung oder im Hashtable-Stil, die mit Hash modulo m indizieren, indem Sie die Belegungsuntergrenze auf die nächste Primzahl runden.
Generatoren, Prüfungen und CI-Orakel
Codegeneratoren und Interviewplattformen rufen ein deterministisches Dimensionierungsorakel auf, das eine fehlende Elementzahl ablehnt und dasselbe buckets-Feld für dieselben n und α zurückgibt.
Häufige Fragen
Soll man die Fächerzahl auf eine Zweierpotenz oder auf eine Primzahl runden?
Nutzen Sie prime für modulobasierte Maps wie die klassische Java Hashtable, damit ein schwacher Hash sich weiter über Restklassen verteilt.
Welchen Lastfaktor sollte ich wählen?
Das hängt von der verwendeten Tabelle ab. Javas HashMap nutzt standardmäßig 0,75, viele Swiss-Table-Bauarten wie hashbrown in Rust liegen bei etwa 0,875, und Lehrcode zielt oft auf 0,5 oder 1,0. Richten Sie das Ziel nach der Tabelle, die die Daten aufnimmt.
Was bedeuten Kapazität und Puffer?
Die Kapazität ist die Zahl der Schlüssel, die die gerundete Tabelle fasst, bevor die Ziellast überschritten wird; der Puffer ist die Kapazität minus Ihre Schlüssel. Bei 1.000 Schlüsseln mit 0,75 in 2.048 Fächern sind das 1.536 und 536.
Welche Werte kann ich eingeben?
Von 1 bis zu einer Milliarde Schlüssel und einen Lastfaktor von 0,05 bis 1. Werte unter 0,05 werden abgelehnt, weil sie ein fast leeres Feld statt einer arbeitenden Tabelle beschreiben.
Warum liegt die tatsächliche Last unter meinem Ziel?
Weil die Fächerzahl auf eine Größe aufgerundet wird, die Tabellen wirklich anlegen. Der Sprung von 1.334 auf 2.048 ergibt eine tatsächliche Last von 0,48828125, deutlich unter 0,75, und schiebt die nächste Vergrößerung hinaus.
Verwandte Tools
Für Entwickler — API-Zugang
Alles auf dieser Seite ist auch per API verfügbar. Dieser Abschnitt richtet sich an Teams, die es in ihre eigenen Systeme einbinden möchten; alle anderen nutzen einfach das Tool oben.
Endpunkt
Authentifizierung per Bearer-Token. Ein einziger POST stellt die Aufgabe in die Warteschlange; das Ergebnis erhalten Sie per Webhook oder über einen signierten Link.
Aufruf aus Ihrem 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)Beispiel-Anfrage
{
"items": 1000,
"load_factor": 0.75
}Beispiel-Antwort
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.hash_table_capacity",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}Die API arbeitet asynchron: Sie erhalten sofort eine task_id. Polling ist mit 1 Anfrage pro Sekunde erlaubt.
Preis
Der Preis steht auf der Seite – keine Tokens, keine Credits. Fehlgeschlagene Aufgaben werden nicht berechnet.
Limits
max_items | 1000000000 |
min_load_factor | 0.05 |
max_load_factor | 1 |
max_buckets | 34359738368 |
Fehler
| HTTP | Code | Bedeutung |
|---|---|---|
401 | unauthorized | Der API-Schlüssel fehlt oder ist ungültig – prüfen Sie den Authorization-Header (Bearer). |
402 | insufficient_balance | Ihr Guthaben reicht für diese Aufgabe nicht aus – Aufladungen verfallen nicht. |
404 | unknown_type | Unbekannter Aufgabentyp – prüfen Sie das Feld „type“ gegen den Katalog. |
429 | rate_limited | Zu viele Anfragen – warten Sie kurz; Polling ist mit 1 Anfrage pro Sekunde erlaubt. |
Technische Hinweise
Warum der Auslastungsfaktor, nicht eine runde Schätzung, die Fächerzahl bestimmen soll
Dieser Rechner macht diese Zweistufenentscheidung ausdrücklich: er meldet min_buckets (die Belegungsuntergrenze), buckets (die gerundete Zuweisung), actual_load_factor (n / m, nach der Rundung stets beim Ziel oder darunter), capacity (wie viele Schlüssel passen, bevor das Ziel überschritten wird) und headroom (capacity minus n).
Eingabevertrag, Rundungsarten, Formeln und Fehlerverhalten
Zweierpotenzen findet sie durch Verdoppeln, nicht durch 32-Bit-Tricks, sodass Größen über zwei hoch einunddreißig genaue sichere Ganzzahlen bleiben. Primzahlen findet sie durch Probedivision ungerader Kandidaten. Senden Sie per POST einen JSON-Körper mit zwei Pflichtfeldern und einem optionalen. items ist die erwartete Schlüsselzahl, eine ganze Zahl von eins bis eine Milliarde; die Aliasse n, count, expected und keys werden akzeptiert. load_factor ist die Ziel-α, eine endliche Zahl von 0.05 bis 1 einschließlich; die Aliasse load und alpha werden akzeptiert. 0.75 ist das Beispiel und der Java-Standard; 1.0 ist eine volle Tabelle; Werte unter 0.05 werden abgelehnt, weil sie ein fast leeres Array beschreiben, keine Arbeitsmap. rounding ist eine Aufzählung, power_of_two oder prime, und gilt als power_of_two, wenn sie fehlt; die Aliasse mode und strategy werden akzeptiert. Ein endlicher Wertebereich gehört in die Aufzählung, damit das Formular eine Auswahlliste zeichnet und die API erfundene Schreibweisen ablehnt. Nach der Prüfung berechnet die Engine min_buckets = ceil(items / load_factor), korrigiert einen einzelnen Gleitkommaschritt, falls das Produkt noch unter n läge, und setzt buckets auf die nächste Zweierpotenz oder die nächste Primzahl bei oder über dieser Untergrenze. Das JSON wiederholt items, load_factor und rounding und liefert dann min_buckets, buckets, actual_load_factor, capacity, headroom, is_power_of_two, is_prime, ein bits-Feld nur auf dem Zweierpotenzpfad (Logarithmus zur Basis zwei von m) und eine formula-Zeichenkette. Fehlende items, ein Lastfaktor außerhalb des veröffentlichten Bereichs, eine nicht ganze Elementzahl oder ein unbekannter Rundungswert scheitern mit invalid_input unter Nennung des Feldes und werden nicht berechnet. Dies ist ein Dimensionierungsorakel, keine erwartete Kollisionszahl: koppeln Sie es mit einem Kugeln-in-Urnen-Belegungswerkzeug, wenn Sie auch wissen müssen, wie viele Schlüssel sich einen Platz teilen, nachdem Sie m gewählt haben.
Wo eine Fächerzahl-API ihren Preis wert ist, Grenzen und Tarif
Nutzen Sie die API, wenn ein Codegenerator, eine Interviewumgebung, ein Cache-Fragmentplaner oder eine Dauerintegrationsprüfung stabiles JSON für viele Paare (n, α) unter einem Vertrag braucht. Jede erfolgreiche Anfrage ist ein abrechenbarer Posten zu $0.002; eine fehlgeschlagene Prüfung wird nicht berechnet. Die veröffentlichten Bereiche halten jede zurückgegebene Zahl in gewöhnlichen sicheren IEEE-754-Ganzzahlen und decken jede In-Memory-Map, die Sie von Hand bemessen würden, vom Unterrichtsbeispiel mit acht Schlüsseln bis zur internierenden Tabelle mit einer Milliarde Einträgen.
Technische Fragen
Wie wählt man die Fächerzahl einer Hashtabelle aus n Elementen und einem Auslastungsfaktor?
Senden Sie items (oder n) und load_factor (zum Beispiel 0.75). Der Rechner liefert min_buckets = ceil(n/α) und buckets, aufgerundet auf die nächste Zweierpotenz oder die nächste Primzahl, dazu die tatsächliche Last, capacity und headroom.
Worin unterscheiden sich min_buckets und buckets?
min_buckets ist die Belegungsuntergrenze ceil(items / load_factor). buckets ist diese Untergrenze, aufgerundet auf eine zuweisbare Größe. Daher liegt actual_load_factor = items / buckets beim Ziel oder darunter.
Was geschieht, wenn items fehlt oder der Auslastungsfaktor außerhalb des Bereichs liegt?
Die Anfrage scheitert mit invalid_input unter Nennung des Feldes. items muss eine ganze Zahl von 1 bis 1 000 000 000 sein; load_factor muss eine endliche Zahl von 0.05 bis 1 sein. Prüfversagen wird nicht berechnet.
Ist der Rechner für die Fächerzahl einer Hashtabelle kostenlos?
Das Browser-Werkzeug läuft kostenlos auf Ihrem Gerät. API-Aufrufe nutzen vorausbezahltes KIT-Guthaben zu $0.002 je erfolgreichem Posten; Prüfversagen wird nicht berechnet.