Pinduoduo·Software Engineer·Technical Phone Screen·Intermediate

Intermediate

Jul 2026

Summary

Pinduoduo SWE interview threw an LRU cache design problem at me, pretty standard stuff for this type of role but the O(1) constraint is where people trip up if they haven't thought it through before.

Questions Asked (1)

Design an LRU cache data structure with get and put operations, both running in O(1) average time complexity.

Algorithms & Data StructuresSystem Design

Author's notes

The question itself is fine if you've seen it before.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the requirements: O(1) get and put, capacity limit, and eviction policy (least recently used). Then propose a combination of a hash map for O(1) access and a doubly linked list for O(1) updates to recency order, explaining how they work together.

Pro tip: Mention that you would use a doubly linked list with dummy head and tail nodes to simplify edge cases, and discuss thread-safety if the cache might be accessed concurrently.

1. Clarify requirements and constraints

Confirm that get returns the value if present and marks it as recently used, put inserts or updates and evicts the least recently used item when capacity is exceeded. Ask about capacity bounds, concurrency, and whether null values are allowed.

2. Choose data structures

Use a hash map (dictionary) to store key -> node references for O(1) lookup, and a doubly linked list to maintain the order of usage, where the head is most recently used and the tail is least recently used.

3. Define node and cache operations

Each node stores key, value, prev, and next pointers. For get: if key exists, move node to head and return value; else return -1. For put: if key exists, update value and move to head; else create new node, add to head, and if capacity exceeded, remove tail node and delete its key from the map.

4. Handle edge cases and optimizations

Use dummy head and tail nodes to avoid null checks. Ensure that when evicting, you remove the key from the hash map as well. Discuss potential concurrency issues and solutions like locks or concurrent data structures if needed.

5. Analyze complexity and test

Explain that both get and put run in O(1) average time due to hash map and linked list operations. Walk through a small example to verify correctness, and mention testing edge cases like capacity 1, repeated gets, and eviction order.

Key Points to Mention

Hash map provides O(1) access to nodes, doubly linked list provides O(1) insertion/deletion and maintains recency order.
Use dummy head and tail nodes to simplify add/remove operations and avoid edge cases.
On get, move accessed node to the front (most recently used).
On put, if key exists update and move to front; if new, add to front and evict from tail if over capacity.
Eviction requires removing the node from both the linked list and the hash map.
Consider thread-safety: use locks or concurrent data structures if the cache is shared across threads.

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.