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

我需要尽快的帮助。 我想实现一个peekMedian函数，它查看在所有对象中具有中值的对象，而不将其从队列中移除。 它应该返回值为（size/2+1）th最低的对象

        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

例如，假设队列具有以下值。{ 2, 1, 2, 2, 6, 4, 2, 5} 然后该方法应该返回2，并且不删除该对象

        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

我尝试过使用collection.sort（），但队列不应根据问题进行排序。我还尝试复制数组中的队列元素，找到第n个最小值并返回该值。但是问题是“返回对象”。。。

---

而且解决方案的复杂度应该更低。

这看起来像是一个家庭作业，所以我将发布一个算法来解决这个问题：

        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

创建一个新队列，作为对象的辅助集合来帮助您

开始将对象从初始队列中移出队列，并将其放入auxuliar队列中

如果知道队列的原始大小，当到达第n个（size/2+1）元素时，请使用辅助对象保留其值的副本

继续执行步骤2中的过程

如果可以，用辅助队列替换您的队列，否则重复过程2中从辅助队列到原始队列的过程

返回带有中间值的辅助对象

顺便说一下，我想你对这个问题有不同的看法。或者问题就是这样提出的

        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

注意：如果您的任务是在不删除队列中的任何对象的情况下执行此操作，那么这是不可能的，至少您可以将队列作为数组或链接列表进行威胁，并对其进行迭代

        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

---

我将向您展示使用Java队列的代码实现

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;
}

        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

public T（队列）{
int medianIndex=queue.size（）/2+1；//根据您的问题。
Queue auxQueue=newlinkedlist（）；
T结果；
整数计数=1；
while（queue.peek（）！=null）{
添加（queue.pop（））；
如果（计数==medianIndex）{
结果=auxQueue.peek（）；
}
计数++；
}
while（auxQueue.peek（）！=null）{
add（auxQueue.pop（））；
}
返回结果；
}

试试这个

        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

import java.util.ArrayDeque；
导入java.util.Iterator；
公共类ArrayDequeDemo{
公共静态void main（字符串[]args）{
ArrayDeque=新的ArrayDeque（）；
//在队列中添加元素
q.添加（2）；
q.添加（1）；
q.添加（2）；
q.添加（2）；
q.添加（6）；
q.添加（4）；
q.添加（2）；
q.添加（5）；
整数中值=中值（que）；
系统输出打印LN（中值）；
}
私有静态整数中值（ArrayQue）{
整数ele=0；//所需数字
int size=que.size（）；
//查找ele的索引。
int-elementFromlastIndex=（size/2）+1；
迭代器descItr=que.degendingIterator（）；
int计数器=0；
//按相反顺序迭代，直到未达到ele的索引。当达到ele的索引时，循环将中断，从而找到所需的元素。
while（descItr.hasNext（）&&counter！=elementFromlastIndex）{
ele=（整数）descItr.next（）；
++计数器；
if（计数器==elementFromlastIndex）
打破
}//当
返回ele；
}
}  
}//阶级

我想我知道怎么做，昨天我被要求实施

        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

在O（1）时间内实现最大值或最小值很容易，不是吗？为什么不把队列分成两个队列，一个存储小于中间值的项目，一个存储大于中间值的项目，始终保持这种关系，当您插入项目时，依次插入到每个队列中，您就可以得到中间值

        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

当保持这个关系时，可能会有一些操作，但我认为完全是O（1）时间，因为我们在O（1）中得到了最大值或最小值，并且插入值可以在O（1）中下降，所以它仍然是O（1），听起来不错

        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

---

我希望我是对的。如果有什么不对劲，请告诉我。

那么，我想这是家庭作业吧？如果是，请相应地标记它。是否有任何范围限制附加到该数字？不，没有范围限制。我们只需要找到该对象并返回该特定对象，而无需将其从队列中删除。谢谢…但所需元素是（大小/2+1）第个最低编号，而不是（大小/2+1）第个no@samcoder所以我说“也许问题就是这样提出的：）：）…那么根据提出的问题，你知道如何找到这个“中位数”吗“？是的，这就是算法实现的。你想雇我来实施它吗？记住，这件事。您的实际实现仅适用于同样实现了队列的ArrayQueue，但OP需要使用最后一个。

        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