Multiple generic parameters in C Sharp (C#) - Time & Space Complexity

Time Complexity: Multiple generic parameters

O(n * m)

Understanding Time Complexity

When using multiple generic parameters in C#, it's important to understand how the program's work grows as input sizes change.

We want to see how the number of operations changes when we have two types of inputs.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

public class PairProcessor<T, U>
{
    public void ProcessPairs(T[] array1, U[] array2)
    {
        foreach (var item1 in array1)
        {
            foreach (var item2 in array2)
            {
                // Some constant time operation
                Console.WriteLine($"{item1} - {item2}");
            }
        }
    }
}
    

This code loops through two arrays of different types and processes every possible pair.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Nested loops over two arrays.
• How many times: Outer loop runs once per element in first array; inner loop runs once per element in second array for each outer loop.

How Execution Grows With Input

Explain the growth pattern intuitively.

Input Size (n, m)	Approx. Operations
10, 10	100
100, 100	10,000
1000, 1000	1,000,000

Pattern observation: The total work grows by multiplying the sizes of both inputs, so doubling either input roughly doubles the total work.

Final Time Complexity

Time Complexity: O(n * m)

This means the work grows proportionally to the product of the sizes of both input arrays.

Common Mistake

[X] Wrong: "The time complexity is just O(n) because we have two loops but they are separate types."

[OK] Correct: Even though the arrays have different types, the loops are nested, so every element of the first array pairs with every element of the second, multiplying the work.

Interview Connect

Understanding how nested loops over different generic types affect time helps you explain performance clearly and shows you can think about how code scales.

Self-Check

"What if the inner loop only ran for half the elements of the second array? How would the time complexity change?"