Sorting Questions at eBay: What to Expect

Sorting questions appear in 25% of eBay’s technical interviews (15 out of 60 problems). This frequency reflects real-world use cases at scale: organizing product listings, ranking search results, processing time-series event data, and optimizing database queries. Efficient sorting directly impacts user experience and system performance, making it a core assessment area for engineering roles.

What to Expect — Types of Problems

eBay’s sorting questions typically fall into three categories:

1. Direct Sorting Applications – Problems where sorting is the primary step, like finding the Kth largest element, merging sorted lists, or removing duplicates. These test your knowledge of built-in sort functions and their time/space trade-offs.

2. Sorting as a Tool for Optimization – Challenges where sorting transforms the problem, such as meeting maximum events, non-overlapping intervals, or two-sum variations. Here, sorting isn’t the end goal but a preprocessing step to enable efficient solutions.

3. Custom Comparator Problems – Scenarios requiring tailored sorting logic, like arranging items by multiple attributes (e.g., price, rating, timestamp) or implementing a specific order (e.g., frequency-based). These assess your ability to adapt sorting to business rules.

Expect follow-ups on time complexity, especially when dealing with large datasets, and questions about stability, in-place sorting, and memory usage.

How to Prepare — Study Tips with One Code Example

Master both library functions and manual implementations. Know the default behavior of sort() in your language and how to write custom comparators. Practice identifying when sorting simplifies a problem—often when you need ordering, grouping, or binary search after preprocessing.

A key pattern is using sorting to turn an O(n²) brute-force solution into O(n log n). For example, finding all pairs with a given difference:

def find_pairs_with_difference(nums, k):
    nums.sort()
    left, right = 0, 1
    result = []
    while right < len(nums):
        diff = nums[right] - nums[left]
        if diff == k:
            result.append((nums[left], nums[right]))
            left += 1
            right += 1
        elif diff < k:
            right += 1
        else:
            left += 1
        if left == right:
            right += 1
    return result

This two-pointer approach after sorting reduces complexity from O(n²) to O(n log n).

Recommended Practice Order

1. Fundamentals: Start with basic sorting algorithms (QuickSort, MergeSort) and their complexities.
2. Library Usage: Solve problems using built-in sort with custom comparators.
3. Pattern Recognition: Tackle interval merging, Kth element, and anagram grouping.
4. Integration: Combine sorting with other techniques (two-pointer, binary search, heap).
5. eBay-Specific: Focus on problems involving ranking, scheduling, and data aggregation.

Practice Sorting at eBay