Cinq, table de hachage
1. Concept
Une table de hachage est une structure de données avec une relation de mappage, c'est-à-dire que, pour une clé, la valeur correspondante peut être trouvée. KEY et VALUE forment une entrée (ou un nœud)
KEY est unique. Si l'entrée ajoutée ultérieurement est égale à la CLÉ d'une entrée précédente, seule la nouvelle valeur écrasera l'ancienne valeur et une nouvelle entrée ne sera pas créée.
Afin de conserver toutes les entrées, vous pouvez utiliser la structure de tableau. Dans le même temps, afin de réduire l'occupation 连续的内存空间, vous pouvez utiliser la structure de liste à liaison unique pour gérer l'Entrée correspondant à la CLE de la même valeur de hashCode (dans Afin de mieux améliorer les performances, vous pouvez également changer le simple Convertir en liste liée en un arbre binaire, ou restaurer un arbre binaire en une seule liste liée)
2. Méthodes courantes
- put ajoute l'élément à la table de hachage (notez que l'entrée de la clé égale, la nouvelle valeur écrasera l'ancienne valeur)
- get Trouver la valeur correspondante en fonction de la clé donnée
- remove Supprimer l'entrée correspondante selon la CLÉ donnée
3. Exemple
class HashTable<K, V> {
private Entry<K, V>[] table;
private final int length;
private int size;
public HashTable(int length) {
this.length = length;
this.size = 0;
}
public void put(K key, V value) {
if (null == key || null == value) {
throw new NullPointerException();
}
if (null == table) {
@SuppressWarnings("unchecked")
Entry<K, V>[] table = (Entry<K, V>[])new Entry[this.length];
this.table = table;
}
int hash = hash(key);
Entry<K, V> entry = table[hash];
while (null != entry) {
if (entry.key.equals(key)) {
entry.value = value;
return;
}
entry = entry.prev;
}
entry = table[hash];
Entry<K, V> put = new Entry<K, V>(key, value);
table[hash] = put;
put.prev = entry;
this.size++;
}
public V get(K key) {
if (null == key) {
throw new NullPointerException();
}
int hash = hash(key);
Entry<K, V> entry = table[hash];
while (null != entry) {
if (entry.key.equals(key)) {
return entry.value;
}
entry = entry.prev;
}
return null;
}
public boolean remove(K key) {
if (null == key) {
throw new NullPointerException();
}
int hash = hash(key);
Entry<K, V> entry = table[hash];
boolean first = true;
Entry<K, V> next = table[hash];
while (null != entry) {
if (entry.key.equals(key)) {
if (first) {
table[hash] = entry.prev;
} else {
next.prev = entry.prev;
}
this.size--;
return true;
}
entry = entry.prev;
if (first) {
first = false;
} else {
next = next.prev;
}
}
return false;
}
public int size() {
return this.size;
}
private int hash(K key) {
return key.hashCode() % this.length;
}
private static class Entry<K, V> {
private final K key;
private V value;
private Entry<K, V> prev;
private Entry(K key, V value) {
this.key = key;
this.value = value;
}
@Override
public String toString() {
return this.key + "=" + this.value;
}
}
@Override
public String toString() {
if (null == table) {
return "{}";
}
StringBuilder sBuilder = new StringBuilder("{");
for (int i = 0; i < this.length; i++) {
Entry<K, V> entry = table[i];
while (null != entry) {
sBuilder.append(entry.toString()).append(',').append(' ');
entry = entry.prev;
}
}
return sBuilder.substring(0, sBuilder.length() - 2) + '}';
}
}