Yes, Mr. Burkett.

Let's do the same thing to lookup.

It could be the case that with 2 buckets I have a good distribution.

I've changed hashtable_update.

And with a good hash function this is true.

Real world implementations of hash tables try to shoot for a ratio between the number of buckets they have and the number of keywords, increasing the number of buckets accordingly as the number of keywords in the hash table decrease and increase.

They do this by looking at the load factor. We actually used this in Unit 4.

There's really 2 good reasons.

Let's say we search for Irvin and that brings us to bucket 2.

We're going to show that by giving an example hash table.

So this means that if you had about a million entries in your hash table, you would expect to have about a million and a half buckets.

So we've been talking about the standard way a hash table works.

In the end, Charlie Bucket won a chocolate factory.

That means there's one space for each hash value, that if you hashed to a given bucket there's only one space there.

We find the bucket in the first line, then within the bucket we're searching for the key, and if we find that entry we're going to update the value.

But as you increase above that 2 3 threshold, then you'd double the size of the buckets.

Things had never been better for the Bucket family.

After 8 months of explosive growth in business, I hope so, Peter finds that he needs to double the number of buckets in his hash table.

This is partly to be easier to see what's going on, because if you saw a hash table with thousands of empty buckets, that would be kind of hard to print out.

One thing to do would be start a new copy, so you keep the search engine going, still responding to queries using the old hash table but you start a separate process of running on a separate computer, something that's making a new copy of the hash table with a larger number of buckets.

Let's say we have a hash table with only 2 buckets.

So that would be 3 string comparisons.

And with a good hash function the time is going to decrease even more.

This is a story of an ordinary little boy named Charlie Bucket.

The way the Python dictionary is implemented, there's just one flat list.

In the new hashtable_lookup, we first find the bucket and then within the bucket we search for the entry.

We had that question in Unit 5.

S3 is a simple storage service, and it's basically a distributed file storage thing in the cloud.

If I have a hash table where 3 keywords all go in bucket 1, if I want to look up the keyword Batman, I'm going to go to bucket 1 and iterate through each item in this bucket until I find Batman.

And so the average number of comparisons is going to be half the size of a bucket in order to look up a keyword in the hash table.

The question where it was N divided by B where you're looking at the impact of the change of the number of buckets and the number of entries.

Statement 2 says we should expect the time to look up most keywords in the hash table will decrease as we increase the number of buckets.

If memory was free and cheap, and equally fast no matter how much you needed, then you'd want the hash table to be as big as possible, right?

In both functions, these 2 lines of code go through a given bucket searching for an entry whose first value is the key.

The first reason is because changing the number of buckets, be it more or less, changes where keywords hash to.

But if I add a third bucket, the hash function is such that everything lands in that new bucket.

And the women said, You know, Jacqueline, who in Nyamirambo is not going to buy doughnuts out of an orange bucket from a tall American woman? And like (Laughter) it's a good point.

In order to show it, we need an example, so let me give you an example dictionary with 3 buckets and 3 keywords in here.

gt gt So we had a lot of great questions about hash tables on the forums and one example is Student Baracha asks

So the table would then be doubled, and that changes the bucket each word would appear in, because we saw that the result of the hash function depends on the number of buckets you have.

We were doing example hash tables, where the number of buckets was very small, and each bucket had many entries in it.

You should see that it's very similar to the code that we have in update and lookup in that we're going to go through the bucket searching for the entry whose first value is the key and then returning the entire entry so that we can use it accordingly in both update and lookup.

Even if the average size is fairly small, the worst size could be much larger than that, and if the lookup for the worst case entry starts to get very bad, then you want a larger number of buckets or to change your hash function in some way.

This is desirable, because if we want to change how these 2 lines of code work perhaps we change the structure of the bucket we don't want to look through every hash table function searching for how this works and updating them.

Once the buckets get too full, or the load factor is too high, you want to create a new table with more buckets, and you've got to copy all your entries to it.