If queue is implemented using arrays, what would be the worst run time complexity of queue and dequeue operations?

When a queue is implemented using arrays, the run time complexity of its operations depends on how the array is managed.

1. Enqueue operation (adding an element to the rear):

   • In most array implementations, adding an element to the end of the array (or at the rear pointer) takes constant time, $O(1)$, assuming there is space available or that array resizing is handled efficiently (e.g., amortized $O(1)$).

2. Dequeue operation (removing an element from the front):

   • Simple Array Implementation: If the queue is implemented such that the front element is always at index 0, then removing the front element requires shifting all subsequent elements one position to the left to fill the gap. If there are $n$ elements in the queue, this shifting operation takes $O(n)$ time. This is considered the worst-case for dequeue in a simple array implementation.
   • Circular Array Implementation: In a more optimized circular array implementation, both the front and rear pointers move around the array. Removing an element from the front simply involves incrementing the front pointer, which takes $O(1)$ time.

The question asks for the worst run time complexity. While a circular array can achieve $O(1)$ for both, a common array implementation (especially if not explicitly stated as circular) can have a $O(n)$ dequeue operation due to the need to shift elements. Therefore, considering the worst-case scenario for a general array implementation, dequeue can be $O(n)$.

Thus, the enqueue operation is $O(1)$, and the dequeue operation is $O(n)$.

The final answer is $\text{B}$