Hash Table (Part 1)
Video Title: Hash Table (Part 1)
Hi there now we’re gonna go over the hash table data structure right and in my opinion the hash table is the most powerful data structure there is in computer science and the reason for that is if you want to get something from this data structure if you want to
Retrieve a value from the hash table the running time of that operation is Big O of 1 ok as you’re aware this is instantaneous right this is constant running time this is much faster than the binary search right so this is this should blow your mind if you want to
Insert values into the hash table that’s also Big O of 1 it’s a constant running time for insertion as well as retrieval and in many cases for deletion as well it’s constant running time so this blows away all of the other algorithms and data structures that you’ve been
Learning in this course this hash table data structure ok and believe it or not a lot of computer algorithms are based on this hash table a lot of computer programs for example the spell checker when you’re typing in a Word document the program needs to be super fast in
Determining whether what you’re writing is spelled correctly right it can’t take a second or 2 seconds it needs to be instantaneous as you’re typing along real time so the hash table data structure is used a lot in many programs where you need that type of speed ok how
Does this work well believe it or not the hash table is actually a very simple data structure it’s simpler than some of the trees that you’ve seen the heap the binary heap the binary search tree it’s simpler than that all right and there’s beauty in simplicity I don’t know if you’ve heard
That saying before but I don’t mean to be cliche but in my opinion this is a beautiful algorithm because it’s first of all simple and it gives us awesome performance so how does this work well in the background the hash table let me just write that up here again the hash
Table is using an underlying data data container that we’re all very familiar with by now and that is the array okay now other data structures also use the array but the way the hash table uses it is closest to the nature of how an array should be used when you’re inserting
Data into an array all you need is the index position right and if you’re getting a value from the array all you need is the index position all right and because we have this index position for insertion and for retrieval as well as deletion the running time of these
Operations because it’s an array is Big O of one so the hash table utilizes this concept of index positions and that is why we achieve this Big O of one constant running time operation so how does it do this you know let’s say that we have a
Hundred thousand words in in an array and we need to get the correct spelling of a word let’s say the word is something simple as hello this hello is stored somewhere in this array and I’m just gonna add an ellipsis here to indicate that this is a much bigger
Array than I’ve drawn so hello is somewhere within this large array okay how is the hash table going to be able to retrieve this hello word all right we need to get the index position all right how do we get the index position because this hello could be somewhere in you
Know the thousandth index position let me write hello here we need to know which index position this word resides or this object it could be it doesn’t have to be strings it could be objects how do we get the index position of this well the magic happens with the hashing
Function all right this is the key term right here hash if we pass in the word hello into this function let me just write that down here hash funk and I’m gonna be defining this function in the Java code and you’ll get a better understanding of how to code this but
Basically if I pass in the word hello to this function the the magic is happening in this function it’s going to tell us the output of this function that’s return value is going to be the index position so let’s say the index position is a you know a hundred and eighty
For instance this process of getting this index position is instantaneous right because the hash function has a way of mapping words to index positions that logic that’s coded in the hash function is basically going to map objects to index positions and we’ll go over the different ways in which we can
Do this but Java has this process perfected will certainly go into that later but we got what we needed we pass in the string hello to the hash function we find out that it is in slot position 182 so now we know that hello is in 182
So if we need to get it all we have to do is reference the array at the index position 182 and we have the word hello all right and this word can have you know it could be an object it could be all kinds of things
It could even be another array or linked list that we get at that index position but the key is to get the index position which we’ve got because we use the hash function so what is that what is the concept of hashing hashing converts objects to index positions in the array
It’s sort of like an address locator that’s another way of looking at it the hash function is an address locator it gives us where the item that we’re searching for is located in the array and once we have the index position you’re well aware that things are
Immediate right it’s very fast big of one we just need the index position and that’s what the hash algorithm allows us to do so what’s going on in this hash let me clear the screen here we need to think about how data is stored in a hash
Table let’s say that we’re trying to build a dictionary and we have words like for example Apple I’m just gonna write a few words your cat hero dinner elephant and we need a way to insert this data into the hash table so that we can also retrieve it very easily well we
Need to use the hashing function so I’m just gonna write that here hash funk and the magic is within the logic of how this this function or this method is coded all right shall we pass in to this function and it’s able to basically give us the index position of
Where Apple belongs in the array so let me just draw an array here so let’s say that this function takes the first character of the word and maps it numerically which alphabet number does a represent in this super basic example let’s just go in numerical order and say
That a is gonna represent the number one alright so let me just write that up here B is going to represent 2 C is going to represent 3 all the way to the 26th alphabet which is Z and let’s just say that the hash function has this
Mapping put in place and it just figures out what the first letter is of this word and gives us the index position so in this case hash function is going to return us the index position 1 so we can very quickly go to the index position 1
And get and that’s going to be right here in x position 1 because we know that this is 0 and let’s just say that this returns us the word right we were able to retrieve the word and as well as insert it we insert the data using the
Hash function and we retrieve the data also using a hash function because the hash function gives us the index position that is involved for that given word all right so for example cat the first letter of cat is C so the index position 3 applies
Here so the hash function is you want to give us the number 3 so we put we put cat in index position 3 which is right here so going to the next word hero that starts with an H so where will that be well let’s just draw a few more slots
Here so 3 4 5 6 7 H is going to be right here sorry this array is getting a little messy but let’s just say that we found we put the word hero in this index position so the hash function gave us where to put it and when we need to
Retrieve that value we pass in the word to the hash function it gives us that I’m going to repeat this multiple times because this is a key concept in the hash table dinner goes into the fourth index position an elephant goes into the fifth index position now what
About if we had another word called Africa now we’re in trouble because Apple starts with an A and so does Africa so the hash function what is it going to return for Africa it’s going to return one for Africa as well and we can’t put Africa into this slot
So this hashing function is no good as a matter of fact this is a terrible hashing function but for the sake of keeping things simple I showed you what a hashing function is so let’s look at a way to improve the hashing function we’re using and make it generate more
Keys for us let me let me clear the screen to make some room so these are the words that we’re trying to insert and the hashing function was giving us a problem right it was not it was not a good hashing function the maximum number of index positions that that function
Could generate for us was 26 because if we’re we are only considering one letter of each word right the first character of each word that’s gonna give us a maximum possibility of 26 and that’s only the case that all of the words have a different first letter
Right so if we try to enhance along the same lines and let’s say that we want to involve the the last character of each word as well into the computation so what we could do is a for Apple is in the position 1 and E is in the position
Of 5 so we could do is we can add 5 plus 1 and that’s going to give us 6 so we can put Apple in the index position 6 in the array and so Africa there there won’t be a conflict first character of Africa is a the last character is a as
Well so that’s 1 plus 1 is equal to 2 so there won’t be a conflict between Apple and Africa however this is still not a good hashing function because for example the word announced has an e at the end and so that is going to be the
Same situation as Apple we’re gonna have a conflict both announced and Apple are going to try to go into index position 6 so both of our hashing strategies were no good we can’t just involve the first letter because that’s just only going to allow 26 possibilities of words if the first
Letter of the word is unique and if we involve this the last letter that’s another 26 and if we involve you know some of the middle ones let’s say that we’re talking about a 10 character word that’s 26 plus 26 all the way to 10 times that’s going to give us a total
Number of 260 words that we could put in our hash table and this is obviously only if we get unique index positions for each one of those words so there’s got to be a better way to hash strings and other objects and I’m going to show
You in the java code how to create a very good hashing function for Strings and that’s going to actually involve the modulus operator so just a quick review from several lectures ago the modulus operator is used to find the remainder so if we do nine modulus three that’s
Going to give us zero if we do seven modulus three that’s gonna give us one so using this along with a good hashing strategy is actually going to improve the variety of index positions the hash function can generate for us so we’ll go into those details later but understand
That one very important thing that I’m about to talk about and that is that even if you have a very very good hashing function you will still experience collision okay it will still be conflicts so let’s talk about how to resolve these kinds of conflicts conflict resolution so let me just draw
An array here and I’m going to hopefully try to keep this much neater than the previous white board that I had so let’s say we try to insert the word phone so we give this word phone to our hashing function and let’s say that that’s a perfectly working hashing function it
Does some random calculations and gives us a pretty good index position to put the word phone in and so let’s say that that index position let’s say that our hash function returns the index position X okay and let’s say that that extends up being somewhere in this array right here
And let’s say that there’s a word okay let’s say that there’s a word in the index position X where we would like phone to go all right so what do we do even with our perfectly working hashing function we are still experiencing conflicts so we try to insert the word
Into this X index position and we can’t do that so there’s a strategy known as probing we can actually probe to the next cell to see if that’s empty and if it’s not then we probe to the next one if not then we probe to the next one
Until we’ve come across an empty slot and this is an empty slot so we’ll put phone right here in this cell okay so this is actually known as probing and specifically this is known as linear probing we’re stepping a one step at a time all right so if we’re not able to insert
Phone into index position X then we need to probe to X plus one all right and if that’s not available then we probe to X plus two and if that’s also not empty then we probe to X plus three and so on until we get to the place where we can
Fit that word so the step size that we’re taking is one we’re moving one step at a time to find an available slot now this is one way of resolving conflicts all right and another term for this is open addressing we’re looking for an open address an open position
Where we can put the word and we can use this linear probing technique to do that now even if we were able to resolve the conflict and finally get the word into the next available slot we still have a problem and the problem is that we’re creating this sort of cluster of words
Okay all jumbled up together and you know they’re not in there in their preferred index position they’re sort of just being advanced the next available slot and they’re clustered together all right and this kind of a cluster is no good because when we’re searching for phone what the function is going to do
For us is going to give us this index position X but then we’re gonna have to iterate to find the next available slot we’re phone could be and if we have a big enough cluster this entire hash table could degenerate could degenerate to Big
O of n okay and that is no good that’s that’s just you know searching through an array and we don’t want to do that we want it to be Big O of one that’s the whole point of using the hash table so a slightly better way to avoid clustering
Is to use something called quadratic probing this is linear probing where we’re taking one step at a time in quadratic probing we take multiple steps so if we’re not able to put the word in the position X we would advance to X plus one squared and if that’s occupied
Then we go to X plus two squared and if that’s occupied then we advance to X plus three squared as you can see the hops that we take the jumps that we take become increasingly larger so the quadratic probing is a bit more extreme than linear probing right it takes
Bigger jumps it’s as if the quadratic probe became increasingly desperate as a search length increased right at first it calmly picks the first cell you know the adjacent to cell if that’s occupied it thinks that we may be in a small cluster so it tries something four cells
Away and if that’s occupied then it becomes a little concerning and you know it jumps to nine cells away and then 16 cells and as you can see it’s going to go up like that 16 and then 25 so this quadratic probing is slightly better than linear probing
Because we don’t start piling words right next to one another we do kind of jump ahead and put the word and if we can find an available slot but that still doesn’t save us from clustering issues right because the pattern is still you know 4 9 16 this kind of
Pattern is still going to be spaced out like that so we’ll have smaller clusters but there will be clusters nonetheless so they may be spread out a bit more but we’re still gonna have clusters to reduce the number of clusters even further we can use a third approach
Right I showed you linear probing quadratic probing there’s a third approach we can use and that is known as double hashing in double hashing we pass the element that we want to insert to two hashing functions hence the name double hashing so let’s just call them func one and func two we passed
Let’s say we pass the word phone to func one and that gives us the hash value and let’s just say that that’s X well func two and this X is the index position where we would like to insert phone and if it’s occupied already we cannot
Insert it there so we need another piece of information and that comes from func – all right the step size is determined by funk – so we pass the word phone to func 2 as well and that’s going to give us a step size and let’s just say that
That step size is three for example this step size is going to be different for every word we’re going to get an index position which you know there can be a conflict but then when we involve this step size it’s gonna you know we won’t have as many clusters or you may still
Have a few clusters here and there but involving a second hashing function is going to reduce the probability of collisions even further and the step size that’s generated by funk – it’s going to vary based on the argument that is given to it right so it has a different mechanism it’s a different
Function than func 1 it has a different mechanism of dealing with the word phone all right so func one has a different way of handling how to generate an index position for phone and func 2 has a different strategy for generating the step size for the word phone right the
Step sizes will vary based on the argument that you pass to the step size function so this double hashing actually is the best approach to finding an open address for where you want to put your element into a hash table now a very key thing that I forgot to mention is you
Know and this is a requisite and that is that your array size right the underlying array that you’re using its size better be a prime number and I’ll explain to you shortly why that’s the case and it’s going to make complete sense when we get into the
Java code we’re going to be implementing the double hashing approach in Java so before moving on to the code I just want to summarize everything and get you thinking about how you’re going to do this programmatically so let’s clear up the screen here in double hashing when
We want to insert an element into a hash table we need to pass that element to two functions okay to find the ultimate index position or if you’d like to put it so the first function let’s call it func one its responsibility is to give us the index position of where we would
Like to put the element that lets us say that that’s X the second function it’s responsibility is to give us the step size so the number of steps that we would need to jump in order to find an empty slot in the array okay in the
Event in the event that X index position is occupied okay so let’s say that we’re trying to insert the word bottle okay we pass bottle to func one and we pass bottle to funk to funky one gives us the index position X and func two calculates
Some step size okay and we’ll go into the details of the calculation later in the java code so we get the index position of func one and let’s say that that index position is right here in this case we cannot insert bottle into this spot so what we do is we increment
The step size so with X so we do X plus five let’s say alright we’ll only know what the step size is once we run the func – all right let’s say that that gave us the number five and that gives us a new that gives us a new incremented
X okay that gives us a new index position and let’s just say that that’s seven we’re not going to move seven spaces yet what we’re gonna do is actually compute another calculation which is seven modulus array size okay the size of the array and this is
Going to give us the slot position where we need to look next for vacancy for a vacant slot and let’s call that slot X and so let’s say array size let’s say array size is 29 for example 7 modulus 29 is going to give us a 7 okay
Because 29 does not go into 7 so the only remainder we have is 7 so we try to put the word bottle into index position 7 so let’s say that index position 7 is right here this is the new X okay this is xn so in this case it’s empty so we
Can put the word bottle in here but let’s say that there was a word in here as well what do we do well we go through this process again okay and the process I’m talking about here is this put a box around it we do the calculation again so
X n is now going to be 7 and the step size that we’ve already calculated is 5 so we do 7 plus 5 is equal to 12 and then we do 12 modulus array size all right whatever that array size is is going to give us X and you know a new X
So let’s just call it X n 2 so 12 mod array size is gonna give us the new X n and let’s just say the array size is still larger let’s say it’s 29 so 29 does not go into 12 so it’s going to give us the calculation 1229 it’s gonna
Give us 12 so let’s just say this is a 29 slot array I don’t I know I didn’t draw all the slots but that’s not important we check in index position 12 to try to put in the word bottle in there if it’s empty great let’s put the
Word in there if it’s not empty then we have to redo this calculation so we keep doing this iteration the the box that I drew here we keep repeating these two calculations inside of a while loop we’re gonna we’re gonna keep repeating this until we find an empty slot now the
Very important thing to keep in mind with double hashing and I briefly mentioned this to you earlier and that is that your array size better be a prime number okay I’m gonna repeat that for double hashing it’s an absolute requirement that your array size is a prime number and we’re gonna ensure this
In our java code when we type it in the next lesson the array size must be a prime number if it’s not a prime number your program may crash and burn okay you’re gonna run into any situation where you may have an infinite loop that just doesn’t end and your program will
Will crash eventually let me actually show you an example of that I know this lecture is getting long but I don’t want to leave anything to your imagination that information is important for you to understand that this could happen so let’s go over an example of that where
This where we can have an infinite loop because the array size is not a prime number I’m gonna clear some of this so if we want to insert bottle we pass bottle to func 1 we get the index position and then we pass bottle to funk
2 we get the step size once both of these things are calculated in the code we’re going to enter a while loop and in that while loop we’re going to be continuously trying to find the open slot in which bottle can go and that while loop the two calculations are
Going to continue to repeat and I just showed you those calculations but I’m gonna rewrite them here in a different flavor so that hopefully it makes better sense so the index position which is X is going to be added to the step size and it’s going to be updating the index
This index whatever it is we’re going to be doing the mod operator with this index with the array size the reason why we need to do a modulus with the array size is because this initial index value that is determined by the first calculation is going to be very very
Large ok whatever hash value that is determined by the func 1 and that hash value could be very large as you’ll see in the Java code it depends on the function but if you have a good hashing function it may return a very large value and that is why we’re gonna need mod
Operator with the array size so that we get the remainder okay and that remainder is is guaranteed to be one of the index positions within the array all right if we don’t do this the index might be well out of bounds okay it might be much larger than what the array
Size is so we don’t want to get into index out of bounds exception that is why that’s one of the key things in this is we need to do a mod with the array size and that’s going to give us the final index position in this calculation okay
And if that’s if that index position is not empty this is going to continue to run until we find an empty slot okay so this is gonna be running as part of the while loop okay this is repeating I’m going to write that right here this step
Is going to repeat until we find an empty slot to put the word bottle okay so why is it important why is it important for the array size to be a prime number let’s dive a little deeper and go over an example let’s say that funk one it gave us the index position
Zero and our new Grand Funk two it gave us the step size 5-a funk one is supposed to give us the hash value which we’re calling as the index typically it’s going to give us a much larger number than zero but to explain to you
Why the array size needs to be a prime number I’m just picking this arbitrary zero so it’s easier for you to see the pattern that gets formed when the array size is not a prime number so let’s say that the array size that was chosen is
15 15 is not a prime number it’s divisible by three it’s divisible by five so we check in the 0th index position first if it’s occupied then of course we need to enter this while loop and what does this while loop entail it entails these calculations so we have to
Do zero plus the step size five and that’s going to give us an updated index position of five okay then we pass this to five mod 15:15 does not go into five the remainder is gonna be five so now the index position is no longer zero its
Five so now let’s look at index position five and see if there if it’s an empty cell if it’s not empty we got to remain in this loop and continue with these calculations again why are these calculations are happening these are happening because we are trying to find
An open address and open location in which we can put the word bottle and we’re going to remain in this loop until we find an open slot so let’s just assume that we’re not able to find the open slot and we’re just going to continue in this loop and let’s see what
Happens so we do that calculation again and instead of zero in the second time we do five plus five and that’s gonna give us ten okay so the index position is now ten and we pass in ten right here ten mod fifteen that’s going to give us
Ten because 15 does not go into ten so now the index position is ten so we do ten plus five is equal to 15 and then 15 mod 15 is going to give us a zero notice that now the updated index position is zero which was right here so notice that
This is gonna happen over and over again or back or back to zero this is an infinite loop it’ll never end so the only available slots that we can search within the array which is of size 15 is zero five and ten over and over and over
And over again what about the rest of the slots of the array one two three four six seven eight nine all the way up to 14 we’re never gonna get to those slots okay there the bug is that we’ve got a non prime number as the array size okay and
This is what can happen if you choose a non prime number as the array size this is not a prime number this is divisible by three by five now let’s say that the array size was 13 I’m gonna erase some of this and we’re going to redo the calculation
So the positions that will be searched if the array size were 15 would be these okay within with a 15 array size but let’s say the the array size is 13 now in this example this 13 is a prime number okay so you’ll see how the result changes so nothing changes in our
Calculation we still have the zero being returned by funk one let’s say so index position zero plus the step size is five okay then we pass five into the second calculation which is five mod array size which is 13 this is going to return us five because 13 does not go into five
Five is the remainder so now instead of zero it’s going to be five plus five that’s gonna give us 10 and then 10 Mod 13 is gonna give us 10 so far we’re visiting index position 5 10 you’ll see how this changes so now 10 plus 5 right
The step size is equal to 15 all right and 15 Mod 13 is gonna give us a 2 so in the case of the array size being 13 we’re visiting 0 so far 5 10 – let’s continue the calculation so now in exposition is – based on our latest
Calculation so to index position + step size of 5 is going to give us 7 ok and 7 Mod 13 is going to give us 7 so here’s another index position that we can visit in array with the size 13 so now 7 plus
5 is 12 so 7 plus 5 is 12 and 12 percent 13 excuse me Mod 13 is going to give us 12 because 13 does not go into 12 so now we’re able to visit 12 so let’s keep going forward 12 plus 5 that’s gonna
Give a 17 and 17 Mod 13 is gonna give us the remainder of 4 so as you can see because the array size was prime we were able to visit all of these different positions to find the available slot to put the word bottle in since the array size is a prime number
Now we’re gonna be able to calculate all of the different index positions and those are going to be from zero all the way to 12 that’s that’s how you get the 13 slots from 0 to 12 we’ll be able to visit each one of those index positions
In our search for finding an open address in the case that the array size is not a prime number in the first example these are the only slot positions we could have visited ok and this algorithm would crash and burn so it’s very important for your array size
To be a prime number now a subtle but important point that I’d like to make about funk 2 which is a step size function is that it must not be the same as the funk one right the logic to retrieve a new hash that’s used in funk
One better be different than the logic that’s used in funk two that’s an obvious right otherwise it would defeat the purpose of having function to another point is that funk 2 must never output a zero ok which means that there’s no step size saurian if it
Returns over zero there would be no step every probe would land on the same cell and the algorithm would go on go into an endless loop so just keep these two points in mind this is an important lecture if you miss something if you don’t understand it I recommend it to
Re-watch it or if you kind of get it that’s okay you can move to the java code type that out and then you can always come back to this and get a refresh on the theory and everything will make a lot more sense ok so let me
Wrap it up here thanks for watching I’ll see you in the next video where we code up the double hashing hash table
-
Sale!
Wireless WIFI Repeater Extender Amplifier Booster 300Mbps
$29.99$14.99 Add to cartWireless WIFI Repeater Extender Amplifier Booster 300Mbps
Categories: Electronics, Wi-Fi Router, Wireless Wi-Fi Extender Tags: 300Mbps, 802.11N, Amplifier, Booster, Extender, mobile wi-fi booster, Remote, WIFI, Wireless, Wireless WIFI, Wireless WIFI Repeater, Wireless WIFI Repeater Extender, Wireless WIFI Repeater Extender Amplifier, Wireless WIFI Repeater Extender Amplifier Booster, Wireless WIFI Repeater Extender Amplifier Booster 300Mbps$29.99$14.99 -
Sale!
Full RGB Light Design Gaming Headset Headphones with Mic
$24.99$14.99 Add to cartFull RGB Light Design Gaming Headset Headphones with Mic
Categories: Electronics, Gaming, Gaming Headsets Tags: Design, Full, Full RGB Light Design Gaming Headset, Full RGB Light Design Gaming Headset Headphones, Full RGB Light Design Gaming Headset Headphones with Mic, Gamer, Gaming, Gaming Headset Headphones, gaming headset wireless, Headphone, Headphones, Headset, Light, Mic, Package, RGB$24.99$14.99 -
Sale!
Wireless BlueTooth Multi-Device Keyboard Mouse Combo
$39.99$19.99 Add to cartWireless BlueTooth Multi-Device Keyboard Mouse Combo
Categories: Electronics, Gaming, Gaming Keyboards, Keyboard Mouse Combos Tags: Combo, Keyboard, keyboard mouse combos, Mouse, MultiDevice, Set, WireKeyboard Mouse Combo, Wireless, Wireless BlueTooth Keyboard Mouse Combo, Wireless BlueTooth Keyboard Mouse Combos, Wireless BlueTooth Multi-Device Keyboard Mouse Combo, Wireless BlueTooth Multi-Device Keyboard Mouse Combos$39.99$19.99 -
Sale!
High Back Leather Executive Adjustable Swivel Gaming Chair with Headrest and Lumbar
$199.99$139.99 Add to cartHigh Back Leather Executive Adjustable Swivel Gaming Chair with Headrest and Lumbar
Categories: Gaming, Gaming Chairs Tags: Adjustable, Chair, computer chairs, Desk, Executive, Gaming, Girl, Headrest, High, High Back Leather Executive Adjustable Swivel Gaming Chair, High Back Leather Executive Adjustable Swivel Gaming Chair with Headrest, High Back Leather Executive Adjustable Swivel Gaming Chair with Headrest and Lumbar, High Back Leather Executive Adjustable Swivel Gaming Chairs, Leather, Lumbar, Office, Racing, Swivel$199.99$139.99 -
Sale!
Professional LED Light Wired Gaming Headphones with Noise Cancelling Microphone
$29.99$19.99 Select optionsProfessional LED Light Wired Gaming Headphones with Noise Cancelling Microphone
SKU: N/A Categories: Electronics, Gaming, Gaming Headsets Tags: Cancelling, Gaming, Gaming Headphones with Noise Cancelling Microphone, gaming headset, Headphones, Headset, LED, Light, Mic, Microphone, Noise, Professional, Professional LED Light Wired Gaming Headphones, Professional LED Light Wired Gaming Headphones with Noise Cancelling Microphone, Wired, Wired Gaming Headphones, Wired Gaming Headphones with Noise Cancelling Microphone$29.99$19.99 -
Sale!
Gaming Desk with LED Lights USB Power Outlets and Charging Ports
$349.99$249.99 Select optionsGaming Desk with LED Lights USB Power Outlets and Charging Ports
SKU: N/A Categories: Computer Desk, Gaming, Gaming Desk Tags: and Charging Ports, Charging, Desk, Desks, Gaming, gaming desk with led lights, Gaming Desks with LED Lights, Home, LED, Lights, Monitor, Office, Outlets, Port, Power, Room, Stand, USB, USB Power Outlets, White, Workstation$349.99$249.99 -
Sale!
Wired Mixed Backlit Anti-Ghosting Gaming Keyboard
$99.99$79.99 Add to cartWired Mixed Backlit Anti-Ghosting Gaming Keyboard
Categories: Electronics, Gaming, Gaming Keyboards Tags: Antighosting, Backlit, Blue, brown, Gaming, Gaming Keyboard, gaming keyboards, gaming keyboards and mouse, Keyboard, Laptop, Switch, Wired, Wired Mixed Backlit Anti-Ghosting Gaming Keyboard, Wired Mixed Backlit Anti-Ghosting Gaming Keyboards, Wired Mixed Backlit Gaming Keyboard$99.99$79.99 -
Sale!
Wireless Bluetooth 5.3 ANC Noise Cancellation Hi-Res Over the Ear Headphones Headset
$119.99$59.99 Add to cartWireless Bluetooth 5.3 ANC Noise Cancellation Hi-Res Over the Ear Headphones Headset
Categories: Electronics, Gaming, Gaming Headsets Tags: 5.3 ANC Noise Cancellation Hi-Res Over the Ear Headphones Headset, ANC, Audio, Bluetooth, Cancellation, Ear, Earphone, gaming headset, Headphones, Headset, Hi-Res Over the Ear Headphones Headset, HiRes, Noise, Wireless, Wireless Bluetooth 5.3 ANC Noise Cancellation Hi-Res Headphones, Wireless Bluetooth 5.3 ANC Noise Cancellation Hi-Res Over the Ear Headphones Headset, Wireless Bluetooth 5.3 ANC Noise Cancellation Hi-Res Over the Ear Headphones Headsets$119.99$59.99 -
Sale!
Wired Sports Gaming Headset Earbuds with Microphone
$19.99$9.99 Select optionsWired Sports Gaming Headset Earbuds with Microphone
SKU: N/A Categories: Gaming, Gaming Headsets Tags: Accessories, Earbud, Earphone, Earphones, Gaming, gaming headset with microphone, Headphones, Headset, IOS, Microphone, Sports, Wired, Wired Sports Gaming Headset Earbuds, Wired Sports Gaming Headset Earbuds with Microphone, Wired Sports Headset Earbuds$19.99$9.99 -
Sale!
150W Universal Multi USB Fast Charger 16 Port MAX Charging Station
$49.99$29.99 Add to cart150W Universal Multi USB Fast Charger 16 Port MAX Charging Station
Categories: Charging Stations, Electronics Tags: 150W, 150W Charging Station, 150W Universal Multi USB Charging Station, 150W Universal Multi USB Fast Charger 16 Port MAX Charging Station, 150W Universal Multi USB Fast Charger 16 Port MAX Charging Stations, 150W Universal Multi USB MAX Charging Station, 16 Port MAX Charging Station, 3.5A, Charger, Charging, Fast, laptop charging stations, Max, Multi, Port, Stand, Station, Universal, USB$49.99$29.99
you sir are the best yt chanel about java
The best tutorial i see about hash table in youtube, what about separate chaining sir?
Mu cmnt is not related to your video tutorial. But plz make a video on creating a jar file containing classes without main method
What if we had another word…say Africa…now we are in trouble…I'm really enjoying this tutorial🤣🤣🤣🤣🤣🤣🤣🤣🤣🤣
Beautifully… Brilliant !!!
Nice tutorial. Like it.
By the way, what software is that, you're using?
hi thanks , when is part 2 ?
first comment is mine.
u r great man. bht easy method me expln kara bhai aapny.great