在JAVA中的FIFO队列中计算PeekMedian（）

Question

Need help ASAP. I want to implement a peekMedian function which looks at the object which has the median value among all the objects without removing it from the queue. It should return the object which has value of ( size/2 + 1) th lowest.

for eg. suppose a queue has the following values. { 2, 1, 2, 2, 6, 4, 2, 5} then the method should return 2 and doesn't remove the object.

I have tried using collection.sort() but the queue should not be sorted according to the question. I have also tried to copy queue elements in an array and find the nth lowest value and return the value. But the question says " return the object ". .. and also the solution should have a less complexity.

Answer 1

This looks like a homework, so I'll post an algorithm to solve the problem:

1. Create an new queue that will help you as an auxiliar collection for your objects.
2. Start dequeuing the objects from the initial queue and queuing them in the auxuliar queue.
3. If you know the original size of the queue, when you get to the (size/2 + 1)nth element, use an auxiliar object to keep a copy of its value.
4. Continue with the process in step 2.
5. If you can, replace your queue with your auxiliar queue, else repeat the process in pass 2 from the auxiliar queue to the original.
6. Return the auxiliar object with the value of the median.

By the way, I think you have a different concept of the median . Or maybe that's how the problem is proposed.

Note: If your assignment is to do this without removing any of the objects in the queue, then its impossible, at least that you threat your queue as an Array or a LinkedList and iterate over it.

---

I'll show you an implementation of the code using Java Queue.

public <T> T peekMedian(Queue<T> queue) {
    int medianIndex = queue.size() / 2 + 1; //based on your question.
    Queue<T> auxQueue = new LinkedList<T>();
    T result;
    int count = 1;
    while(queue.peek() != null) {
        auxQueue.add(queue.pop());
        if (count == medianIndex) {
            result = auxQueue.peek();
        }
        count++;
    }
    while(auxQueue.peek() != null) {
        queue.add(auxQueue.pop());
    }
    return result;
}

Answer 2

try this

        import java.util.ArrayDeque;
        import java.util.Iterator;

        public class ArrayDequeDemo {
           public static void main(String[] args) {

        ArrayDeque<Integer> que = new ArrayDeque<Integer>();
            // add elements in queue
              que.add(2);
             que.add(1);
              que.add(2);
              que.add(2);
              que.add(6);
              que.add(4);
              que.add(2);
              que.add(5);

    Integer median = peekMedian(que);

     System.out.println(median);
       }


  private static Integer peekMedian(ArrayDeque<Integer> que){

    Integer ele=0;      //required number
   int size=que.size();  

   //finding the index of ele.
   int elementFromlastIndex= (size/2)+1;


   Iterator descItr = que.descendingIterator();

    int counter=0;  


// iterate in reverse order  till the index of ele is not reached.The loop will break when  when index of ele is reached and thereby finding required element. 

    while(descItr.hasNext() && counter!=elementFromlastIndex) {
             ele =( Integer)descItr.next();
            ++counter;

         if(counter==elementFromlastIndex)
          break;
}//while  
      return ele;       

   }
   }  
        }//class

Answer 3

I think I know how to do, I was asked to implement yesterday.

It easy to implement max or min in O(1) time, isn't it? Why don't you divide the queue into two queues, one store the item smaller than median, one store the item bigger than median, always keep this relation,and when you insert items, in turns insert to each queue,than you can get the median.

There maybe some operating when keep the relation, but I think totally it will be O(1) time because we get max or min in O(1) and inset can be down in O(1), so it's still O(1), sounds good.

I hope I was right. If there's something wrong, please tell me.