Explain why QuickSort is preferred over MergeSort for Arrays, but MergeSort is preferred for Linked Lists.

QuickSort vs MergeSort for Arrays and Linked Lists

javascript

1
Array QuickSort has average O(n log n) time and can be implemented with O(log n) expected recursion stack.
2
QuickSort has O(n²) worst-case time with poor pivot choices, so production implementations use robust pivoting or hybrid algorithms.
3
Array MergeSort has predictable O(n log n) time but normally requires O(n) auxiliary storage.
4
Linked-list MergeSort has O(n log n) time and can merge by changing next references.
5
Linked lists do not provide efficient random access, making index-based QuickSort partitioning less natural.
6
MergeSort is stable when implemented appropriately, which can be important for linked-list sorting.

Difficulty: 5/10

Topics: QuickSort, MergeSort, Data‑structure choice

0-2 years experience

1
You need to sort an array of integers in place. Which algorithm would you pick and why?
2
Given a singly linked list of numbers, which sorting algorithm would you choose and what property of the list makes that choice better?
3
What happens to QuickSort's performance if the array is already sorted and you always pick the first element as pivot?

2-5 years experience

1
Our service currently uses MergeSort to sort a large array and it's slower than expected. Walk me through how you'd evaluate switching to QuickSort and what pitfalls to watch for.
2
A teammate replaced a QuickSort on a linked list with MergeSort and observed a memory spike. Explain why that happened and how you'd fix it.
3
We frequently sort streams stored as linked lists under high concurrency. How would you decide between in‑place QuickSort and MergeSort given those constraints?

5-8 years experience

1
Design a sorting utility library that must efficiently handle both arrays and linked lists of varying sizes. Explain your API design and algorithm choices to balance time, space, and cache performance.
2
We need to sort a massive dataset that lives partly in memory as arrays and partly on disk as linked structures. Discuss the trade‑offs of using QuickSort vs MergeSort at this scale and any hybrid approaches you’d consider.
3
A regression showed sorting a linked list of 10 million nodes caused a stack overflow. How would you modify the MergeSort implementation to avoid this while preserving its O(n log n) guarantee?

8+ years experience

1
Our platform is migrating legacy code that heavily uses QuickSort on array buffers to a microservice architecture where data is often represented as linked structures for streaming. Outline a migration strategy that minimizes performance regression and technical debt, including algorithm choices and testing.
2
Across multiple teams, some have swapped QuickSort and MergeSort for the wrong data structures, leading to bugs. Propose an organization‑wide guideline and tooling to enforce the correct algorithm per data structure, considering future language changes.
3
Looking ahead, we plan to adopt a persistent immutable list library. How would that affect our choice between QuickSort and MergeSort, and what architectural considerations would you raise?

❓How does cache locality affect QuickSort's performance on large arrays?
❓What is the space complexity difference between the two algorithms for each data structure?
❓If the input is already partially sorted, which algorithm would you favor and why?