Design Most Recently Used Queue

Design Most Recently Used Queue - Problem

Design a queue-like data structure that moves the most recently used element to the end of the queue.

Implement the MRUQueue class:

MRUQueue(int n) constructs the MRUQueue with n elements: [1,2,3,...,n].
int fetch(int k) moves the kth element (1-indexed) to the end of the queue and returns it.

Input & Output

Example 1 — Basic Operations

$ Input: operations = ["MRUQueue", "fetch", "fetch", "fetch"], values = [3, 1, 2, 3]

› Output: [1,3,3]

💡 Note: MRUQueue(3) creates [1,2,3]. fetch(1) returns 1, queue becomes [2,3,1]. fetch(2) returns 3, queue becomes [2,1,3]. fetch(3) returns 3, queue becomes [2,1,3].

Example 2 — Repeated Fetch

$ Input: operations = ["MRUQueue", "fetch", "fetch"], values = [2, 2, 1]

› Output: [2, 1]

💡 Note: MRUQueue(2) creates [1,2]. fetch(2) returns 2, queue becomes [1,2]. fetch(1) returns 1, queue becomes [2,1].

Example 3 — Single Element

$ Input: operations = ["MRUQueue", "fetch"], values = [1, 1]

› Output: [1]

💡 Note: MRUQueue(1) creates [1]. fetch(1) returns 1, queue remains [1].

Constraints

1 ≤ n ≤ 2000
1 ≤ k ≤ current queue length
At most 2000 calls will be made to fetch

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Facebook 8

The key insight is choosing the right data structure for efficient element movement. The brute force array approach requires O(n) time per fetch due to element shifting. The doubly linked list approach achieves O(1) per fetch by direct node manipulation. Best approach is doubly linked list. Time: O(1) per operation, Space: O(n)

Common Approaches

✓ Array with Linear Movement

⏱️ Time: O(n) Space: O(n)

Use a simple array to store elements. When fetching element at position k, remove it and append to end by shifting all elements after position k to the left.

Doubly Linked List

⏱️ Time: O(1) Space: O(n)

Maintain a doubly linked list with an array of node references for O(1) access. When fetching element at position k, remove the node and append to tail in O(1) time.

Array with Linear Movement — Algorithm Steps

Initialize array [1,2,3,...,n]
For fetch(k): get element at index k-1
Shift all elements after k-1 one position left
Append the fetched element to end

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Array [1,2,3,4,5]

Fetch(3)

Remove element 3, shift [4,5] left

Result

Append 3 to end: [1,2,4,5,3]

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.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) {
    int element = obj->queue[k - 1];
    for (int i = k - 1; i < obj->size - 1; i++) {
        obj->queue[i] = obj->queue[i + 1];
    }
    obj->queue[obj->size - 1] = element;
    return element;
}

int* solution(char operations[][20], int* values, int opCount, int* returnSize) {
    int* results = (int*)malloc(opCount * sizeof(int));
    int resultCount = 0;
    MRUQueue* mruQueue = NULL;
    
    for (int i = 0; i < opCount; i++) {
        if (strcmp(operations[i], "MRUQueue") == 0) {
            mruQueue = mruQueueCreate(values[i]);
        } else if (strcmp(operations[i], "fetch") == 0) {
            results[resultCount++] = mruQueueFetch(mruQueue, values[i]);
        }
    }
    
    *returnSize = resultCount;
    return results;
}

int main() {
    char operations[100][20];
    int values[100];
    int opCount = 0;
    
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    char* token = strtok(line, "[],\"\n ");
    while (token != NULL) {
        if (strlen(token) > 0) {
            strcpy(operations[opCount], token);
            opCount++;
        }
        token = strtok(NULL, "[],\"\n ");
    }
    
    fgets(line, sizeof(line), stdin);
    token = strtok(line, "[],\n ");
    int valCount = 0;
    while (token != NULL) {
        if (strlen(token) > 0) {
            values[valCount++] = atoi(token);
        }
        token = strtok(NULL, "[],\n ");
    }
    
    int returnSize;
    int* result = solution(operations, values, opCount, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each fetch requires shifting up to n-1 elements

✓ Linear Growth

Space Complexity

O(n)

Array stores n elements

⚡ Linearithmic Space

23.0K Views

Medium Frequency

~25 min Avg. Time

890 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 Movement — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler