Java design a Queue with O(1) lookup time of the Maximum element. You will implement this design using the ArrayDeque Class in Java. solve the problem as stated below:- (1) Here you will Maintain two Queues - a Main Queue and a Queue holding the Maximum value(s) from the Main Queue (AKA Max Queue). The Main Queue contains the elements. The Max Queue contains the elements with Maximum value. The Max Queue would have to be a double ended Queue as you would like to be able to remove elements from both ends. Example : Let’s say we have the following: We add an integer 1 into our Main Queue and I hope it is really obvious that when the Main Queue contains a single element, the Max Queue can be populated without confusion :) Main Queue: 1 << front of Queue Max Queue : 1 << front of Queue Now, let’s say we insert a 4 into the Main Queue. the Main Queue will look as follows: Main Queue: 4 → 1 << front of Queue In the Max Queue, we don’t need 1 anymore, since 1 can never be the Max of this Queue now. So we remove 1 and insert 4. Main Queue: 4 → 1 << front of Queue Max Queue : 4 << front of Queue Say we insert 2 into the Main Queue. We know 2 is not the Max, but it can be the Max if we de-Queue 1 and 4 from the Queue. So, we insert it onto the Max Queue: Main Queue: 2 → 4 → 1 << front of Queue Max Queue : 2 → 4 << front of Queue Further, If we insert a 3 into the Main Queue, we can get rid of the 2 from the Max Queue, because 2 can no longer be the Max of the Queue, even if 4 and 1 are de-Queued. In that case our Queues become: Main Queue: 3 → 2 → 4 → 1 << front of Queue Max Queue : 3 → 4 << front of Queue In the process of inserting 3, we removed elements from the back of the Max Queue until we found an element ≥ 3. This is because elements < 3 could never be Max after 3 is inserted. What I stated above is exactly the algorithm for inserting an element in the Max Queue. To lookup the Maximum Value (AKA Max), we just check the front of the Max Queue which ensures O(1) lookup time. While de-queuing elements, we check if they are equal to the front of the Max Queue, and if so, we de-Queue from the Max Queue too. For example, after de-queuing 1, lets say we want to de-Queue 4. We see that 4 is the front of the Max Queue, so we remove both the 4s. This does indeed make sense as 4 can no longer remain the Maximum after it is removed from the Main Queue. If the process described above is followed and you code up the example provided we end up with the complexity stated below.

Java

design a Queue with O(1) lookup time of

the Maximum element. You will implement this design using the ArrayDeque

Class in Java.

solve the problem as stated below:-

 (1)  Here you will Maintain two Queues - a Main Queue and a Queue holding the

Maximum value(s) from the Main Queue (AKA Max Queue). The Main Queue

contains the elements. The Max Queue contains the elements with Maximum

value. The Max Queue would have to be a double ended Queue as you would

like to be able to remove elements from both ends.

Example :

Let’s say we have the following:

We add an integer 1 into our Main Queue and I hope it is really obvious that

when the Main Queue contains a single element, the Max Queue can be populated without confusion :)

Main Queue: 1 << front of Queue

Max Queue : 1 << front of Queue

Now, let’s say we insert a 4 into the Main Queue. the Main Queue will look as

follows:

Main Queue: 4 → 1 << front of Queue

In the Max Queue, we don’t need 1 anymore, since 1 can never be the Max

of this Queue now. So we remove 1 and insert 4.

Main Queue: 4 → 1 << front of Queue

Max Queue : 4 << front of Queue

Say we insert 2 into the Main Queue. We know 2 is not the Max, but it can be

the Max if we de-Queue 1 and 4 from the Queue. So, we insert it onto the Max

Queue:

Main Queue: 2 → 4 → 1 << front of Queue

Max Queue : 2 → 4 << front of Queue

Further, If we insert a 3 into the Main Queue, we can get rid of the 2 from the

Max Queue, because 2 can no longer be the Max of the Queue, even if 4 and 1

are de-Queued. In that case our Queues become:

Main Queue: 3 → 2 → 4 → 1 << front of Queue

Max Queue : 3 → 4 << front of Queue

In the process of inserting 3, we removed elements from the back of the Max

Queue until we found an element ≥ 3.

This is because elements < 3 could never be Max after 3 is inserted. What I

stated above is exactly the algorithm for inserting an element in the Max Queue.

To lookup the Maximum Value (AKA Max), we just check the front of the Max

Queue which ensures O(1) lookup time.

While de-queuing elements, we check if they are equal to the front of the Max

Queue, and if so, we de-Queue from the Max Queue too. For example, after

de-queuing 1, lets say we want to de-Queue 4. We see that 4 is the front of the

Max Queue, so we remove both the 4s. This does indeed make sense as 4 can

no longer remain the Maximum after it is removed from the Main Queue.

If the process described above is followed and you code up the example provided

we end up with the complexity stated below.

***VERY VERY IMPORTANT***

Time Complexity of the Max Queue lookup: O(1)

Space Complexity on the Max Queue : O(n)

(1) Your code should be well commented which explains all the steps you are

performing to solve the problem AND mentioned Time and Space complexities

(2) As a comment in your code, please write your test-cases on how you would

test your solution assumptions and hence your code.

You will address your test cases in the form of code and not prose :