└── README.md /README.md: -------------------------------------------------------------------------------- 1 | # 55 Fundamental Queue Data Structure Interview Questions in 2025 2 | 3 |
4 |

5 | 6 | data-structures-and-algorithms 7 | 8 |

9 | 10 | #### You can also find all 55 answers here 👉 [Devinterview.io - Queue Data Structure](https://devinterview.io/questions/data-structures-and-algorithms/queue-data-structure-interview-questions) 11 | 12 |
13 | 14 | ## 1. What is a _Queue_? 15 | 16 | A **queue** is a data structure that adheres to the **First-In-First-Out (FIFO)** principle and is designed to hold a collection of elements. 17 | 18 | ### Core Operations 19 | 20 | - **Enqueue**: Adding an element to the end of the queue. 21 | - **Dequeue**: Removing an element from the front of the queue. 22 | - **IsEmpty**: Checks if the queue is empty. 23 | - **IsFull**: Checks if the queue has reached its capacity. 24 | - **Peek**: Views the front element without removal. 25 | 26 | All operations have a space complexity of $O(1)$ and time complexity of $O(1)$, except for **Search**, which has $O(n)$ time complexity. 27 | 28 | ### Key Characteristics 29 | 30 | 1. **Order**: Maintains the order of elements according to their arrival time. 31 | 2. **Size**: Can be either bounded (fixed size) or unbounded (dynamic size). 32 | 3. **Accessibility**: Typically provides only restricted access to elements in front and at the rear. 33 | 4. **Time Complexity**: The time required to perform enqueue and dequeue is usually $O(1)$. 34 | 35 | ### Visual Representation 36 | 37 | ![Queue](https://firebasestorage.googleapis.com/v0/b/dev-stack-app.appspot.com/o/queues%2Fsimple-queue.svg?alt=media&token=976157b7-407b-4523-b8df-61f79bc1fafc) 38 | 39 | ### Real-World Examples 40 | 41 | - **Ticket Counter**: People form a queue, and the first person who joined the queue gets the ticket first. 42 | - **Printer Queue**: Print jobs are processed in the order they were sent to the printer. 43 | 44 | ### Practical Applications 45 | 46 | 1. **Task Scheduling**: Used by operating systems for managing processes ready to execute or awaiting specific events. 47 | 2. **Handling of Requests**: Servers in multi-threaded environments queue multiple user requests, processing them in arrival order. 48 | 3. **Data Buffering**: Supports asynchronous data transfers between processes, such as in IO buffers and pipes. 49 | 4. **Breadth-First Search**: Employed in graph algorithms, like BFS, to manage nodes for exploration. 50 | 5. **Order Processing**: E-commerce platforms queue customer orders for processing. 51 | 6. **Call Center Systems**: Incoming calls wait in a queue before connecting to the next available representative. 52 | 53 | ### Code Example: Queue 54 | 55 | Here is the Python code: 56 | 57 | ```python 58 | from collections import deque 59 | 60 | class Queue: 61 | def __init__(self): 62 | self.queue = deque() 63 | 64 | def enqueue(self, item): 65 | self.queue.append(item) 66 | 67 | def dequeue(self): 68 | if not self.is_empty(): 69 | return self.queue.popleft() 70 | raise Exception("Queue is empty.") 71 | 72 | def size(self): 73 | return len(self.queue) 74 | 75 | def is_empty(self): 76 | return len(self.queue) == 0 77 | 78 | def front(self): 79 | if not self.is_empty(): 80 | return self.queue[0] 81 | raise Exception("Queue is empty.") 82 | 83 | def rear(self): 84 | if not self.is_empty(): 85 | return self.queue[-1] 86 | raise Exception("Queue is empty.") 87 | 88 | # Example Usage 89 | q = Queue() 90 | q.enqueue(5) 91 | q.enqueue(6) 92 | q.enqueue(3) 93 | q.enqueue(2) 94 | q.enqueue(7) 95 | print("Queue:", list(q.queue)) 96 | print("Front:", q.front()) 97 | print("Rear:", q.rear()) 98 | q.dequeue() 99 | print("After dequeue:", list(q.queue)) 100 | ``` 101 |
102 | 103 | ## 2. Explain the _FIFO (First In, First Out)_ policy that characterizes a _Queue_. 104 | 105 | The **FIFO (First-In-First-Out)** policy governs the way **Queues** handle their elements. Elements are processed and removed from the queue in the same order in which they were added. The data structures responsible for adhering to this policy are specifically designed to optimize for this principle, making them ideal for a host of real-world applications. 106 | 107 | ### Core Mechanism 108 | 109 | Elements are typically added to the **rear** and removed from the **front**. This design choice ensures that the earliest elements, those closest to the front, are processed and eliminated first. 110 | 111 | ### Fundamental Operations 112 | 113 | 1. **Enqueue (Add)**: New elements are positioned at the rear end. 114 | 2. **Dequeue (Remove)**: Front element is removed from the queue. 115 | 116 | In the above diagram: 117 | 118 | - **Front**: Pointing to the element about to be dequeued. 119 | - **Rear**: Position where new elements will be enqueued. 120 |
121 | 122 | ## 3. Name some _Types of Queues_. 123 | 124 | **Queues** are adaptable data structures with diverse types, each optimized for specific tasks. Let's explore the different forms of queues and their functionalities. 125 | 126 | ### Simple Queue 127 | 128 | A **Simple Queue** follows the basic **FIFO** principle. This means items are added at the end and removed from the beginning. 129 | 130 | #### Visual Representation 131 | 132 | ![Simple Queue](https://firebasestorage.googleapis.com/v0/b/dev-stack-app.appspot.com/o/queues%2Fsimple-queue.svg?alt=media&token=976157b7-407b-4523-b8df-61f79bc1fafc) 133 | 134 | #### Implementation 135 | 136 | Here is the Python code: 137 | 138 | ```python 139 | class SimpleQueue: 140 | def __init__(self): 141 | self.queue = [] 142 | 143 | def enqueue(self, item): 144 | self.queue.append(item) 145 | 146 | def dequeue(self): 147 | if not self.is_empty(): 148 | return self.queue.pop(0) 149 | 150 | def is_empty(self): 151 | return len(self.queue) == 0 152 | 153 | def size(self): 154 | return len(self.queue) 155 | ``` 156 | 157 | ### Circular Queue 158 | 159 | In a **Circular Queue** the last element points to the first element, making a circular link. This structure uses a **fixed-size array** and can wrap around upon reaching the end. It's more **memory efficient** than a Simple Queue, reusing positions at the front that are left empty by the dequeue operations. 160 | 161 | #### Visual Representation 162 | 163 | ![Circular Queue](https://firebasestorage.googleapis.com/v0/b/dev-stack-app.appspot.com/o/queues%2Fcircular-queue.svg?alt=media&token=31e68b64-92a8-45f7-84c4-0ba8eb929ee8) 164 | 165 | #### Implementation 166 | 167 | Here is the Python code: 168 | 169 | ```python 170 | class CircularQueue: 171 | def __init__(self, k): 172 | self.queue = [None] * k 173 | self.size = k 174 | self.front = self.rear = -1 175 | 176 | def enqueue(self, item): 177 | if self.is_full(): 178 | return "Queue is full" 179 | elif self.is_empty(): 180 | self.front = self.rear = 0 181 | else: 182 | self.rear = (self.rear + 1) % self.size 183 | self.queue[self.rear] = item 184 | 185 | def dequeue(self): 186 | if self.is_empty(): 187 | return "Queue is empty" 188 | elif self.front == self.rear: 189 | temp = self.queue[self.front] 190 | self.front = self.rear = -1 191 | return temp 192 | else: 193 | temp = self.queue[self.front] 194 | self.front = (self.front + 1) % self.size 195 | return temp 196 | 197 | def is_empty(self): 198 | return self.front == -1 199 | 200 | def is_full(self): 201 | return (self.rear + 1) % self.size == self.front 202 | ``` 203 | 204 | ### Priority Queue 205 | 206 | A **Priority Queue** gives each item a priority. Items with higher priorities are dequeued before those with lower priorities. This is useful in scenarios like task scheduling where some tasks need to be processed before others. 207 | 208 | #### Visual Representation 209 | 210 | ![Priority Queue](https://firebasestorage.googleapis.com/v0/b/dev-stack-app.appspot.com/o/queues%2Fpriority-queue.svg?alt=media&token=df8214e1-9ba6-4aaf-9f79-bd5334a234af) 211 | 212 | #### Implementation 213 | 214 | Here is the Python code: 215 | 216 | ```python 217 | class PriorityQueue: 218 | def __init__(self): 219 | self.queue = [] 220 | 221 | def enqueue(self, item, priority): 222 | self.queue.append((item, priority)) 223 | self.queue.sort(key=lambda x: x[1], reverse=True) 224 | 225 | def dequeue(self): 226 | if not self.is_empty(): 227 | return self.queue.pop(0)[0] 228 | 229 | def is_empty(self): 230 | return len(self.queue) == 0 231 | ``` 232 | 233 | ### Double-Ended Queue (De-queue) 234 | 235 | A **Double-Ended Queue** allows items to be added or removed from both ends, giving it **more flexibility** compared to a simple queue. 236 | 237 | #### Visual Representation 238 | 239 | ![De-queue](https://firebasestorage.googleapis.com/v0/b/dev-stack-app.appspot.com/o/queues%2Fdouble-ended.svg?alt=media&token=acca0731-3dd3-4af0-bbad-86739fb0506a) 240 | 241 | #### Implementation 242 | 243 | Here is the Python code: 244 | 245 | ```python 246 | from collections import deque 247 | 248 | de_queue = deque() 249 | de_queue.append(1) # Add to rear 250 | de_queue.appendleft(2) # Add to front 251 | de_queue.pop() # Remove from rear 252 | de_queue.popleft() # Remove from front 253 | ``` 254 | 255 | ### Input-Restricted Deque and Output-Restricted Deque 256 | 257 | An **Input-Restricted Deque** only allows items to be added at one end, while an **Output-Restricted Deque** limits removals to one end. 258 | 259 | #### Visual Representation 260 | 261 | **Input-Restricted Deque** 262 | 263 | ![Input-Restricted Deque](https://firebasestorage.googleapis.com/v0/b/dev-stack-app.appspot.com/o/queues%2Fimput-restricted-deque.svg?alt=media&token=6ca0c591-ed53-40be-b410-3aea8fa519b0) 264 | 265 | **Output-Restricted Deque** 266 | 267 | ![Output-Restricted Deque](https://firebasestorage.googleapis.com/v0/b/dev-stack-app.appspot.com/o/queues%2Foutput-restricted-deque.svg?alt=media&token=d304afbd-5ac3-47bb-b58e-759648c0761d) 268 |
269 | 270 | ## 4. What is a _Priority Queue_ and how does it differ from a standard _Queue_? 271 | 272 | **Queues** are data structures that follow a **FIFO** (First-In, First-Out) order, where elements are removed in the same sequence they were added. 273 | 274 | **Priority Queues**, on the other hand, are more dynamic and cater to elements with **varying priorities**. A key distinction is that while queues prioritize the order in which items are processed, a priority queue dictates the sequence based on the priority assigned to each element. 275 | 276 | ### Core Differences 277 | 278 | - **Order:** Queues ensure a consistent, predefined processing sequence, whereas priority queues handle items based on their assigned priority levels. 279 | 280 | - **Elements Removal:** Queues remove the oldest element, while priority queues remove the highest-priority item. This results in a different set of elements being dequeued in each case. 281 | 282 | - **Queues**: 1, 2, 3, 4, 5 283 | - **Priority Queue**: (assuming '4' has the highest priority): 4, 2, 6, 3, 1 284 | 285 | - **Support Functions**: Since queues rely on a standard FIFO flow, they present standard methods like `enqueue` and `dequeue`. In contrast, priority queues offer means to set priorities and locate/query elements based on their priority levels. 286 | 287 | ### Implementation Methods 288 | 289 | #### Array List 290 | - **Queues**: Direct support. 291 | - **Priority Queues**: Manage elements to sustain a specific order. 292 | 293 | #### Linked List 294 | - **Queues**: Convenient for dynamic sizing and additions. 295 | - **Priority Queues**: Manual management of element ordering. 296 | 297 | #### Binary Trees 298 | - **Queues**: Not common but a viable approach using structures like Heaps. 299 | 300 | - **Priority Queues**: Specifically utilized for priority queues to ensure efficient operations based on priorities. 301 | 302 | 4. **Hash Tables** 303 | - **Queues**: Suitable for more sophisticated, fine-tuned queues. 304 | - **Priority Queues**: Can be combined with other structures for varied implementations. 305 | 306 | ### Typical Use-Cases 307 | 308 | - **Queues**: Appropriate for scenarios where "**first come, first serve**" is fundamental, such as in printing tasks or handling multiple requests. 309 | - **Priority Queues**: More Suitable for contexts that require managing and completing tasks in an "**order of urgency**" or "**order of importance**", like in real-time systems, traffic routing, or resource allocation. 310 |
311 | 312 | ## 5. When should I use a _Stack_ or a _Queue_ instead of _Arrays/Lists_? 313 | 314 | **Queues** and **Stacks** provide structured ways to handle data, offering distinct advantages over more generic structures like **Lists** or **Arrays**. 315 | 316 | ### Key Features 317 | 318 | #### Queues 319 | 320 | - **Characteristic**: First-In-First-Out (FIFO) 321 | - **Usage**: Ideal for ordered processing, such as print queues or BFS traversal. 322 | 323 | #### Stacks 324 | 325 | - **Characteristic**: Last-In-First-Out (LIFO) 326 | - **Usage**: Perfect for tasks requiring reverse order like undo actions or DFS traversal. 327 | 328 | #### Lists/Arrays 329 | 330 | - **Characteristic**: Random Access 331 | - **Usage**: Suitable when you need random access to elements or don't require strict order or data management. 332 |
333 | 334 | ## 6. How do you reverse a _Queue_? 335 | 336 | Reversing a queue can be accomplished **using a single stack** or **recursively**. Both methods ensure the first element in the input queue becomes the last in the resultant queue. 337 | 338 | ### Single-Stack Method 339 | 340 | Here are the steps: 341 | 342 | 1. **Transfer Input to Stack**: While the input queue isn't empty, **dequeue** elements and **push** them to the stack. 343 | 2. **Transfer Stack to Output**: Then, **pop** elements from the stack and **enqueue** them back to the queue. This reverses their order. 344 | 345 | ### Code Example: Reversing a Queue with a Stack 346 | 347 | Here is the Python code: 348 | 349 | ```python 350 | def reverse_queue(q): 351 | if not q: # Base case: queue is empty 352 | return 353 | stack = [] 354 | while q: 355 | stack.append(q.pop(0)) # Transfer queue to stack 356 | while stack: 357 | q.append(stack.pop()) # Transfer stack back to queue 358 | return q 359 | 360 | # Test 361 | q = [1, 2, 3, 4, 5] 362 | print(f"Original queue: {q}") 363 | reverse_queue(q) 364 | print(f"Reversed queue: {q}") 365 | ``` 366 | 367 | ### Complexity Analysis 368 | 369 | - **Time Complexity**: $O(n)$ as it involves one pass through both the queue and the stack for a queue of size $n$. 370 | - **Space Complexity**: $O(n)$ - $n$ space is used to store the elements in the stack. 371 | 372 | ### Using Recursion 373 | 374 | To reverse a queue **recursively**, you can follow this approach: 375 | 376 | 1. **Base Case**: If the queue is empty, stop. 377 | 2. **Recurse**: Call the reverse function recursively until all elements are dequeued. 378 | 3. **Enqueue Last Element**: For each item being dequeued, enqueue it back into the queue after the recursion bottoms out, effectively reversing the order. 379 | 380 | ### Code Example: Reversing a Queue Recursively 381 | 382 | Here is the Python code: 383 | 384 | ```python 385 | def reverse_queue_recursively(q): 386 | if not q: 387 | return 388 | front = q.pop(0) # Dequeue the first element 389 | reverse_queue_recursively(q) # Recurse for the remaining queue 390 | q.append(front) # Enqueue the previously dequeued element at the end 391 | return q 392 | 393 | # Test 394 | q = [1, 2, 3, 4, 5] 395 | print(f"Original queue: {q}") 396 | reverse_queue_recursively(q) 397 | print(f"Reversed queue: {q}") 398 | ``` 399 | 400 | ### Complexity Analysis 401 | 402 | - **Time Complexity**: $O(n^2)$ - this is because each dequeue operation on the queue in the recursion stack is an $O(n)$ operation, and these operations occur in sequence for a queue of size $n$. Therefore, we get $n + (n-1) + \ldots + 1 = \frac{n(n+1)}{2}$ in the worst case. While this can technically be represented as $O(n^2)$, in practical scenarios for small queues, it can have a time complexity of $O(n)$. 403 | - **Space Complexity**: $O(n)$ - $n$ depth comes from the recursion stack for a queue of $n$ elements 404 |
405 | 406 | ## 7. Can a queue be implemented as a static data structure and if so, what are the limitations? 407 | 408 | **Static queues** use a pre-defined amount of memory, typically an array, for efficient FIFO data handling. 409 | 410 | ### Limitations of Static Queues 411 | 412 | 1. **Fixed Capacity**: A static queue cannot dynamically adjust its size based on data volume or system requirements. As a result, it can become either underutilized or incapable of accommodating additional items. 413 | 414 | 2. **Memory Fragmentation**: If there's not enough contiguous memory to support queue expansion or changes, memory fragmentation occurs. This means that even if there's available memory in the system, it may not be usable by the static queue. 415 | 416 | Memory fragmentation is more likely in long-running systems or when the queue has a high rate of enqueueing and dequeueing due to the "moving window" of occupied and freed space. 417 | 418 | 3. **Potential for Data Loss**: Enqueuing an item into a full static queue results in data loss. As there's no mechanism to signify that storage was exhausted, it's essential to maintain methods to keep track of the queue's status. 419 | 420 | 4. **Time-Consuming Expansion**: If the queue were to support expansion, it would require operations in $O(n)$ time - linear with the current size of the queue. This computational complexity is a significant downside compared to the $O(1)$ time complexity offered by dynamic queues. 421 | 422 | 5. **Inefficient Memory Usage**: A static queue reserved a set amount of memory for its potential max size, which can be a wasteful use of resources if the queue seldom reaches that max size. 423 |
424 | 425 | ## 8. Write an algorithm to _enqueue_ and _dequeue_ an item from a _Queue_. 426 | 427 | ### Problem Statement 428 | 429 | The task is to write an algorithm to perform both **enqueue** (add an item) and **dequeue** (remove an item) operations on a **queue**. 430 | 431 | ### Solution 432 | 433 | A Queue, often used in real-world scenarios with first-in, first-out (FIFO) logic, can be implemented using an array (for fixed-size) or linked list (for dynamic size). 434 | 435 | #### Algorithm Steps 436 | 437 | 1. **Enqueue Operation**: Add an item at the `rear` of the queue. 438 | 2. **Dequeue Operation**: Remove the item at the `front` of the queue. 439 | 440 | #### Implementation 441 | 442 | Here is the Python code: 443 | 444 | ```python 445 | class Queue: 446 | def __init__(self): 447 | self.items = [] 448 | 449 | def enqueue(self, item): 450 | self.items.append(item) 451 | 452 | def dequeue(self): 453 | if not self.is_empty(): 454 | return self.items.pop(0) 455 | return "Queue is empty" 456 | 457 | def is_empty(self): 458 | return self.items == [] 459 | 460 | def size(self): 461 | return len(self.items) 462 | 463 | # Example 464 | q = Queue() 465 | q.enqueue(2) 466 | q.enqueue(4) 467 | q.enqueue(6) 468 | print("Dequeued:", q.dequeue()) # Output: Dequeued: 2 469 | ``` 470 | 471 | In this Python implementation, the `enqueue` operation has a time complexity of $O(1)$ while the `dequeue` operation has a time complexity of $O(n)$. 472 |
473 | 474 | ## 9. How to implement a _Queue_ such that _enqueue_ has _O(1)_ and _dequeue_ has _O(n)_ complexity? 475 | 476 | One way to achieve **$O(1)$** enqueue and **$O(n)$** dequeue times is with a **linked-list**. You can keep the tail pointer always. Enqueues don't need to perform more than a couple of cheap link operations. 477 | 478 | However, dequeue operations on a single-ended list are costly, potentially traversing the whole list. To keep dequeue times acceptable, you might want to limit the number of elements you enqueue before you're allowed to dequeue elements. You could define a fixed size for the list e.g. 100 or 1000, and after this limit, you would allow dequeueing. The key is to ensure the amortized time for the last operation is still $O(1)$ this way. 479 | 480 | ### Python Example 481 | 482 | Here is a Python code: 483 | 484 | ```python 485 | class Node: 486 | def __init__(self, data=None): 487 | self.data = data 488 | self.next = None 489 | 490 | class LimitedQueue: 491 | def __init__(self, max_size): 492 | self.head = None 493 | self.tail = None 494 | self.max_size = max_size 495 | self.count = 0 496 | 497 | def enqueue(self, data): 498 | if self.count < self.max_size: 499 | new_node = Node(data) 500 | if not self.head: 501 | self.head = new_node 502 | else: 503 | self.tail.next = new_node 504 | self.tail = new_node 505 | self.count += 1 506 | else: 507 | print("Queue is full. Dequeue before adding more.") 508 | 509 | def dequeue(self): 510 | if self.head: 511 | data = self.head.data 512 | self.head = self.head.next 513 | self.count -= 1 514 | if self.count == 0: 515 | self.tail = None 516 | return data 517 | else: 518 | print("Queue is empty. Nothing to dequeue.") 519 | 520 | def display(self): 521 | current = self.head 522 | while current: 523 | print(current.data, end=" ") 524 | current = current.next 525 | print() 526 | 527 | # Let's test the Queue 528 | limited_queue = LimitedQueue(3) 529 | limited_queue.enqueue(10) 530 | limited_queue.enqueue(20) 531 | limited_queue.enqueue(30) 532 | limited_queue.display() # Should display 10 20 30 533 | limited_queue.enqueue(40) # Should display 'Queue is full. Dequeue before adding more.' 534 | limited_queue.dequeue() 535 | limited_queue.display() # Should display 20 30 536 | ``` 537 |
538 | 539 | ## 10. Discuss a scenario where _dequeue_ must be prioritized over _enqueue_ in terms of complexity. 540 | 541 | While **enqueue** typically takes $O(1)$ time and **dequeue** $O(1)$ or $O(n)$ time in a simple Queue, there are cases, like in **stacks**, where we prioritize one operation over the other. 542 | 543 | In most traditional Queue implementations, **enqueue and dequeue** operate in $O(1)$ time. 544 | 545 | However, you can design special queues, like **priority queues**, where one operation is optimized at the cost of the other. For instance, if you're using a **binary heap**. 546 | 547 | ### Binary Heap & Deque Efficiency 548 | 549 | The efficiency of both **enqueue** and **dequeue** is constrained by the binary heap's structure. A binary heap can be represented as a binary tree. 550 | 551 | In a **complete** binary tree, most levels are fully occupied, and the last level is either partially or fully occupied from the left. 552 | 553 | When the binary heap is visualized with the root at the top, the following rules are typically followed: 554 | 555 | - **Maximum Number of Children**: All nodes, except the ones at the last level, have exactly two children. 556 | - **Possible Lopsided Structure in the Last Level**: The last level, if not fully occupied from the left, can have a right-leaning configuration of nodes. 557 | 558 | Suppose we represent such a binary heap using an array starting from index $1$. In that case, the children of a node at index $i$ can be located at indices $2i$ and $2i+1$ respectively. 559 | 560 | Thus, both **enqueue** and **dequeue** rely on traversing the binary heap in a systematic manner. The following efficiencies are characteristic: 561 | 562 | #### Enqueue Efficiency: $O(\log n)$ 563 | 564 | When **enqueue** is executed: 565 | 566 | - The highest efficiency achievable is $O(1)$ when the new element replaces the root, and the heap happens to be a min or max heap. 567 | - The efficiency can degrade up to $O(\log n)$ in the worst-case scenario. This occurs when the new child percolates to the root in $O(\log n)$ steps after comparing and potentially swapping with its ancestors. 568 | 569 | #### Dequeue Efficiency: $O(1)$ - $O(\log n)$ 570 | 571 | When **dequeue** is executed: 572 | 573 | - The operation's efficiency spans from $O(1)$ when the root is instantly removed to $O(\log n)$ when the replacement node needs to 'bubble down' to its proper position. 574 |
575 | 576 | ## 11. Explain how you can efficiently track the _Minimum_ or _Maximum_ element in a _Queue_. 577 | 578 | Using a **singly linked list as a queue** provides $O(1)$ time complexity for standard queue operations, but finding exact minimum and maximum can be $O(n)$. However, there are optimized methods for improving efficiency. 579 | 580 | ### Optimal Methods 581 | 582 | 1. **Element Popularity Counter**: Keep track of the number of times an element appears, so you can easily determine changes to the minimum and maximum when elements are added or removed. 583 | 2. **Auxiliary Data Structure**: Alongside the queue, maintain a secondary data structure, such as a tree or stack, that helps identify the current minimum and maximum elements efficiently. 584 | 585 | ### Code Example: Naive Queue 586 | 587 | Here is the Python code: 588 | 589 | ```python 590 | class NaiveQueue: 591 | def __init__(self): 592 | self.queue = [] 593 | 594 | def push(self, item): 595 | self.queue.append(item) 596 | 597 | def pop(self): 598 | return self.queue.pop(0) 599 | 600 | def min(self): 601 | return min(self.queue) 602 | 603 | def max(self): 604 | return max(self.queue) 605 | ``` 606 | This code has $O(n)$ time complexity for both `min` and `max` methods. 607 | 608 | 609 | ### Code Example: Element Popularity Counter 610 | 611 | Here is the Python code: 612 | 613 | ```python 614 | from collections import Counter 615 | 616 | class EfficientQueue: 617 | def __init__(self): 618 | self.queue = [] 619 | self.element_count = Counter() 620 | self.minimum = float('inf') 621 | self.maximum = float('-inf') 622 | 623 | def push(self, item): 624 | self.queue.append(item) 625 | self.element_count[item] += 1 626 | self.update_min_max(item) 627 | 628 | def pop(self): 629 | item = self.queue.pop(0) 630 | self.element_count[item] -= 1 631 | if self.element_count[item] == 0: 632 | del self.element_count[item] 633 | if item == self.minimum: 634 | self.minimum = min(self.element_count.elements(), default=float('inf')) 635 | if item == self.maximum: 636 | self.maximum = max(self.element_count.elements(), default=float('-inf')) 637 | return item 638 | 639 | def min(self): 640 | return self.minimum 641 | 642 | def max(self): 643 | return self.maximum 644 | 645 | def update_min_max(self, item): 646 | self.minimum = min(self.minimum, item) 647 | self.maximum = max(self.maximum, item) 648 | ``` 649 | 650 | This code has $O(1)$ time complexity for both `min` and `max` methods. 651 | 652 | 653 | ### Code Example: Dual Data Structure Queue 654 | 655 | Here is the Python code: 656 | 657 | ```python 658 | from queue import Queue 659 | from collections import deque 660 | 661 | class DualDataQueue: 662 | def __init__(self): 663 | self.queue = Queue() # For standard queue operations 664 | self.max_queue = deque() # To keep track of current maximum 665 | 666 | def push(self, item): 667 | self.queue.put(item) 668 | while len(self.max_queue) > 0 and self.max_queue[-1] < item: 669 | self.max_queue.pop() 670 | self.max_queue.append(item) 671 | 672 | def pop(self): 673 | item = self.queue.get() 674 | if item == self.max_queue[0]: 675 | self.max_queue.popleft() 676 | return item 677 | 678 | def max(self): 679 | return self.max_queue[0] 680 | ``` 681 | 682 | This code has $O(1)$ time complexity for `max` method and $O(1)$ time complexity for `min` method using the symmetric approach. 683 |
684 | 685 | ## 12. Discuss an algorithm to merge two or more _Queues_ into one with efficient _Dequeuing_. 686 | 687 | **Merging multiple queues** is conceptually similar to merging two lists. However, direct merging challenges efficiency as it enforces a $\mathcal{O}(n)$ operation for each item in the queues. Utilizing a secondary queue $\text{auxQueue}$ can provide a more efficient $\mathcal{O}(n + m)$ sequence. 688 | 689 | ### Algorithm: Queue Merging 690 | 691 | 1. **Enqueue into Aux**: Until all input queues are empty, **enqueue** from the oldest non-empty queue to $\text{auxQueue}$. 692 | 2. **Move Everything Back**: For each item already in $\text{auxQueue}$, **dequeue** and **enqueue** back to the determined queue. 693 | 3. **Return $\text{auxQueue}$**: As all input queues are empty, $\text{auxQueue}$ now contains all the original elements. 694 | 695 | ### Complexity Analysis 696 | 697 | - **Time Complexity**: The algorithm runs in $\mathcal{O}(n + m)$ where $n$ and $m$ represent the sizes of the input queues. 698 | - **Space Complexity**: The algorithm uses $\mathcal{O}(1)$ auxiliary space. 699 | 700 | ### Code Example: Queue Merging 701 | 702 | Here is the Python code: 703 | 704 | ```python 705 | from queue import Queue 706 | 707 | def merge_queues(q_list): 708 | auxQueue = Queue() 709 | 710 | # Step 1: Enqueue into Aux 711 | for q in q_list: 712 | while not q.empty(): 713 | auxQueue.put(q.get()) 714 | 715 | # Step 2: Move Everything Back 716 | for _ in range(auxQueue.qsize()): 717 | q.put(auxQueue.get()) 718 | 719 | # Step 3: Return auxQueue 720 | return q 721 | ``` 722 | 723 | ### Code Example: Testing Queue Merging 724 | 725 | Here is the Python code with the test: 726 | 727 | ```python 728 | # Creating queues 729 | q1 = Queue() 730 | q2 = Queue() 731 | 732 | # Enqueueing elements 733 | for i in range(5): 734 | q1.put(i) 735 | 736 | for i in range(5, 10): 737 | q2.put(i) 738 | 739 | # Merging 740 | merged = merge_queues([q1, q2]) 741 | 742 | # Dequeuing and printing 743 | while not merged.empty(): 744 | print(merged.get()) 745 | ``` 746 | 747 | ### Code Example: Multi-Queue Merging 748 | 749 | Here is the Python code if we merge it into single queue: 750 | 751 | ```python 752 | def merge_queue_multi(q_list): 753 | merged = Queue() 754 | 755 | # Merging the queues 756 | for q in q_list: 757 | while not q.empty(): 758 | merged.put(q.get()) 759 | 760 | return merged 761 | ``` 762 | 763 | ### Time Complexity of Limitation 764 | 765 | The time complexity of this algorithm is **not as optimal** as the enqueuing to the auxiliary queue makes each item traverse more than once, increasing control time when an element is being dequeued. 766 | 767 | For even activity, all enqueuing actions are executed approximately the same number of times, so there's still a linear-time bound. 768 | 769 | #### Code Example: Multi-Queue Merging with Dequeuing Control 770 | 771 | Here is the Python code: 772 | 773 | ```python 774 | def merge_queues_on_visit_multi(q_list): 775 | def on_visit(visit_cb): 776 | for q in q_list: 777 | while not q.empty(): 778 | visit_cb(q.get()) 779 | 780 | merged = Queue() 781 | on_visit(merged.put) 782 | return merged 783 | ``` 784 |
785 | 786 | ## 13. Name some _Queue Implementations_. Compare their efficiency. 787 | 788 | **Queues** can be built using various underlying structures, each with its trade-offs in efficiency and complexity. 789 | 790 | ### Naive Implementations 791 | 792 | #### Simple Array 793 | 794 | Using a simple array for implementation requires **shifting elements** when adding or removing from the front. This makes operations linear time $O(n)$, which is **inefficient** and not suitable for large queues or real-time use. 795 | 796 | ```python 797 | class ArrayQueue: 798 | def __init__(self): 799 | self.queue = [] 800 | 801 | def enqueue(self, item): 802 | self.queue.append(item) 803 | 804 | def dequeue(self): 805 | return self.queue.pop(0) 806 | ``` 807 | 808 | #### Singly-linked List 809 | 810 | Using a singly-linked list allows $O(1)$ `enqueue` with a tail pointer but still $O(n)$ `dequeue`. 811 | 812 | ```python 813 | class Node: 814 | def __init__(self, data=None): 815 | self.data = data 816 | self.next = None 817 | 818 | class LinkedListQueue: 819 | def __init__(self): 820 | self.head = None 821 | self.tail = None 822 | 823 | def enqueue(self, item): 824 | new_node = Node(item) 825 | if self.tail: 826 | self.tail.next = new_node 827 | else: 828 | self.head = new_node 829 | self.tail = new_node 830 | 831 | def dequeue(self): 832 | if self.head: 833 | data = self.head.data 834 | self.head = self.head.next 835 | if not self.head: 836 | self.tail = None 837 | return data 838 | ``` 839 | 840 | ### Efficient Implementations 841 | 842 | #### Doubly Linked List 843 | 844 | A doubly linked list enables $O(1)$ `enqueue` and `dequeue` by maintaining head and tail pointers, but it requires **prev node management**. 845 | 846 | ```python 847 | class DNode: 848 | def __init__(self, data=None): 849 | self.data = data 850 | self.next = None 851 | self.prev = None 852 | 853 | class DoublyLinkedListQueue: 854 | def __init__(self): 855 | self.head = None 856 | self.tail = None 857 | 858 | def enqueue(self, item): 859 | new_node = DNode(item) 860 | if not self.head: 861 | self.head = new_node 862 | else: 863 | self.tail.next = new_node 864 | new_node.prev = self.tail 865 | self.tail = new_node 866 | 867 | def dequeue(self): 868 | if self.head: 869 | data = self.head.data 870 | self.head = self.head.next 871 | if self.head: 872 | self.head.prev = None 873 | else: 874 | self.tail = None 875 | return data 876 | ``` 877 | 878 | #### Double-Ended Queue 879 | 880 | The `collections.deque` in Python is essentially a double-ended queue implemented using a **doubly-linked list**, providing $O(1)$ complexities for operations at both ends. 881 | 882 | ```python 883 | from collections import deque 884 | 885 | class DequeQueue: 886 | def __init__(self): 887 | self.queue = deque() 888 | 889 | def enqueue(self, item): 890 | self.queue.append(item) 891 | 892 | def dequeue(self): 893 | return self.queue.popleft() 894 | ``` 895 | 896 | #### Binary Heap 897 | 898 | A binary heap with its **binary tree structure** is optimized for **priority queues**, achieving $O(\log n)$ for both `enqueue` and `dequeue` operations. This makes it useful for situations where you need to process elements in a particular order. 899 | 900 | ```python 901 | import heapq 902 | 903 | class MinHeapQueue: 904 | def __init__(self): 905 | self.heap = [] 906 | 907 | def enqueue(self, item): 908 | heapq.heappush(self.heap, item) 909 | 910 | def dequeue(self): 911 | return heapq.heappop(self.heap) 912 | ``` 913 |
914 | 915 | ## 14. Describe an array-based implementation of a _Queue_ and its disadvantages. 916 | 917 | While **array-based Queues** are simple, they have inherent limitations. 918 | 919 | ### Key Features 920 | 921 | - **Structure**: Uses an array to simulate a queue's First-In-First-Out (FIFO) behavior. 922 | - **Pointers**: Utilizes a front and rear pointer/index. 923 | 924 | ### Code Example: Simple Queue Operations 925 | 926 | Here is the Python code: 927 | 928 | ```python 929 | class ArrayQueue: 930 | def __init__(self, size): 931 | self.size = size 932 | self.queue = [None] * size 933 | self.front = self.rear = -1 934 | 935 | def is_full(self): 936 | return self.rear == self.size - 1 937 | 938 | def is_empty(self): 939 | return self.front == -1 or self.front > self.rear 940 | 941 | def enqueue(self, element): 942 | if self.is_full(): 943 | print("Queue is full") 944 | return 945 | if self.front == -1: 946 | self.front = 0 947 | self.rear += 1 948 | self.queue[self.rear] = element 949 | 950 | def dequeue(self): 951 | if self.is_empty(): 952 | print("Queue is empty") 953 | return 954 | item = self.queue[self.front] 955 | self.front += 1 956 | if self.front > self.rear: 957 | self.front = self.rear = -1 958 | return item 959 | ``` 960 | 961 | ### Disadvantages 962 | 963 | - **Fixed Size**: Array size is predetermined, leading to potential memory waste or overflow. 964 | - **Element Frontshift**: Deletions necessitate front-shifting, creating an $O(n)$ time cost. 965 | - **Unequal Time Complexities**: Operations like `enqueue` and `dequeue` can be $O(1)$ or $O(n)$, making computation times less predictable. 966 |
967 | 968 | ## 15. What are the benefits of implementing a _Queue_ with a _Doubly Linked List_ versus a _Singly Linked List_? 969 | 970 | Let's compare the benefits of implementing a **Queue** using both a **Doubly Linked List** and **Singly Linked List**. 971 | 972 | ### Key Advantages 973 | 974 | #### Singly Linked List Queue 975 | 976 | - **Simplicity**: The implementation is straightforward and may require fewer lines of code. 977 | - **Memory Efficiency**: Nodes need to store only a single reference to the next node, which can save memory. 978 | 979 | #### Doubly Linked List Queue 980 | 981 | - **Bi-directional Traversal**: Allows for both forward and backward traversal, a necessity for certain queue operations such as tail management and removing from the end. 982 | - **Efficient Tail Operations**: Eliminates the need to traverse the entire list to find the tail, significantly reducing time complexity for operations that involve the tail. 983 |
984 | 985 | 986 | 987 | #### Explore all 55 answers here 👉 [Devinterview.io - Queue Data Structure](https://devinterview.io/questions/data-structures-and-algorithms/queue-data-structure-interview-questions) 988 | 989 |
990 | 991 | 992 | data-structures-and-algorithms 993 | 994 |

995 | 996 | --------------------------------------------------------------------------------