[MUSIC PLAYING]
>> DOUG LLOYD: By now you know a lot about arrays,
and you know a lot about linked lists.
And we've discuss the pros and cons, we've
discussed that linked lists can get bigger and smaller,
but they take up more size.
Arrays are much more straightforward to use, but they're restrictive in as much
as we have to set the size of the array at the very beginning
and then we're stuck with it.
>> But that's, we've pretty much exhausted all of our topics
about linked lists and arrays.
Or have we?
Maybe we can do something even more creative.
And that sort of lends the idea of a hash table.
>> So in a hash table we're going to try combine an array with a linked list.
We're going to take the advantages of the array, like random access,
being able to just go to array element 4 or array element 8
without having to iterate across.
That's pretty fast, right?
>> But we also want to have our data structure be able to grow and shrink.
We don't need, we don't want to be restricted.
And we want to be able to add and remove things
very easily, which if you recall, is very complex with an array.
And we can call this new thing a hash table.
>> And if implemented correctly, we're sort of taking
the advantages of both data structures you've already seen,
arrays and linked lists.
>> Well an average insertion into a hash table
can start to get close to constant time.
And deletion can get close to constant time.
And lookup can get close to constant time.
That's-- we don't have a data structure yet that can do that,
and so this already sounds like a pretty great thing.
We've really mitigated the disadvantages of each on its own.
>> To get this performance upgrade though, we
need to rethink how we add data into the structure.
Specifically we want the data itself to tell us
where it should go in the structure.
And if we then need to see if it's in the structure, if we need to find it,
we want to look at the data again and be able to effectively,
using the data, randomly access it.
Just by looking at the data we should have
an idea of where exactly we're going to find it in the hash table.
>> Now the downside of a hash table is that they're really
pretty bad at ordering or sorting data.
And in fact, if you start to use them to order or sort
data you lose all of the advantages you previously
had in terms of insertion and deletion.
The time becomes closer to theta of n, and we've basically
regressed into a linked list.
And so we only want to use hash tables if we don't care about
whether data is sorted.
For the context in which you'll use them in CS50
you probably don't care that the data is sorted.
>> So a hash table is a combination of two distinct pieces
with which we're familiar.
The first is a function, which we usually call a hash function.
And that hash function is going to return some non-negative integer, which
we usually call a hashcode, OK?
The second piece is an array, which is capable of storing data of the type we
want to place into the data structure.
We'll hold off on the linked list element for now
and just start with the basics of a hash table to get your head around it,
and then we'll maybe blow your mind a little bit when we
combine arrays and link lists together.
>> The basic idea though is we take some data.
We run that data through the hash function.
And so the data is processed and it spits out a number, OK?
And then with that number we just store the data
we want to store in the array at that location.
So for example we have maybe this hash table of strings.
It's got 10 elements in it, so we can fit 10 strings in it.
>> Let's say we want to hash John.
So John as the data we want to insert into this hash table somewhere.
Where do we put it?
Well typically with an array so far we probably
would put it in array location 0.
But now we have this new hash function.
>> And let's say that we run John through this hash function
and it's spits out 4.
Well that's where we're going to want to put John.
We want to put John in array location 4, because if we hash John again--
let's say later we want to search and see
if John exists in this hash table-- all we need to do
is run it through the same hash function, get the number 4 out,
and be able to find John immediately in our data structure.
That's pretty good.
>> Let's say we now do this again, we want to hash Paul.
We want to add Paul into this hash table.
Let's say that this time we run Paul through the hash function,
the hashcode that is generated is 6.
Well now we can put Paul in the array location 6.
And if we need to look up whether Paul is in this hash table,
all we need to do is run Paul through the hash function again
and we're going to get 6 out again.
>> And then we just look at array location 6.
Is Paul there?
If so, he's in the hash table.
Is Paul not there?
He's not in the hash table.
It's pretty straightforward.
>> Now how do you define a hash function?
Well there's really no limit to the number of possible hash functions.
In fact there's a number of really, really good ones on the internet.
There's a number of really, really bad ones on the internet.
It's also pretty easy to write a bad one.
>> So what makes up a good hash function, right?
Well a good hash function should use only the data being hashed,
and all of the data being hashed.
So we don't want to use anything-- we don't incorporate anything
else other than the data.
And we want to use all of the data.
We don't want to just use a piece of it, we want to use all of it.
A hash function should also be deterministic.
What does that mean?
Well it means that every time we pass the exact same piece of data
into the hash function we always get the same hashcode out.
If I pass John into the hash function I get out 4.
I should be able to do that 10,000 times and I'll always get 4.
So no random numbers effectively can be involved in our hash tables--
in our hash functions.
>> A hash function should also uniformly distribute data.
If every time you run data through the hash function you get the hashcode 0,
that's probably not so great, right?
You probably want to big a range of hash codes.
Also things can be spread out throughout the table.
And also it would be great if really similar data, like John and Jonathan,
maybe were spread out to weigh different locations in the hash table.
That would be a nice advantage.
>> Here's an example of a hash function.
I wrote this one up earlier.
It's not a particularly good hash function
for reasons that don't really bear going into right now.
But do you see what's going on here?
It seems like we're declaring a variable called sum and setting it equal to 0.
And then apparently I'm doing something so long as strstr[j] is not equal
to backslash 0.
What am I doing there?
>> This is basically just another way of implementing [? strl ?]
and detecting when you've reached the end of the string.
So I don't have to actually calculate the length of the string,
I'm just using when I hit the backslash 0 character I know
I've reached the end of the string.
And then I'm going to keep iterating through that string,
adding strstr[j] to sum, and then at the end of the day going to return sum mod
HASH_MAX.
>> Basically all this hash function is doing is adding up
all of the ASCII values of my string, and then it's
returning some hashcode modded by HASH_MAX.
It's probably the size of my array, right?
I don't want to be getting hash codes if my array is of size 10,
I don't want to be getting out hash codes 11, 12,
13, I can't put things into those locations of the array,
that would be illegal.
I'd suffer a segmentation fault.
>> Now here is another quick aside.
Generally you're probably not going to want to write your own hash functions.
It is actually a bit of an art, not a science.
And there's a lot that goes into them.
The internet, like I said, is full of really good hash functions,
and you should use the internet to find hash functions because it's really
just kind of an unnecessary waste of time to create your own.
>> You can write simple ones for testing purposes.
But when you actually are going to start hashing data and storing it
into a hash table you're probably going to want
to use some function that was generated for you, that exists on the internet.
If you do just be sure to cite your sources.
There's no reason to plagiarize anything here.
>> The computer science community is definitely growing, and really values
open source, and it's really important to cite your sources so that people
can get attribution for the work that they're
doing to the benefit of the community.
So always be sure-- and not just for hash
functions, but generally when you use code from an outside source,
always cite your source.
Give credit to the person who did some of the work so you don't have to.
>> OK so let's revisit this hash table for a second.
This is where we left off after we inserted
John and Paul into this hash table.
Do you see a problem here?
You might see two.
But in particular, do you see this possible problem?
>> What if I hash Ringo, and it turns out that after processing
that data through the hash function Ringo also generated the hashcode 6.
I've already got data at hashcode-- array location 6.
So it's probably going to be a bit of a problem for me now, right?
>> We call this a collision.
And the collision occurs when two pieces of data run through the same hash
function yield the same hashcode.
Presumably we still want to get both pieces of data into the hash table,
otherwise we wouldn't be running Ringo arbitrarily through the hash function.
We presumably want to get Ringo into that array.
>> How do we do it though, if he and Paul both yield hashcode 6?
We don't want to overwrite Paul, we want Paul to be there too.
So we need to find a way to get elements into the hash table that
still preserves our quick insertion and quick look up.
And one way to deal with it is to do something called linear probing.
>> Using this method if we have a collision, well, what do we do?
Well we can't put him in array location 6, or whatever hashcode was generated,
let's put him at hashcode plus 1.
And if that's full let's put him in hashcode plus 2.
The benefit of this being if he's not exactly where we think he is,
and we have to start searching, maybe we don't have to go too far.
Maybe we don't have to search all n elements of the hash table.
Maybe we have to search a couple of them.
>> And so we're still tending towards that average case being close to 1 vs
close to n, so maybe that'll work.
So let's see how this might work out in reality.
And let's see if maybe we can detect the problem that might occur here.
>> Let's say we hash Bart.
So now we're going to run a new set of strings through the hash function,
and we run Bart through the hash function, we get hashcode 6.
We take a look, we see 6 is empty, so we can put Bart there.
>> Now we hash Lisa and that also generates hashcode 6.
Well now that we're using this linear probing method we start at 6,
we see that 6 is full.
We can't put Lisa in 6.
So where do we go?
Let's go to 7.
7's empty, so that works.
So let's put Lisa there.
>> Now we hash Homer and we get 7.
OK well we know that 7's full now, so we can't put Homer there.
So let's go to 8.
Is 8 available?
Yeah, and 8's close to 7, so if we have to start searching we're
not going to have to go too far.
And so let's put Homer at 8.
>> Now we hash Maggie and returns 3, thank goodness
we're able to just put Maggie there.
We don't have to do any sort of probing for that.
Now we hash Marge, and Marge also returns 6.
>> Well 6 is full, 7 is full, 8 is full, 9, all right thank God, 9 is empty.
I can put Marge at 9.
Already we can see that we're starting to have this problem where now we're
starting to stretch things kind of far away from their hash codes.
And that theta of 1, that average case of being constant time,
is starting to get a little more-- starting to tend a little more
towards theta of n.
We're starting to lose that advantage of hash tables.
>> This problem that we just saw is something called clustering.
And what's really bad about clustering is that once you now
have two elements that are side by side it makes it even more likely,
you have double the chance, that you're going
to have another collision with that cluster,
and the cluster will grow by one.
And you'll keep growing and growing your likelihood of having a collision.
And eventually it's just as bad as not sorting the data at all.
>> The other problem though is we still, and so far up to this point,
we've just been sort of understanding what a hash table is,
we still only have room for 10 strings.
If we want to continue to hash the citizens of Springfield,
we can only get 10 of them in there.
And if we try and add an 11th or 12th, we don't have a place to put them.
We could just be spinning around in circles trying to find an empty spot,
and we maybe get stuck in an infinite loop.
>> So this sort of lends to the idea of something called chaining.
And this is where we're going to bring linked lists back into the picture.
What if instead of storing just the data itself in the array,
every element of the array could hold multiple pieces of data?
Well that doesn't make sense, right?
We know that an array can only hold-- each element of an array
can only hold one piece of data of that data type.
>> But what if that data type is a linked list, right?
So what if every element of the array was
a pointer to the head of a linked list?
And then we could build those linked lists
and grow them arbitrarily, because linked lists allow
us to grow and shrink a lot more flexibly than an array does.
So what if we now use, we leverage this, right?
We start to grow these chains out of these array locations.
>> Now we can fit an infinite amount of data, or not infinite,
an arbitrary amount of data, into our hash table
without ever running into the problem of collision.
We've also eliminated clustering by doing this.
And well we know that when we insert into a linked list, if you recall
from our video on linked lists, singly linked lists and doubly linked lists,
it's a constant time operation.
We're just adding to the front.
>> And for look up, well we do know that look up in a linked list
can be a problem, right?
We have to search through it from beginning to end.
There's no random access in a linked list.
But if instead of having one linked list where a lookup would be O of n,
we now have 10 linked lists, or 1,000 linked lists,
now it's O of n divided by 10, or O of n divided by 1,000.
>> And while we were talking theoretically about complexity
we disregard constants, in the real world these things actually matter,
right?
We actually will notice that this happens
to run 10 times faster, or 1,000 times faster,
because we're distributing one long chain across 1,000 smaller chains.
And so each time we have to search through one of those chains we can
ignore the 999 chains we don't care about , and just search that one.
>> Which is on average to be 1,000 times shorter.
And so we still are sort of tending towards this average case
of being constant time, but only because we are leveraging
dividing by some huge constant factor.
Let's see how this might actually look though.
So this was the hash table we had before we declared a hash table that
was capable of storing 10 strings.
We're not going to do that anymore.
We already know the limitations of that method.
Now our hash table's going to be an array of 10 nodes, pointers
to heads of linked lists.
>> And right now it's null.
Each one of those 10 pointers is null.
There's nothing in our hash table right now.
>> Now let's start to put some things into this hash table.
And let's see how this method is going to benefit us a little bit.
Let's now hash Joey.
We'll will run the string Joey through a hash function and we return 6.
Well what do we do now?
>> Well now working with linked lists, we're not working with arrays.
And when we're working with linked lists we
know we need to start dynamically allocating space and building chains.
That's sort of how-- those are the core elements of building a linked list.
So let's dynamically allocate space for Joey,
and then let's add him to the chain.
>> So now look what we've done.
When we hash Joey we got the hashcode 6.
Now the pointer at array location 6 points to the head of a linked list,
and right now it's the only element of a linked list.
And the node in that linked list is Joey.
>> So if we need to look up Joey later, we just hash Joey again,
we get 6 again because our hash function is deterministic.
And then we start at the head of the linked list pointed
to by array location 6, and we can iterate
across that trying to find Joey.
And if we build our hash table effectively,
and our hash function effectively to distribute data well,
on average each of those linked lists at every array location
will be 1/10 the size of if we just had it as a single huge
linked list with everything in it.
>> If we distribute that huge linked list across 10 linked lists
each list will be 1/10 the size.
And thus 10 times quicker to search through.
So let's do this again.
Let's now hash Ross.
>> And let's say Ross, when we do that the hash code we get back is 2.
Well now we dynamically allocate a new node, we put Ross in that node,
and we say now array location 2, instead of pointing to null,
points to the head of a linked list whose only node is Ross.
And we can do this one more time, we can hash Rachel and get hashcode 4.
malloc a new node, put Rachel in the node, and say a array location
4 now points to the head of a linked list whose
only element happens to be Rachel.
>> OK but what happens if we have a collision?
Let's see how we handle collisions using the separate chaining method.
Let's hash Phoebe.
We get the hashcode 6.
In our previous example we were just storing the strings in the array.
This was a problem.
>> We don't want to clobber Joey, and we've already
seen that we can get some clustering problems if we try and step
through and probe.
But what if we just kind of treat this the same way, right?
It's just like adding an element to the head of a linked list.
Let's just malloc space for Phoebe.
>> We'll say Phoebe's next pointer points to the old head of the linked list,
and then 6 just points to the new head of the linked list.
And now look, we've changed Phoebe in.
We can now store two elements with hashcode 6,
and we don't have any problems.
>> That's pretty much all there is to chaining.
And chaining is definitely the method that's
going to be most effective for you if you are storing data in a hash table.
But this combination of arrays and linked lists
together to form a hash table really dramatically improves your ability
to store large amounts of data, and very quickly and efficiently search
through that data.
>> There's still one more data structure out there
that might even be a bit better in terms of guaranteeing
that our insertion, deletion, and look up times are even faster.
And we'll see that in a video on tries.
I'm Doug Lloyd, this is CS50.