GATE-CS-2000 Problem 18

This problem is from the GATE Computer Science examination conducted in the year 2000. It tests the concepts related to data structures and algorithms.

Problem Statement

Consider the following data structure for representing a set of integers.

struct Set {
    int size;
    int *elements;
};

Assume that we have initially allocated sufficient memory for the elements array. The following functions are provided:

int size_of_set(struct Set *S);
int is_element_of(struct Set *S, int x);
void insert_element(struct Set *S, int x);
void delete_element(struct Set *S, int x);

These functions operate on the set S and are used as follows:

• size_of_set(S) returns the number of elements in S.
• is_element_of(S, x) returns true if x is an element of S, false otherwise.
• insert_element(S, x) inserts x into S.
• delete_element(S, x) deletes x from S.

You are required to implement the following function:

struct Set *set_intersection(struct Set *A, struct Set *B);

This function returns a pointer to a set which contains the elements common to sets A and B, i.e., the set C where C = A ∩ B.

Solution

The function set_intersection can be implemented using a hash table. We can first insert all elements of set A into a hash table and then iterate over all elements of set B to check if they are present in the hash table. If an element is present, we add it to the resulting set.

Here is the implementation in Python:

def set_intersection(A, B):
    # Create a hash table for set A
    hash_table = {}
    for elem in A.elements:
        hash_table[elem] = True

    # Create a set for the intersection
    C = Set()
    C.size = 0
    C.elements = []

    # Iterate over elements of set B
    for elem in B.elements:
        # Check if element is present in hash table
        if elem in hash_table:
            # Add element to set C
            C.elements.append(elem)
            C.size += 1

    return C

Note that we are assuming that the hash table has a constant time insertion, deletion, and lookup complexity. In practice, we can use a hash table implementation such as Python's dict for this purpose.

Conclusion

In this problem, we saw how to implement a set intersection operation using a hash table. This technique can be extended to other set operations such as union and difference as well. The implementation in Python used a simple hash table implementation, but in practice, we should use a more efficient implementation such as Python's dict.