While there are many types of probing in hash tables, such as linear probing,  quadratic probing, and more, I haven't encountered a so-called hash-probing (maybe this method which I describe below exits and I just don't know its name, and if that is the case I would love some references). This is the concept:When generating a hash table of size $m$, generate an assisting array of size $m$, for which every index will be given a different hash function from a universal (or almost universal) hash family.When inserting/deleting an item from the hash table, we use probing, for which if the first index in the hash table is taken, calculate the second index to be checked using the second hash function from the array, and so on...Each calculation will be $O(1)$ (by itself).Now - the goal is to avoid problems such as clustering that occurs in linear probing which can cause the time complexity to increase when the load factor rises.I'm pretty sure this method I suggested now is flawed, since I haven't encountered this method anywhere, but I couldn't formally point to the flaws of the method.One idea I've come up with is that by using different hash functions we cannot guarantee that the second (nor the third, etc..) hash function for a given item $x$ will not result in the same value (i.e the same index in the hash table), but I'm not sure about this since for big hash tables (and therefore many hash functions), cannot we expect a low amount of collisions (for the same item by different functions)?Would love some comments on the method and my last analysis (and/or references). Thanks.EDIT:Well, I've went on to try to implement it in order to make some tests on efficiency, but then I've noticed two extremely major flaws in this method:Unsuccessful search will always be $O(m)$, since you need to go all over the hahs function in the hash-array.Deletion - when we delete an item from the table, we can't correct the table, unless we rehash it, which will be $O(m)$ as well.I don't think this method works, because of this two flaws, but if someone has an idea on how to avoid those (and not changing the method much, or suggesting cuckoo hashing) it will be interesting to read.Thanks.
Hash Probing?
data structures;hash;hash tables