Suppose that we are using an extendible hash table with bucket size 2 and suppose that our hash function H is such that
H(ANT) = 1110... H(DOG) = 0101... H(PIG) = 1001... H(BEAR) = 0010... H(ELK) = 1000... H(RAT) = 0000... H(CAT) = 1010... H(GORN) = 1010... H(WOLF) = 0111... H(COW) = 0001... H(MOOSE) = 0001...
At the present time, the hash table is as follows:
Directory
+----+ +-----+-----+
(000) 0 | *-+--->-------------> | COW | RAT | (000)
+----+ +-----+-----+
(001) 1 | *-+--->-------------> +------+----+
+----+ | BEAR | | (001)
(010) 2 | *-+--->---+ +------+----+
+----+ \ +-----+-----+
(011) 3 | *-+--->-----+-------> | DOG | | (01)
+----+ +-----+-----+
(100) 4 | *-+--->---+
+----+ \ +-----+-----+
(101) 5 | *-+--->-----+--->---> | CAT | ELK | (1)
+----+ / +-----+-----+
(110) 6 | *-+--->---+
+----+ /
(111) 7 | *-+--->-+
+----+
Each bucket has an associated signature (or label) indicating which cells in the directory point to it: namely, all those having an index whose binary representation has the signature as a prefix.
For each of the following operations, apply it to the hash table above (not to the result of applying the previous operations) and show the hash table that results.
(a) Insert WOLF. (b) Insert ANT.
(c) Insert GORN. (d) Delete DOG.
(e) Delete RAT. (f) Delete CAT.
(g) Insert MOOSE.
SOLUTIONS:
(a) Insert WOLF. WOLF fits quite nicely alongside DOG in the bucket with signature 01. (Illustration omitted.)
(b) Insert ANT. This causes overflow of the bucket with signature 1, and thus that bucket is split into buckets with signatures 10 and 11, into which CAT and ELK are placed appropriately, after which we attempt to insert ANT again. Because 10 is a prefix of both H(CAT) and H(ELK), both of these animals are placed into the bucket with signature 10, leaving the 11 bucket empty. Insertion of ANT now goes smoothly, as it belongs in the 11 bucket.
+----+ +-----+-----+
(000) 0 | *-+--->------------> | COW | RAT | (000)
+----+ +-----+-----+
(001) 1 | *-+--->------------> +------+---+
+----+ | BEAR | | (001)
(010) 2 | *-+--->---+ +------+---+
+----+ \ +-----+---+
(011) 3 | *-+--->-----+------> | DOG | | (01)
+----+ +-----+---+
(100) 4 | *-+--->---+
+----+ \ +-----+-----+
(101) 5 | *-+--->-----+------> | CAT | ELK | (10)
+----+ +-----+-----+
(110) 6 | *-+--->---+
+----+ \ +-----+---+
(111) 7 | *-+--->-----+------> | ANT | | (11)
+----+ +-----+---+
(c) Insert GORN. This causes overflow of the bucket with signature 1, and thus that bucket is split into buckets with signatures 10 and 11, into which CAT and ELK are placed appropriately, after which we attempt to insert GORN again. Because 10 is a prefix of both H(CAT) and H(ELK), both of these animals are placed into the bucket with signature 10, leaving the 11 bucket empty. Attempting to insert GORN leads to splitting the 10 bucket into buckets with signatures 100 and 101. ELK is placed into the former and CAT into the latter. Attempting to insert GORN once again, we find room for him in the 101 bucket.
+----+ +-----+-----+
(000) 0 | *-+--->------------> | COW | RAT | (000)
+----+ +-----+-----+
(001) 1 | *-+--->------------> +------+---+
+----+ | BEAR | | (001)
(010) 2 | *-+--->---+ +------+---+
+----+ \ +-----+---+
(011) 3 | *-+--->-----+------> | DOG | | (01)
+----+ +-----+---+
(100) 4 | *-+--->------------> +-----+---+
+----+ | ELK | | (100)
(101) 5 | *-+--->-----+ +-----+---+
+----+ \ +-----+------+
(110) 6 | *-+--->---+ +----> | CAT | GORN | (101)
+----+ \ +-----+------+
(111) 7 | *-+--->-----+------> +---+---+
+----+ | | | (11)
+---+---+
(d) Delete DOG. Remove DOG from the 01 bucket. As there are no buddy buckets with which to combine it, we simply leave the 01 bucket empty. (Only a bucket with signature 00 could be a "buddy" to the bucket with signature 01, and there is no such bucket.) (Illustration omitted.)
(e) Delete RAT. Remove RAT from the 000 bucket. As the 000 and 001 buckets now qualify as "buddies" (note that the total # of entries in the two of them is now two), we can combine them into a 00 bucket containing COW and BEAR. Because now the maximum length of any bucket's signature is two, we can halve the size of the directory, making its depth two.
+----+ +-----+------+
(00) 0 | *-+--->------------> | COW | BEAR | (00)
+----+ +-----+------+
(01) 1 | *-+--->------------> +-----+---+
+----+ | DOG | | (01)
(10) 2 | *-+--->---+ +-----+---+
+----+ \ +-----+-----+
(11) 3 | *-+--->-----+------> | CAT | ELK | (1)
+----+ +-----+-----+
(f) Delete CAT. Remove CAT from the 1 bucket. There is no buddy bucket, so that is all we can do. (Illustration omitted.)
(g) Insert MOOSE. This causes overflow of the bucket with signature 000. Because this bucket has depth 3, which corresponds to DIR_DEPTH, we double the size of the directory, making each entry in the new directory point to the correct bucket. Then we split the overflowing bucket into buckets with signatures 0000 and 0001, into which COW and BEAR are placed appropriately. Then we attempt once more to insert MOOSE. This time, MOOSE fits nicely alongside COW in the 0001 bucket.
+----+ +-----+---+
(0000) 0 | *-+--->-------------> | RAT | | (0000)
+----+ +-----+---+
(0001) 1 | *-+--->-------------> +-----+-------+
+----+ | COW | MOOSE | (0001)
(0010) 2 | *-+--->---+ +-----+-------+
+----+ \ +------+---+
(0011) 3 | *-+--->-----+-------> | BEAR | | (001)
+----+ +------+---+
(0100) 4 | *-+--->---+
+----+ v
(0101) 5 | *-+--->---+
+----+ v +-----+---+
(0110) 6 | *-+--->---+---------> | DOG | | (01)
+----+ ^ +-----+---+
(0111) 7 | *-+--->---+
+----+
(1000) 8 | *-+--->--+
+----+ v
(1001) 9 | *-+--->--+
+----+ v
(1010) 10 | *-+--->--+---->----> +-----+-----+
+----+ ^ | CAT | ELK | (1)
(1011) 11 | *-+--->--+ +-----+-----+
+----+ ^
(1100) 12 | *-+--->--+
+----+ ^
(1101) 13 | *-+--->--+
+----+ ^
(1110) 14 | *-+--->--+
+----+ ^
(1111) 15 | *-+--->--+
+----+