The python wiki on time complexity lists a single intersection as O(min(len(s), len(t)) where s and t are sets with the sizes len(s) and len(t), respectively. (In English: the time is bounded by and linear in the size of the smaller set.)

Note: based on the comments below, this wiki entry had been be wrong if the argument passed is not a set. I've corrected the wiki entry.

If you have n sets (sets, not iterables), you'll do n-1 intersections and the time can be (n-1)O(len(s)) where s is the set with the smallest size.

Note that as you do an intersection the result may get smaller, so although O is the worst case, in practice, the time will be better than this.

However, looking at the specific code this idea of taking the min() only applies to a single pair of sets and doesn't extend to multiple sets. So in this case, we have to be pessimistic and take s as the set with the largest size.

Let's say there are m elements in the first set, and n in the second set. In general, there's no way to find the result faster than O(m + n). (For some specific problems there may be a faster solution depending on what type of stuff is in the set.) So the main question is how to achieve O(m + n). The most common solution is to use a HashSet. For example: Insert all of the items from the first set (or the smaller set) into a HashSet. Then iterate over all of the items in the second set and test if any of them are in the HashSet. If so, add them to the intersection. Hash tables are generally O(1) to insert and look up. If you're not familiar with them I'd highly recommend learning how they work.

The data structure behind the set is a hash table where the typical performance is an amortized O(1) lookup and insertion.

The intersection algorithm loops exactly min(len(s1), len(s2)) times. It performs one lookup per loop and if there is a match performs an insertion. In pure Python, it looks like this:

    def intersection(self, other):
        if len(self) <= len(other):
            little, big = self, other
        else:
            little, big = other, self
        result = set()
        for elem in little:
            if elem in big:
                result.add(elem)
        return result

Python sets are powerful data structures that resemble mathematical sets. They are implemented using hash tables, similar to dictionaries in Python but only storing keys without associated values. Due to their hash table implementation, most of the common operations on sets have efficient time complexities. Here is an overview of the time complexities for various operations on Python sets: Average Case Time Complexities Insertion (Add): O(1) Adding an element to a set is generally an O(1) operation. The element is hashed, and then placed in a bucket based on its hash value. Deletion (Remove, Discard): O(1) Removing an element, like adding, involves computing its hash and locating it in its bucket, making it an O(1) operation on average. Lookup (Check for membership): O(1) Checking whether an element is in a set is O(1) because it hashes the element and checks the corresponding bucket. Length (Size of the set): O(1) Python stores the number of elements in a set as an instance variable, making the length retrieval operation O(1).

Your post contains two problems. I will only address the first.

There is a simple $O(n)$ algorithm for computing $A \cap B$, which involves an array of length $n$.

Another algorithm sorts $A \cup B$ to find the intersection in time $O(n\log n)$. In contrast to the previous algorithm, this algorithm can be implemented using only comparisons. There is a matching $\Omega(n\log n)$ lower bound in the algebraic decision tree model; see for example lecture notes of Otfried Cheong.