Hash Table is a data structure to map key to values (also called Table or Map Abstract Data Type/ADT). It uses a hash function to map large or even non-integer keys into a small range of integer indices (typically [0..hash_table_size-1]).
The probability of two distinct keys colliding into the same index is relatively high and each of this potential collision needs to be resolved to maintain data integrity.
There are several collision resolution strategies that will be highlighted in this visualization: Open Addressing (Linear Probing, Quadratic Probing, and Double Hashing) and Closed Addressing (Separate Chaining). Try clicking for a sample animation of searching a specific value 7 in a randomly created Hash Table using Separate Chaining technique (duplicates are allowed).
Hashing is an algorithm (via a hash function) that maps large data sets of variable length, called keys, not necessarily integers, into smaller integer data sets of a fixed length.
A Hash Table is a data structure that uses a hash function to efficiently map keys to values (Table or Map ADT), for efficient search/retrieval, insertion, and/or removals.
Hash Table is widely used in many kinds of computer software, particularly for associative arrays, database indexing, caches, and sets.
In this e-Lecture, we will digress to Table ADT, the basic ideas of Hashing, the discussion of Hash Functions before going into the details of Hash Table data structure itself.
Sebuah ADT Tabel harus mendukung setidaknya tiga operasi dibawah ini dengan seefisien mungkin:
Tabel Hash adalah salah satu pilihan implementasi until ADT Tabel ini (pilihan yang lain adalah ini).
PS1: Untuk dua implementasi yang lebih lemah dari ADT Tabel, anda bisa meng-klik link berikut: array tidak beratur atau array teratur untuk membaca diskusi lebih dalam.
PS2: Dalam kelas langsung, anda mungkin mau membandingkan persyaratan-persyaratan dari ADT Table versus ADT List.
When the range of the integer keys is small, e.g., [0..M-1], we can use an initially empty (Boolean) array A of size M and implement the following Table ADT operations directly:
That's it, we use the small integer key itself to determine the address in array A, hence the name Direct Addressing. It is clear that all three major Table ADT operations are O(1).
PS: This idea is also used elsewhere, e.g., in Counting Sort.
In Singapore (as of Mar 2026), bus routes are numbered from [2..993].
Not all integers between [2..993] are currently used, e.g., there is no bus route 989 — Search(989) should return false. A new bus route x may be introduced, i.e., Insert(x) or an existing bus route y may be discontinued, i.e., Remove(y).
As the range of possible bus routes is small, to record the data whether a bus route number exists or not, we can use a DAT of Boolean array of size 1000 (generally, it is useful to give a few extra buffer cells on top of the current largest bus number of 993).
PS: The closest prime number to 1000 is 997 - but using prime table size is not important for DAT.
Sadari bahwa kita dapat selalu menambahkan data satelit daripada hanya menggunakan larik Boolean untuk menyimpan eksistensi dari kunci-kunci.
Contohnya, kita dapat menggunakan larik String asosiatif A untuk memetakan nomor rute bus ke nama operatornya, misalkan:,
A[2] = "Go-Ahead Singapore",
A[10] = "SBS Transit",
A[183] = "Tower Transit Singapore",
A[188] = "SMRT Buses", etc.
Diskusi: Dapatkah anda memikirkan beberapa contoh-contoh DAT di kehidupan nyata?
The keys must be (or can be easily mapped to) non-negative integer values. Note that basic DAT has problem in the full version of the example in the previous few slides as there are actually variations of bus route numbers in Singapore, e.g., 96B, 151A, NR10, etc.
The range of keys must be small.
The memory usage will be (insanely) large if we have (insanely) large range.
The keys must be dense, i.e., not many gaps in the key values.
DAT will contain too many empty (and wasted) cells otherwise.
We will overcome these restrictions with hashing.
Using hashing, we can:
Contohnya, kita mempunyai N = 400 nomor-nomor telepon Singapura (nomor telepon Singapura memiliki 8 digit, jadi ada maksimum 10^8 = 100M nomor-nomor telepon yang memungkinkan di Singapura).
Daripada menggunakan sebuah DAT dan menggunakan larik raksasa berukuran M = 100 Juta, kita bisa menggunakan fungsi hash sederhana berikut ini h(v) = v%997.
Dengan ini, kita memetakan nomor-nomor telepon 8 digit 6675 2378 dan 6874 4483 masing-masing menjadi hanya 3 digit h(6675 2378) = 237 dan h(6874 4483) = 336. Oleh karena itu, kita hanya perlu mempersiapkan larik dengan ukuran M = 997 (997 adalah bilangan prima) daripada M = 100 Juta.
With hashing, we can now implement the following Table ADT operations using integer array (instead of Boolean array) as follows:
If we have keys that map to satellite data and we want to record the original keys too, we can implement the Hash Table using pair of (integer, satellite-data-type) array as follows:
However, by now you should notice that something is incomplete...
A hash function may, and quite likely, map different keys (integer or not) into the same integer slot, i.e., a many-to-one mapping instead of one-to-one mapping.
For example, h(6675 2378) = 237 from three slides earlier and if we want to insert another phone number 6675 4372, we will have a problem as h(6675 4372) = 237 too.
This situation is called a collision, i.e., two (or more) keys have the same hash value.
Paradoks Ulang Tahun (von Mises) menanyakan hal ini: 'Berapa banyak orang (jumlah kunci-kunci) harus berada di sebuah ruangan (Tabel Hash) dengan ukuran 365 kursi-kursi (sel-sel) sebelum kemungkinan bahwa beberapa orang memiliki hari ulang tahun yang sama (tabrakan (collision), dua kunci ter-hash ke sel yang sama), mengabaikan tahun-tahun kabisat (yaitu semua tahun memiliki 365 hari), menjadi > 50 persen (yaitu lebih mungkin terjadi daripada tidak)?'
Jawabannya, yang mungkin mengejutkan bagi sebagian dari kita, adalah .
Mari melakukan beberapa kalkulasi.
Let Q(n) be the probability of unique birthday for n people in a room.
Q(n) = 365/365 × 364/365 × 363/365 × ... × (365-n+1)/365,
i.e., the first person's birthday can be any of the 365 days, the second person's birthday can be any of the 365 days except the first person's birthday, and so on.
Let P(n) be the probability of same birthday (collision) for n people in a room.
P(n) = 1-Q(n).
We compute that P(23) = 0.507 > 0.5 (50%).
Thus, we only need 23 people (a small amount of keys) in the room (Hash Table) of size 365 seats (cells) for a (more than) 50% chance collision to happen (the birthday of two different people in that room is one of 365 days/slots).
A good heuristic: we only need sqrt(n) keys in a hash Table of n cells to have more than 50% chance of collision [derivation omitted, but it is based on this birthday paradox].
Issue 1: We have seen a simple hash function like the h(v) = v%997 used in Phone Numbers example that maps large range of integer keys into a smaller range of integer keys, but how about non integer keys? How to do such hashing efficiently?
Issue 2: We have seen that by hashing, or mapping, large range into smaller range, there will very likely be a collision. How to deal with them?
Bagaimana caranya untuk menciptakan sebuah fungsi hash yang baik dengan properti yang diinginkan berikut ini?
Suppose we have a hash table of size M where keys are used to identify the satellite-data and a specific hash function is used to compute a hash value.
A hash value/hash code of key v is computed from the key v with the use of a hash function to get an integer in the range 0 to M-1. This hash value is used as the base/home index/address of the Hash Table entry for the satellite-data.
Di contoh Nomor-nomor Telepon, jika kita mendefinisikan h(v) = floor(v/1 000 000), yaitu kita memilih dua digit pertama dari sebuah nomor telepon.
h(66 75 2378) = 66
h(68 74 4483) = 68
Diskusi: Apa yang terjadi jika anda menggunakan fungsi hash seperti itu? Petunjuk: Lihat ini.
Sebelum mendiskusikan kenyataan, mari mendiskusikan kasus ideal: fungsi-fungsi hash sempurna.
Sebuah fungsi hash sempurna adalah pemetaan satu-ke-satu antara kunci-kunci dan nilai-nilai hash, yaitu tidak ada tabrakan sama sekali. Hal ini memungkinkan jika semua kunci-kunci diketahui sebelumnya. Contohnya, sebuah pencarian compiler/interpreter untuk kata-kata kunci reserved. Tetapi, kasus-kasus seperti ini jarang.
Fungsi hash sempurna yang paling minim terpenuhi ketika ukuran tabel sama dengan jumlah kata-kata kunci yang disediakan. Kasus ini lebih jarang lagi.
Jika anda tertarik, anda bisa mengeksplorasi GNU gperf, sebuah generator fungsi hash sempurna yang tersedia secara gratis yang ditulis dalam bahasa C++ yang secara otomatis membuat fungsi-fungsi sempurna (sebuah program C++) dari daftar kata-kata kunci yang disuplai oleh pengguna.
People has tried various ways to hash a large range of integers into a smaller range of integers as uniformly as possible. In this e-Lecture, we jump directly to one of the best and most popular version: h(v) = v%M, i.e., map v into Hash Table of size M slots. The (%) is a modulo operator that gives the remainder after division. This is clearly fast, i.e., O(1) assuming that v does not exceed the natural integer data type limit.
The Hash Table size M is set to be a reasonably large prime not near a power of 2, about 2+ times larger than the expected number of keys N that will ever be used in the Hash Table. This way, the load factor α = N/M < 0.5 — we shall see later that having low load factor, thereby sacrificing empty spaces, help improving Hash Table performance.
Discuss: What if we set M to be a power of 10 (decimal) or power of 2 (binary)?
People has also tried various ways to hash Strings into a small range of integers as uniformly as possible. In this e-Lecture, we jump directly to one of the best and most popular version, shown below:
int hash_function(string v) { // note 1: v uses ['A'..'Z'] only
int sum = 0; // note 2: v is a short string
for (auto& c : v) // for each character c in v
sum = ((sum*26)%M + (c-'A'+1))%M; // M is table size
return sum;
}Interactive (M = ∞), i.e., the modulo operation has no effect
v = , = 0.
Discussion: In real life class, discuss the components of the hash function above, e.g., why loop through all characters?, will that be slower than O(1)?, why multiply with 26?, what if the string v uses more than just UPPERCASE chars?, etc.
Ada dua ide-ide utama: Metode Pengalamatan Terbuka (Open Addressing) dibandingkan dengan Pengalamatan Tertutup (Closed Addressing).
Dalam Closed Addressing, Table Hash nya terlihat seperti Daftar Adjacency (Adjacency List) (sebuah struktur data graf). Kode hash dari sebuah kunci memberikan alamat dasar yang tetap/tertutup (closed). Tabrakan (Collision) diselesaikan dengan menambahkan kunci-kunci yang bertabrakan tersebut didalam sebuah struktur data (yang biasanya merupakan sebuah ADT Daftar) yang diidentifikasikan oleh alamat dasarnya.
Dalam Open Addressing, semua kunci-kunci yang di-hash terletak di sebuah larik tunggal. Kode hash dari sebuah kunci adalah alamat dasarnya. Tabrakan (Collision) diselesaikan dengan mengecek/menyelidiki (probing) berbagai alamat-alamat alternatif (sehingga dinamai terbuka (open)) di dalam tabel berdasarkan aturan tertentu.
Separate Chaining (SC) collision resolution technique is simple. We use M copies of auxiliary data structures, usually Doubly Linked Lists (PS: simpler auxiliary data structures exist). If two keys a and b both have the same hash value i, both will be appended to the (front/back) of Doubly Linked List i (in this visualization, we append to the back in O(1) with help of tail pointer). That's it, where the keys will be slotted in is completely dependent on the hash function itself, hence we also call Separate Chaining as Closed Addressing collision resolution technique.
If we use Separate Chaining, the load factor α = N/M is the average length of the M lists (unlike in Open Addressing, α can be "slightly over 1.0") and it will determine the performance of Search(v) as we may have to explore α elements on average. As Remove(v) also requires Search(v), its performance is similar as Search(v). Insert(v) is clearly O(1).
If we can bound α to be a small constant (true if we know the expected largest N in our Hash Table application so that we can set up M accordingly), then all Search(v), Insert(v), and Remove(v) operations using Separate Chaining will be O(1).
Ada tiga teknik-teknik resolusi tabrakan Open Addressing (OA) yang dibahas di visualisasi ini: Linear Probing (LP), Quadratic Probing (QP), dan Double Hashing (DH).
Untuk berpindah diantara ketiga mode, silahkan klik tajuk (header) yang bersangkutan.
Biarlah:
M = HT.length = ukuran sekarang dari tabel hash,
base = (key%HT.length),
step = langkah probing sekarang,
secondary = smaller_prime - key%smaller_prime (untuk menghindari angka nol — akan dibahas segera)
Kita akan segera melihat bahwa urutan-urutan penyelidikan (probing) di ketiga mode adalah:
Linear Probing: i=(base+step*1) % M,
Quadratic Probing: i=(base+step*step) % M, dan
Double Hashing: i=(base+step*secondary) % M.
Ketiga teknik OA memerlukan faktor beban α = N/M < 1.0 (jika tidak, insertion lebih lanjut tidak mungkin dilakukan). Jika kita dapat membatasi α menjadi konstanta kecil (benar jika kita mengetahui N terbesar yang diharapkan dalam aplikasi Tabel Hash kita sehingga kita dapat mengatur M sesuai, sebaiknya < 0.5 untuk sebagian besar varian OA), maka semua operasi Cari(v), Masukkan(v), dan Hapus(v) menggunakan Open Addressing akan menjadi O(1) — detail dihilangkan.
Lihatlah visualisasi Table Hash Table diatas.
Dalam visualisasi ini, kami memperbolehkan pemasukkan dari kunci-kunci duplikat (multiset). Karena sebuah multiset lebih general dari sebuah set, masukkan bilangan-bilangan berbeda dalam visualisasi ini jika anda ingin melihat bagaimana Tabel Hash bekerja untuk kunci bilangan berbeda saja.
Dikarenakan ruangan terbatas pada layar, kami merubah dari skala default (1.0x) menjadi 0.5x setiap kali anda ingin mengvisualisasi Tabel Hash M ∈ [46..90] untuk teknik Open Addressing. Limitnya lebih rendah untuk teknik Separate Chaining, yakni untuk M ∈ [20..31].
Table Hash divisualisasikan secara horisontal seperti sebuah larik dimana indeks 0 ditaruh di sisi paling kiri dan indeks M-1 ditaruh di sisi paling kanan tetapi detil-detilnya berbeda ketika kita memvisualisasikan teknik resolusi tabrakan (collision resolution) tipe Open Addressing (hanya baris teratas) dibandingkan dengan Separate Chaining (merentang berbagai baris).
Untuk teknik resolusi tabrakan Separate Chaining (SC), baris pertama berisikan M penunjuk-penunjuk "H" (Head/kepala) dari M Senarai Berantai Ganda.
Lalu, setiap Senarai Berantai Ganda i berisikan semua kunci-kunci yang semuanya ter-hash ke i dalam urutan apapun (dalam skala 0.5x, label simpul ditunjukkan di atas sebuah titik hitam kecil). Secara matematis, semua kunci-kunci yang bisa diekspresikan sebagai i (mod M) — termasuk semua duplikat i — ter-hash ke DLL i. Lagi-lagi, kami tidak menaruh data satelit di visualisasi ini.
Ada tiga teknik-teknik resolusi tabrakan Pengalamatan Terbuka (Open Addressing) yang dibahas di visualisasi ini: Linear Probing (LP), Quadratic Probing (QP), dan Double Hashing (DH).
Untuk ketiga teknik-teknik tersebut, setiap sel Tabel Hash ditampilkan sebagai sebuah simpul dengan nilai sel [0..99] yang ditampilkan sebagai label simpul (dalam skala 0.5x, label simpul ditunjukkan di atas sebuah titik hitam kecil). Tanpa kehilangan makna umum, kami tidak menunjukkan data satelit apapun dalam visualisasi ini karena kami mengkonsentrasikan hanya kepada pengaturan kunci-kunci. Kami mencadangkan nilai -1 untuk mengindikasikan 'sel KOSONG' (divisualisasikan sebagai simpul kosong) dan -2 untuk mengindikasikan 'sel TERHAPUS' (divisualisasikan sebagai sebuah simpul dengan label singkatan "DEL"). Indeks-indeks sel berkisar antara [0..M-1] ditunjukkan sebagai label merah dibawah setiap simpul (baris dengan 15 indeks di skala 1.0x atau baris dengan 25 indeks di skala 0.5x).
Try to see how Insert(v) operation works if we use Separate Chaining as collision resolution technique. On such random insertions, the performance is good and each insertion is clearly O(1).
However if we try , notice that all integers {68,90} are 2 (modulo 11) so all of them will be appended into the (back of) Doubly Linked List 2. We will have a long chain in that list. Note that due to the screen limitation, we limit the length of each Doubly Linked List to be at maximum 6.
Coba untuk melihat bahwa Cari(v) bisa dibuat berjalan dalam O(1+α).
Coba untuk melihat bahwa Hapus(v) bisa dibuat berjalan dalam O(1+α) juga.
Jika α besar, performa Separate Chaining tidak benar-benar O(1). Tetapi, jika kita secara kasar mengetahui potensial jumlah terbesar dari kunci-kunci N yang aplikasi kita akan pernah gunakan, maka kita bisa mengeset ukuran tabel M seperlunya supaya α = N/M adalah angka positif (floating-point) yang sangat rendah, dengan demikian membuat performa Separate Chaining diharapkan O(1).
Dalam teknik resolusi tabrakan Linear Probing, kita menelusuri kedepan satu indeks setiap saat untuk slot kosong/terhapus berikutnya (kembali kedepan ketika kita telah mencapai slot terakhir) bilamana terjadi tabrakan.
Contohnya, mari asumsikan bahwa kita memulai dengan Tabel Hash kosong HT dengan ukuran tabel M = HT.length = 7 seperti yang ditunjukkan diatas yang menggunakan indeks 0 ke M-1 = 7-1 = 6. Sadri bahwa 7 adalah bilangan prima. Fungsi hash (primer) sederhana saja, h(v) = v%M.
Walk-through ini akan menunjukkan anda langkah-langkah yang diambil oleh operasi-operasi Masukkan(v), Cari(v), dan Hapus(v) ketika menggunakan Linear Probing sebagai teknik resolusi tabrakan.
Now click — three individual insertions in one command.
Recap (to be shown after you click the button above).
Formally, we describe Linear Probing index i as i = (base+step*1) % M where base is the (primary) hash value of key v, i.e., h(v) and step is the Linear Probing step starting from 1.
Tips: To do a quick mental calculation of a (small) integer V modulo M, we simply subtract V with the largest multiple of M ≤ V, e.g., 18%7 = 18-14 = 4, as 14 is the largest multiple of 7 that is ≤ 18.
Sekarang klik (selain dari tiga nilai-nilai pertama yang sudah dimasukkan di slide sebelumnya).
Rekap (akan ditunjukkan setelah anda mengklik tombol diatas)
Sekarang kita mengilustrasikan operasi Cari(v) dimana kita menggunakan Linear Probing sebagai teknik resolusi tabrakan. Langkah-langkah yang diambil sangat mirip dengan operasi Masukkan(v), yaitu kita mulai dari nilai hash kunci (primer) dan mengecek jika kita telah menemukan v, kalau tidak kita maju satu indeks kedepan satu per satu (kembali ke depan jika perlu) dan mengecek ulang apakah kita telah menemukan v. Kita berhenti ketika kita menjumpai sel kosong yang berarti v tidak berada dalam Tabel Hash sama sekali (karena operasi Masukkan(v) sebelumnya harusnya sudah menaruh v disana kalau tidak).
Sekarang klik — anda harus melihat urutan penyelidikan (probing) [0,1,2,3 (kunci 35 ditemukan)].
Sekarang klik — [1,2,3,4, 5 (sel kosong, jadi kunci 8 tidak ditemukan di Tabel Hash)].
Sekarang mari diskusikan operasi Hapus(v).
Jika kita baru saja mengeset sel HT[i] = KOSONG langsung dimana i adalah indeks yang mengandung v (setelah probing linear jika diperlukan), apakah anda menyadari bahwa kita akan menyebabkan sebuah masalah? Kenapa?
Petunjuk: Ulas tiga slide-slide terakhir tentang bagaimana Masukkan(v) dan Cari(v) bekerja.
Sekarang mari lihat Hapus(v) yang lengkap. Jika kita menemukan v pada indeks i (setelah Linear Probing jika diperlukan), kita harus mengeset HT[i] = TERHAPUS (disingkat sebagai DEL dalam visualisasi ini) dimana DEL adalah simbol spesial (secara umum anda harus hanya menggunakan simbol yang tidak dipakai di aplikasi anda) untuk mengindikasikan bahwa sel tersebut bisa di-lewati jika perlu oleh Cari(v) di masa mendatang, tetapi bisa ditimpa oleh Masukkan(w) di masa mendatang. Strategi ini desebut sebagai Penghapusan Malas (Lazy Deletion).
Sekarang klik — [0,1 (kunci 21 ditemukan dan kita set H[1] = DEL)].
Setelah itu, silahkan lanjutkan diskusi di slide berikuktnya.
Sekarang klik — [0,1 (melewati sel yang TERHAPUS), 2,3 (menemukan kunci 35)].
Bayangkan apa yang akan terjadi jika kita salah mengeset H[1] = KOSONG.
Sekarang klik — anda harusnya melihat barisan probing [0,1 (menemukan sel dengan simbol DEL)], jadi sel ini sebenarnya bisa ditimpa dengan nilai baru tanpa mempengaruhi kebenaran dari Cari(v) di masa mendatang. Jadi, kita taruh 28 di indeks 1.
Meskipun kita bisa mengatasi tabrakan dengan Linear Probing, ini bukan cara yang paling efektif.
Kita mendefinisikan sebuah kluster sebagai kumpulan dari slot-slot yang terisi secara berurutan. Sebuah kluster yang meliputi alamat dasar dari sebuah kunci disebut sebagai kluster primer dari kunci tersebut.
Sekarang sadari bahwa Linear Probing bisa menciptakan primary cluster yang besar yang akan meningkatkan waktu pengerjaan dari operasi-operasi Cari(v)/Masukkan(v)/Hapus(v) lebih dari O(1) yang diiklankan.
Lihat contoh diatas dengan M = 31 dan kita telah memasukkan 15 kunci [0..14] sehingga mereka berada di sel [0..14] (α = 15/31 < 0.5). Sekarang lihat seberapa 'pelan' (kunci ke-16) jadinya.
The probe sequence of Linear Probing can be formally described as follows:
h(v) // base address
(h(v) + 1*1) % M // 1st probe if there is a collision
(h(v) + 2*1) % M // 2nd probe if there is still a collision
(h(v) + 3*1) % M // 3rd probe if there is still a collision
...
(h(v) + k*1) % M // k-th probe, etc...
During Insert(v), if there is a collision but there is an empty (or DEL) slot remains in the Hash Table, we are sure to find it after at most M Linear Probing steps, i.e., in O(M). And when we do, the collision will be resolved, but the primary cluster of the key v is expanded as a result and future Hash Table operations will get slower too. Try the slow on the same Hash Table as in the previous slide but with many DEL markers (suppose {4, 5, 8, 9, 10, 12, 14} have just been deleted).
Di slide sebelumnya (Kluster Primer, Bagian 1), kita memecahkan asumsi bahwa fungsi hash harus dengan uniform mendistribusikan kunci-kunci disekitar [0..M-1]. Di contoh berikutnya, kita akan menunjukkan kalau masalah kluster primer dapat tetap terjadi meski fungsi hash mendistribusikan kunci-kunci secara uniform sekitar [0..M-1].
Di layar, anda melihat M = 31 dengan 15 bilangan acak di antara [0..99] dimasukkan (terdapat beberapa kluster primer pendek dan acak). Jika kita lalu mengisi 4 kunci-kunci berikutnya {2, 9, 12, 1}, tiga kunci pertama akan 'menutup' sel-sel kosong dan secara tidak sengaja meng-annex (atau menggabungkan) kluster-kluster tetangga (yang sebelumnya terpisah)) menjadi satu kluster primer yang panjang. Sehingga pemasukan kunci berikutnya {1} yang mendarat pada (permulaan dari) kluster primer panjang ini akan pada akhirnya melakukan hampir O(M) langkah-langkah probing hanya untuk menemukan sebuah sel kosong. Cobalah .
To reduce primary clustering, we can modify the probe sequence to:
h(v) // base address
(h(v) + 1*1) % M // 1st probe if there is a collision
(h(v) + 2*2) % M // 2nd probe if there is still a collision
(h(v) + 3*3) % M // 3rd probe if there is still a collision
...
(h(v) + k*k) % M // k-th probe, etc...
That's it, the probe jumps quadratically, wrapping around the Hash Table as necessary.
A very common mistake as this is a different kind of Quadratic Probing:
Doing h(v), (h(v)+1) % M, (h(v)+1+4) % M, (h(v)+1+4+9) % M, ...
Asumsikan bahwa kita telah memanggil Masukkan(18) dan Masukkan(10) ke Tabel Hash yang pada awalnya kosong dengan ukuran M = HT.length = 7. Karena 18%7 = 4 dan 10%7 = 3, 18 dan 3 tidak bertabrakan dan keduanya masing-masing berada di indeks 4 dan 3 seperti yang ditunjukkan diatas.
Sekarang, mari klik .
Ulangan (akan ditunjukkan setelah anda mengklik tombol diatas).
Operasi-operasi Hapus(x) dan Cari(y) didefinisikan dengan mirip. Hanya saja kali ini kita menggunakan Quadratic Probing dan bukan Linear Probing.
Contohnya, asumsikan bahwa kita telah memanggil Hapus(18) setelah slide sebelumnya dan kita menandai HT[4] = TERHAPUS. Jika kita lalu memanggil , kita akan menggunakan urutan Quadratic Probing yang sama seperti slide sebelumnya, tetapi menembus HT[4] yang sudah di tandai sebagai TERHAPUS.
Sekilasi, Quadratic Probing yang meloncat +1, +4, +9, +16, ... secara kuadratik sepertinya bisa menyelesaikan isu primary clustering yang kita hadapi dengan Linear Probing sebelumnya, tetapi akah ini adalah teknik resolusi tabrakan yang sempurna?
Cobalah .
Apakah anda menyadari apa yang baru saja terjadi?
Kita bisa memasukkan 12 dengan mudah karena h(12) = 12%7 = 5 sebelumnya kosong (lihat diatas).
Tetapi kita akan memiliki masalah mayor dalam memasukkan kunci 17 bahkan ketika kita masih memiliki 3 slot kosong karena:
h(17) = 17%7 = 3 sudah terisi oleh kunci 10,
(3+1*1) % 7 = 4 sudah terisi oleh kunci 18,
(3+2*2) % 7 = 0 sudah terisi oleh kunci 38,
(3+3*3) % 7 = 5 sudah terisi oleh kunci 12,
(3+4*4) % 7 = 5 lagi sudah terisi oleh kunci 12,
(3+5*5) % 7 = 0 lagi sudah terisi oleh kunci 38,
(3+6*6) % 7 = 4 lagi sudah terisi oleh kunci 18,
(3+7*7) % 7 = 3 lagi sudah terisi oleh kunci 10,
Akan terjadi siklus selamanya jika kita melanjutkan Quadratic Probing ini...
Meskipun kita masih memiliki beberapa (3) sel-sel kosong, kita tidak bisa memasukkan nilai baru 17 ini kedalam Tabel Hash...
Jika α < 0.5 dan M adalah sebuah bilangan prima (> 3), maka kita bisa selalu mendapatkan slot kosong menggunakan Quadratic Probing (bentuk berikut). Ingat: α adalah load factor dan M adalah ukuran Tabel Hash (HT.length).
Jika kedua persyaratan diatas terpenuhi, kita bisa membuktikan bahwa M/2 indeks-indeks Quadratic Probing pertama, diluar alamat dasar h(v) adalah berbeda dan unik.
Tetapi tidak ada garansi setelah itu. Sehingga jika kita mau menggunakan Quadratic Probing, kita perlu menjamin bahwa α < 0.5 (tidak dipaksakan dalam visualisasi ini tetapi kita keluar dari loop setelah M langkah untuk menghindari infinite loop).
We will use proof by contradiction. We first assume that two Quadratic Probing steps:
x and y, x != y (let's say x < y), can yield the same address modulo M.
h(v) + x*x = h(v) + y*y (mod M)
x*x = y*y (mod M) // strike out h(v) from both sides
x*x - y*y = 0 (mod M) // move y*y to LHS
(x-y)*(x+y) = 0 (mod M) // rearrange the formula
Now, either (x-y) or (x+y) has to be equal to zero.
As our assumption says x != y, then (x-y) cannot be 0.
As 0 ≤ x < y ≤ (M/2) and M is a prime > 3 (an odd integer),
then (x+y) also cannot be 0 modulo M.
Contradiction!
So the first M/2 Quadratic Probing steps cannot yield the same address modulo M
(if we set M to be a prime number greater than 3).
Discussion: Can we make Quadratic Probing able to use the other ~50% of the table cells?
Dalam Quadratic Probing, clusters terbentuk sepanjang jalur probing, bukan sekitar alamat dasar seperti pada Linear Probing. Clusters ini disebut Secondary Clusters dan ini 'kurang terlihat' dibandingkan dengan Primary Clusters yang mengganggu Linear Probing.
Secondary clusters terbentuk sebagai akibat dari menggunakan pola yang sama dalam probing oleh semua kunci-kunci, yaitu jika dua kunci yang berbeda memiliki alamat dasar yang sama, urutan Quadratic Probing mereka akan sama.
Untuk menggambarkan ini, lihatlah layar dengan M = 31. Kami telah mengisi Tabel Hash dengan hanya 7 kunci-kunci (jadi faktor beban α = 10/31 ≤ 0.5) dan Tabel Hash kelihatan 'cukup kosong' (tidak ada kluster primer yang besar dan jelas). Tetapi, jika kita lalu memasukkan , meskipun fakta bahwa ada banyak (31-10 = 21) sel-sel kosong dan 62 != 93 (kunci-kunci berbeda yang tidak sengaja dihash ke indeks 0), kita akhirnya melakukan 10 langkah-langkah probing melalui kluster sekunder 'yang kurang kelihatan' ini.
Secondary Clustering dalam Quadratic Probing tidak sejelek primary clustering dalam Linear Probing karena sebuah fungsi hash yang baik harusnya secara teori menyebarkan kunci-kunci ke alamat-alamat dasar yang berbeda ∈ [0..M-1] pada mulanya.
To reduce primary and secondary clustering, we can modify the probe sequence to:
h(v) // base address
(h(v) + 1*h2(v)) % M // 1st probe if there is a collision
(h(v) + 2*h2(v)) % M // 2nd probe if there is still a collision
(h(v) + 3*h2(v)) % M // 3rd probe if there is still a collision
...
(h(v) + k*h2(v)) % M // k-th probe, etc...
That's it, the probe jumps according to the value of the second hash function h2(v), wrapping around the Hash Table as necessary.
If h2(v) = 1, then Double Hashing works exactly the same as Linear Probing.
So we generally wants h2(v) > 1 to avoid primary clustering.
If h2(v) = 0, then Double Hashing does not work for an obvious reason as any probing step multiplied by 0 remains 0, i.e. we stay at the base address forever during a collision. We need to avoid this.
Usually (for integer keys), h2(v) = M' - v%M' where M' is a smaller prime than M.
This makes h2(v) ∈ [1..M'], which is diverse enough to avoid secondary clustering.
The usage of the secondary hash function makes it theoretically hard to have either primary or secondary clustering issue.
Klik untuk memasukkan 35 dan lalu 42 ke Table Hash saat ini diatas.
Rekap (akan ditunjukkan setelah anda mengklik tombol diatas).
Operasi-operasi Hapus(x) dan Cari(y) didefinisikan dengan mirip. Hanya saja kali ini kita menggunakan Double Hashing dan bukan Linear Probing atau Quadratic Probing.
Contohnya, asumsikan bahwa kita telah memanggil Hapus(17) setelah slide sebelumnya dan kita menandai HT[3] = TERHAPUS. Jika kita lalu memanggil , kita akan menggunakan urutan Double Hashing yang sama seperti slide sebelumnya, tetapi menembus HT[3] yang sudah ditandai sebagai TERHAPUS.
Pada kesimpulannya, teknik resolusi tabrakan Pengalamatan Terbuka (Open Addressing) harus:
Sekarang, mari lihat tes kasus yang sama yang menyulitkan Quadratic Probing sebelumnya. Sekarang cobalah lagi. Meskipun h(62) = h(93) = 0 dan mereka bertabrakan, langkah-langkah probing mereka tidak sama: h2(62) = 29-62%29 = 25 tidak sama dengan h2(93) = 29-93%29 = 23.
Diskusi: Double Hashing sepertinya memenuhi semua syarat. Tetapi... Apakah strategi Double Hashing cukup fleksibel untuk bisa digunakan sebagai implementasi library default dari sebuah Tabel Hash? Atau dalam kasus general, mana dari kedua teknik resolusi tabrakan (Seperate Chaining versus Open Addressing: Double Hashing) lebih baik?
Anda telah mencapai akhir dari materi-materi dasar dari struktur data Table Hash ini dan kami mendorong anda untuk mengeksplorasi lebih jauh di Mode Eksplorasi.
Tetapi, kami masih mempunyai beberapa tantangan-tantangan Table Hash untuk anda yang diuraikan di bagian ini.
Performa dari Tabel Hash menurun ketika load factor α menjadi lebih tinggi. Untuk teknik resolusi tabrakan Quadratic Probing (standar), pemasukkan bisa gagal jika Tabel Hash memiliki α > 0.5.
JIka itu terjadi, kita bisa melakukan hash ulang. Kita buat Tabel Hash lain sekitar dua kali lebih besar dengan fungsi hash yang baru. Kita lalui semuai kunci-kunci di Tabel Hash asli, hitung ulang nilai-nilai hash baru, dan memasukkan ulang kunci-kunci (dan dengan data satelitnya) ke Tabel Hash yang baru dan lebih besar, sebelum pada akhirnya kita menghapus Tabel Hash yang lama dan lebih kecil.
Sebuah aturan praktis adalah untuk melakukan hash ulang ketika α ≥ 0.5 jika kita menggunakan Pengalamatan Terbuka (Open Addressing) dan ketika α > konstanta kecil (dekat dengan 1.0, sesuai kebutuhan) jika kita menggunakan Separate Chaining.
Jika kita mengetahui nilai maksimum dari total kunci-kunci yang mungkin dipakai, kita bisa selalu mempengaruhi α menjadi angka kecil.
However, if you ever need to implement a Hash Table in C++, Python, or Java, and your keys are either integers or strings, you can use the built-in C++ STL, Python standard library, or Java API, respectively. They already have good built-in implementation of default hash functions for integers or strings.
See C++ STL std::unordered_map, std::unordered_set, Python dict, set, or Java HashMap, HashSet.
For C++, note that the std::multimap/std::multiset implementations are also exist where duplicate keys are allowed.
For OCaml, we can use Hashtbl.
However, here is our take of a simple Separate Chaining implementation: HashTableDemo.cpp | py | java.
Hash Table is an extremely good data structure to implement Table ADT if the (integer or string) keys only need to be mapped to satellite-data, with O(1) performance for Search(v), Insert(v), and Remove(v) operations if the Hash Table is set up properly.
However, if we need to do much more with the keys, we may need to use an alternative data structure.
Untuk beberapa pertanyaan yang lebih menarik tentang struktur data ini, silahkan latihan pada modul latihan Table Hash (tidak perlu login).
Tetapi untuk pengguna yang teregistrasi, anda harus login dan pergi ke Halaman Latihan Umum untuk secara resmi menyelesaikan modul ini dan prestasi tersebut akan disimpan dalam akun pengguna anda.
Cobalah selesaikan beberapa masalah-masalah pemrograman dasar yang agak membutuhkan penggunaan Tabel Hash (terutama jika ukuran masukkan jauh lebih besar):