Design Most Recently Used Queue - Practice Coding Problems

Design Most Recently Used Queue - Problem

Design a special queue-like data structure that automatically moves the most recently accessed element to the end of the queue. Think of it as a smart queue that keeps frequently used items at the back for easier access patterns.

Your task is to implement the MRUQueue class with the following functionality:

MRUQueue(int n): Initializes the queue with n elements in order [1, 2, 3, ..., n]
int fetch(int k): Retrieves the k-th element (1-indexed) from the current queue, moves it to the end, and returns its value

Example: If you have queue [1, 2, 3, 4, 5] and call fetch(3), you get element 3, and the queue becomes [1, 2, 4, 5, 3].

This pattern is useful in cache systems, priority queues, and adaptive data structures where recently accessed items should be easily accessible.

Input & Output

example_1.py — Basic Operations

$ Input: MRUQueue(8) fetch(3) fetch(5) fetch(2) fetch(8)

› Output: 3 6 2 2

💡 Note: Initial: [1,2,3,4,5,6,7,8] → fetch(3) returns 3, queue: [1,2,4,5,6,7,8,3] → fetch(5) returns 6, queue: [1,2,4,5,7,8,3,6] → fetch(2) returns 2, queue: [1,4,5,7,8,3,6,2] → fetch(8) returns 2, queue: [1,4,5,7,8,3,6,2]

example_2.py — Edge Position Access

$ Input: MRUQueue(5) fetch(1) fetch(5) fetch(3)

› Output: 1 5 4

💡 Note: Initial: [1,2,3,4,5] → fetch(1) returns 1, queue: [2,3,4,5,1] → fetch(5) returns 1, queue: [2,3,4,5,1] → fetch(3) returns 4, queue: [2,3,5,1,4]

example_3.py — Single Element

$ Input: MRUQueue(1) fetch(1) fetch(1)

› Output: 1 1

💡 Note: With only one element, fetch(1) always returns 1 and the queue remains [1]

Constraints

1 ≤ n ≤ 2000
1 ≤ k ≤ current queue length
At most 2000 calls will be made to fetch
All values in the queue are guaranteed to be unique

Visualization

Tap to expand

Understanding the Visualization

Initial Shelf

Books are arranged in order [1,2,3,4,5] on the library shelf

Book Request

A patron requests the 3rd book from the left (book #3)

Remove Book

Librarian takes book #3 from its position, creating a gap

Shift Books

Remaining books slide left to fill the gap: [1,2,4,5,_]

Place at End

Book #3 is placed at the end for easy re-shelving: [1,2,4,5,3]

Key Takeaway

🎯 Key Insight: The MRU Queue simulates a "recently used" priority system where accessed elements are moved to the end, similar to how we organize frequently used items in real life for easy access.

Asked in

G Google 12 a Amazon 8 ⊞ Microsoft 6 f Meta 4

The Most Recently Used Queue can be implemented using a simple array with O(n) fetch operations. For each fetch, we remove the k-th element and append it to the end, requiring element shifting. More advanced solutions using segment trees or balanced trees can achieve O(log n) complexity but add significant implementation complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Array with Linear Operations	O(n)	O(n)	Use a simple array and shift elements manually for each fetch operation

Array with Linear Operations — Algorithm Steps

Initialize array with elements [1, 2, 3, ..., n]
For fetch(k): store the k-th element (1-indexed)
Remove element at index k-1 by shifting all subsequent elements left
Append the removed element to the end of array
Return the fetched element

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Queue contains [1, 2, 3, 4, 5] in order

Fetch(3)

Access element at position 3 (value=3)

Shift Left

Move elements 4,5 one position left

Move to End

Place fetched element 3 at the end

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int* queue;
    int size;
} MRUQueue;

MRUQueue* mruQueueCreate(int n) {
    MRUQueue* obj = (MRUQueue*)malloc(sizeof(MRUQueue));
    obj->queue = (int*)malloc(n * sizeof(int));
    obj->size = n;
    for (int i = 0; i < n; i++) {
        obj->queue[i] = i + 1;
    }
    return obj;
}

int mruQueueFetch(MRUQueue* obj, int k) {
    // Get the k-th element (1-indexed)
    int element = obj->queue[k - 1];
    // Shift elements left
    for (int i = k - 1; i < obj->size - 1; i++) {
        obj->queue[i] = obj->queue[i + 1];
    }
    // Place element at end
    obj->queue[obj->size - 1] = element;
    return element;
}

int main() {
    MRUQueue* mru = mruQueueCreate(5);
    printf("%d\n", mruQueueFetch(mru, 3)); // Returns 3
    printf("%d\n", mruQueueFetch(mru, 1)); // Returns 1
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each fetch operation requires shifting up to n-1 elements in the worst case

✓ Linear Growth

Space Complexity

O(n)

Storage for n elements in the array

⚡ Linearithmic Space

23.8K Views

Medium Frequency

~15 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Array with Linear Operations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler