Explain worst case time complexity of looking up item in Python set and dict is O(n)

Question

I am seeking to understand why the amortised worst-case time complexity of looking up an item in a set (item in set), as well as getting an item in a dictionary (d.get(item)), is O(N), while usually (in an average case scenario) it just takes O(1), as the underlying data structure of set and dictionary is hash table.

Existing posts on Stack Overflow related to this topic either doesn't tackle this question, or is too advanced for a beginner like me. A solution on one post wrote that the time complexity of item in set is O(n) when "your hash table's load factor is too high, then you face collisions". I thought that a set didn't allow duplicate values to be added, and it would also ignore any duplicate values created initially. How does a collision happen in a set and how exactly does that make the time complexity go from O(1) to O(n)? How about in a dictionary?

What is the conceptual explanation? What would some simple code examples be?

---

To explain it simply for people who are also confused about collisions and duplicates like me before this, the values don't need to be duplicates to have hash collision.

For example, "apple" and "banana" are not duplicates, so they can be added to the same set, but depending on the hash function, the hash values that are computed for "apple" and for "banana" separately may be the same, which leads to a hash collision.

The answers and comments below explain why a hash collision leads to longer searching time, and to O(N) in the worst case when every value in a set collides.

Answer 1

The collision is mainly due to the functions that Python uses for hashing the values in a set or dictionary. In hashing, a hash function is used to map an item to a unique hash value. Ideally, each item should have a unique hash value, and the hash table (used internally by sets and dictionaries) would have one item per bucket. However, due to the nature of hash functions and the finite number of possible hash values, collisions can occur.

For example, let's say that your set/dict have two items, "apple" and "banana", and their hash values are calculated to be the same. In such cases, the hash table needs to handle these collisions and resolve them.

Python's implementation of sets and dictionaries uses a technique called separate chaining to handle hash collisions. Each bucket in the hash table contains a linked list of items that have collided. When a collision occurs, the new item is appended to the linked list in that bucket.

Now, when you perform a lookup operation on a set or dictionary, Python uses the hash value of the item you're searching for to locate the corresponding bucket. It then traverses the linked list in that bucket to find the exact match. If there are multiple items in the linked list, Python needs to iterate through them until it finds the desired item or reaches the end of the list.

Therefore, in the worst-case scenario, all items in your set/dict are having the same hash value, and then the function will need to search through that single bucket containing all items in your set/dict, and that's why the complexity is O(n). Again this is the worst-case scenario and it's very rare.

Answer 2

To achieve the desired result with dictionaries, you can use nested loops to iterate over the keys and values of the original dictionary and compute the product of values. However, you need to keep track of the combinations that have already been computed to avoid redundant entries.

Here's an example of how you can accomplish this:

d = {'a': 0, 'b': 1, 'c': 2}
result = {}

for key1, value1 in d.items():
    for key2, value2 in d.items():
        if key1 <= key2:  # To avoid redundant computations
            new_key = key1 + '#' + key2
            result[new_key] = value1 * value2

print(result)

Output:

{'a#a': 0, 'a#b': 0, 'a#c': 0, 'b#b': 1, 'b#c': 2, 'c#c': 4}

In this code, the outer loop iterates over the keys and values of the dictionary d. The inner loop iterates from the current key to the end of the dictionary to avoid redundant computations (e.g., avoiding b#a when a#b has already been computed). The product of the values is calculated and stored in the result dictionary with the appropriate key.

By checking key1 <= key2, we ensure that each combination is computed only once. This condition guarantees that the ordering of the keys doesn't affect the result, preventing duplicates such as a#b and b#a.

I hope this helps! Let me know if you have any further questions.