Codestin Search App

Design Front Middle Back Queue - Problem

Array Linked List Design Queue Data Stream Medium

Design a Flexible Multi-Position Queue

You need to design a special queue data structure that supports push and pop operations at three different positions: front, middle, and back.

Your FrontMiddleBackQueue class should implement:
• pushFront(val) - Add element to the front
• pushMiddle(val) - Add element to the middle position
• pushBack(val) - Add element to the back
• popFront() - Remove and return front element
• popMiddle() - Remove and return middle element
• popBack() - Remove and return back element

Key Rules:
1. When there are two middle positions, choose the frontmost one
2. Return -1 if trying to pop from an empty queue

Examples:
• Pushing 6 into middle of [1,2,3,4,5] → [1,2,6,3,4,5]
• Popping middle from [1,2,3,4,5,6] → returns 3, queue becomes [1,2,4,5,6]

Input & Output

example_1.py — Basic Operations

$ Input: ["FrontMiddleBackQueue", "pushFront", "pushBack", "pushMiddle", "popFront", "popMiddle", "popBack"] [[], [1], [2], [3], [], [], []]

› Output: [null, null, null, null, 1, 3, 2]

💡 Note: Initialize empty queue, push 1 to front: [1], push 2 to back: [1,2], push 3 to middle: [1,3,2], pop front returns 1: [3,2], pop middle returns 3: [2], pop back returns 2: []

example_2.py — Middle Position Rules

$ Input: ["FrontMiddleBackQueue", "pushBack", "pushBack", "pushBack", "pushBack", "popMiddle", "popMiddle"] [[], [1], [2], [3], [4], [], []]

› Output: [null, null, null, null, null, 2, 3]

💡 Note: Build queue [1,2,3,4]. For even length 4, middle positions are indices 1,2. Choose frontmost (index 1): pop 2, queue becomes [1,3,4]. Now length 3, middle is index 1: pop 3.

example_3.py — Empty Queue Edge Case

$ Input: ["FrontMiddleBackQueue", "popFront", "popMiddle", "popBack", "pushMiddle", "popMiddle"] [[], [], [], [], [1], []]

› Output: [null, -1, -1, -1, null, 1]

💡 Note: All pop operations on empty queue return -1. After pushing 1 to middle of empty queue: [1], popping middle returns 1.

Constraints

1 ≤ val ≤ 10⁹
At most 1000 calls will be made to pushFront, pushMiddle, pushBack, popFront, popMiddle, and popBack
All values are positive integers

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

Set up two balanced sections (left and right halves) with a manager for each

Balance Rule

Left section can have at most 1 more person than right section

Middle Access

Middle seat is always at the boundary - end of left section when balanced

Efficient Operations

Most seating/departures are O(1) with occasional rebalancing between sections

Key Takeaway

🎯 Key Insight: By splitting the queue into two balanced deques with the middle always at their boundary, we achieve O(1) performance for all operations while maintaining the correct middle position semantics.

Asked in

G Google 45 a Amazon 38 f Meta 28 ⊞ Microsoft 22

The optimal approach uses two balanced deques to represent the left and right halves of the queue. By maintaining the invariant that the left deque has at most one more element than the right deque, we ensure that the middle element is always at the boundary between the two halves. This design enables O(1) operations for most cases with only occasional rebalancing needed.

Common Approaches

Approach	Time	Space	Notes
✓ Two Deques (Balanced Halves)	O(1)	O(n)	Use two deques to represent left and right halves with balancing

Two Deques (Balanced Halves) — Algorithm Steps

Initialize two deques: left and right
Maintain balance: len(left) <= len(right) + 1
Middle is at end of left deque when balanced
Rebalance after each operation by moving elements between deques
Front operations use left deque, back operations use right deque

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Balanced State

Left: [1,2,3], Right: [4,5] - Middle is 3

Push Middle

Insert at end of left, then rebalance if needed

Balanced Result

Left: [1,2,6], Right: [3,4,5] - New middle is 6

Code -

solution.c — C

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

typedef struct {
    int* left;
    int* right;
    int leftSize, rightSize;
    int leftCap, rightCap;
} FrontMiddleBackQueue;

FrontMiddleBackQueue* frontMiddleBackQueueCreate() {
    FrontMiddleBackQueue* obj = malloc(sizeof(FrontMiddleBackQueue));
    obj->leftCap = obj->rightCap = 1000;
    obj->left = malloc(obj->leftCap * sizeof(int));
    obj->right = malloc(obj->rightCap * sizeof(int));
    obj->leftSize = obj->rightSize = 0;
    return obj;
}

void balance(FrontMiddleBackQueue* obj) {
    if (obj->leftSize > obj->rightSize + 1) {
        // Move last element of left to front of right
        for (int i = obj->rightSize; i > 0; i--) {
            obj->right[i] = obj->right[i-1];
        }
        obj->right[0] = obj->left[obj->leftSize-1];
        obj->leftSize--;
        obj->rightSize++;
    } else if (obj->leftSize < obj->rightSize) {
        // Move first element of right to end of left
        obj->left[obj->leftSize] = obj->right[0];
        for (int i = 0; i < obj->rightSize-1; i++) {
            obj->right[i] = obj->right[i+1];
        }
        obj->leftSize++;
        obj->rightSize--;
    }
}

void frontMiddleBackQueuePushFront(FrontMiddleBackQueue* obj, int val) {
    for (int i = obj->leftSize; i > 0; i--) {
        obj->left[i] = obj->left[i-1];
    }
    obj->left[0] = val;
    obj->leftSize++;
    balance(obj);
}

void frontMiddleBackQueuePushMiddle(FrontMiddleBackQueue* obj, int val) {
    if (obj->leftSize > obj->rightSize) {
        for (int i = obj->rightSize; i > 0; i--) {
            obj->right[i] = obj->right[i-1];
        }
        obj->right[0] = obj->left[obj->leftSize-1];
        obj->leftSize--;
        obj->rightSize++;
    }
    obj->left[obj->leftSize++] = val;
    balance(obj);
}

void frontMiddleBackQueuePushBack(FrontMiddleBackQueue* obj, int val) {
    obj->right[obj->rightSize++] = val;
    balance(obj);
}

int frontMiddleBackQueuePopFront(FrontMiddleBackQueue* obj) {
    if (obj->leftSize == 0 && obj->rightSize == 0) return -1;
    int val;
    if (obj->leftSize > 0) {
        val = obj->left[0];
        for (int i = 0; i < obj->leftSize-1; i++) {
            obj->left[i] = obj->left[i+1];
        }
        obj->leftSize--;
    } else {
        val = obj->right[0];
        for (int i = 0; i < obj->rightSize-1; i++) {
            obj->right[i] = obj->right[i+1];
        }
        obj->rightSize--;
    }
    balance(obj);
    return val;
}

int frontMiddleBackQueuePopMiddle(FrontMiddleBackQueue* obj) {
    if (obj->leftSize == 0 && obj->rightSize == 0) return -1;
    int val;
    if (obj->leftSize > obj->rightSize) {
        val = obj->left[--obj->leftSize];
    } else {
        if (obj->leftSize > 0) {
            val = obj->left[--obj->leftSize];
        } else {
            val = obj->right[0];
            for (int i = 0; i < obj->rightSize-1; i++) {
                obj->right[i] = obj->right[i+1];
            }
            obj->rightSize--;
        }
    }
    balance(obj);
    return val;
}

int frontMiddleBackQueuePopBack(FrontMiddleBackQueue* obj) {
    if (obj->leftSize == 0 && obj->rightSize == 0) return -1;
    int val;
    if (obj->rightSize > 0) {
        val = obj->right[--obj->rightSize];
    } else {
        val = obj->left[--obj->leftSize];
    }
    balance(obj);
    return val;
}

void frontMiddleBackQueueFree(FrontMiddleBackQueue* obj) {
    free(obj->left);
    free(obj->right);
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Most operations are O(1), occasional O(1) rebalancing

✓ Linear Growth

Space Complexity

O(n)

Store n elements across two deques

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~25 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

Two Deques (Balanced Halves) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler