如何以 0(1) 的时间复杂度随时从队列中检索最大和最小元素？ 早些时候我使用 Collections.max 和 min 来查找元素，但这将是 0(n)。
【问题讨论】：
标签： java data-structures
存在这样一种结构，它的作用类似于队列，但可以让您在恒定时间内检索最小/最大值，实际上不是严格恒定的，它是摊销的恒定时间（您可以猜到命名为最小/最大队列）。有两种实现方式 - 使用两个堆栈或使用队列和双端队列。
Deque 实现看起来不像这样（语言无关）：
所以我们有一个最大元素的双端队列，前面的那个是所需的最大值，还有一个标准队列。
推送操作
删除操作
获取最大值
（应添加大量参数以明确其工作原理，但下面介绍的第二个版本可能是这种必要性的答案）
Stack 的实现非常相似，我认为实现的时间可能会更长一些，但可能更容易掌握。首先要注意的是，将最大元素存储在堆栈中很容易 - 容易练习（对于懒惰的人 - Stack with find-min/find-max more efficient than O(n)?）。第二部分，如果第一次看到可能有点棘手，那就是使用两个堆栈实现队列非常容易，可以在这里找到 - How to implement a queue using two stacks?。基本上就是这样 - 如果我们可以获得两个堆栈的最大元素，我们可以获得整个队列的最大元素（如果你想要一个更正式的参数，取最大值是关联的或类似的东西，但我打赌你不't，这真的很明显）。
最小版本是类推的。
一切也可以在 O(nlogn) 时间内使用一个集合（或类似的东西）来完成，但这毫无意义，因为 O(n) 中的常数非常小，它应该更快，但易于实现.
第一个版本中不感兴趣的部分：
希望我能帮上一点忙。并希望这没有说错什么。如果需要，可以在 C++/C 中给出一个简单的实现。非常感谢您对表格的任何反馈，因为这是我在任何地方的第一篇此类帖子:)（而且英语不是我的母语）。还有一些关于正确性的确认会很棒。
编辑：因为这个答案让我得到了一些分数，所以我觉得有必要对其进行一些清理，并对其进行一些扩展。
【讨论】：
我在这里发布完整的代码，以便在恒定时间内找到队列中的 MIN 和 MAX。 如果您有任何疑问，请随时与我联系。
队列
// Queue Interface
package com.java.util.collection.advance.datastructure.queue;
public interface Queue<E>{
boolean addR(E e);
E removeL();
E element();
E elementR();
boolean isFull();
boolean isEmpty();
void trim();
}
双端队列
package com.java.util.collection.advance.datastructure.queue;
/**
* A deque is a double-ended queue. You can insert items at either end and delete them
* from either end. The methods might be called insertLeft() and insertRight(), and
* removeLeft() and removeRight().
* @author vsinha
*
* @param <E>
*/
public interface DeQueue<E> extends Queue<E>{
boolean addL(E element);
E removeR();
}
查找最小最大队列
package com.java.util.collection.advance.datastructure.queue;
@SuppressWarnings("hiding")
public interface FindMinMaxQueue<Integer> extends Queue<Integer>{
public Integer min();
public Integer max();
}
我的队列
package com.java.util.collection.advance.datastructure.queue;
import java.util.Arrays;
public class MyQueue<E> implements Queue<E>,DeQueue<E>{
protected int front = 0;
protected int rear =-1;
protected E[] elements =null;
private static final int DEFAULT_INTIAL_CAPACITY =100;
private int size =0;
public MyQueue(){
this(DEFAULT_INTIAL_CAPACITY);
}
@SuppressWarnings("unchecked")
public MyQueue(int intialCapacity){
if(intialCapacity < 0){
throw new IllegalArgumentException("intial capacity can't be null");
}
elements =(E[]) new Object[intialCapacity];
}
@Override
public boolean addR(E e) {
if(! isFull()) {
elements[++rear] = e;
size++;
return true;
}
return false;
}
@Override
public E removeL() {
E element =null;
if(!isEmpty()){
element=elements[front];
// Nullify the reference
elements[front] =null;
++front;
--size;
}
return element;
}
@Override
public E element() {
E element =null;
if(!isEmpty()){
element=elements[front];
}
return element;
}
@Override
public E elementR() {
E element =null;
if(!isEmpty()){
element=elements[rear];
}
return element;
}
public boolean isFull() {
return rear == elements.length;
}
public boolean isEmpty() {
return size == 0;
}
Override
public String toString() {
return "MyQueue [front=" + front + ", rear=" + rear + ", elements="
+ Arrays.toString(elements) + ", size=" + size + "]";
}
@Override
public void trim() {
@SuppressWarnings("unchecked")
E[] dest =(E[]) new Object[size];
System.arraycopy(elements, front, dest, 0, size);
elements = dest;
front =0;
rear=size-1;
}
@Override
public boolean addL(E element) {
if(front != 0) {
elements[--front] = element;
size++;
return true;
}
return false;
}
@Override
public E removeR() {
E element =null;
if(size > 0) {
element=elements[rear];
// Nullify the reference
elements[rear] =null;
--rear;
--size;
}
return element;
}
}
MinAndMaxFinderQueue
package com.java.util.collection.advance.datastructure.queue;
public class MinAndMaxFinderQueue extends MyQueue<Integer> implements FindMinMaxQueue<Integer> {
private Queue<Integer> maxValuesQueue =null;
private Queue<Integer> minValuesQueue =null;
public MinAndMaxFinderQueue (int intialCapacity){
super(intialCapacity);
maxValuesQueue =new MyQueue<Integer>(intialCapacity);
minValuesQueue =new MyQueue<Integer>(intialCapacity);
}
@Override
public boolean addR(Integer e) {
if(super.addR(e)){
if(max() == null || max() <= e){
maxValuesQueue.addR(e);
}
if(min() == null || min() >= e){
minValuesQueue.addR(e);
}
return true;
}
return false;
}
@Override
public Integer removeL() {
Integer element =super.removeL();
if(element !=null){
if(maxValuesQueue.element() == element){
maxValuesQueue.removeL();
}
if(minValuesQueue.element() == element){
minValuesQueue.removeL();
}
}
//Need to re-generate MIN and MAX queue when the main queue is not empty and min/max queue is empty
regenerateMin();
regenerateMax();
return element;
}
private void regenerateMin(){
Integer current =null;
if(!super.isEmpty() && min() ==null){
for(int front = super.front; front<= super.rear;front++){
current = (Integer)elements[front];
if(min() == null || min() >= current){
minValuesQueue.addR(current);
}
}
}
}
private void regenerateMax(){
Integer current =null;
if(!super.isEmpty() && max() ==null){
for(int front = super.front; front<= super.rear;front++){
current = (Integer)elements[front];
if(max() == null || max() <= current){
maxValuesQueue.addR(current);
}
}
}
}
public Integer min() {
return minValuesQueue.elementR();
}
public Integer max() {
return maxValuesQueue.elementR();
}
@Override
public String toString() {
return super.toString()+"\nMinAndMaxFinderQueue [maxValuesQueue=" + maxValuesQueue
+ ", minValuesQueue=" + minValuesQueue + "]";
}
}
测试
//Test class
package com.java.util.collection.advance.datastructure.queue;
import java.util.Random;
public class MinMaxQueueFinderApp {
public static void main(String[] args) {
FindMinMaxQueue<Integer> queue =new MinAndMaxFinderQueue(10);
Random random =new Random();
for(int i =0; i< 10; i++){
queue.addR(random.nextInt(100));
System.out.println(queue);
System.out.println("MAX :"+queue.max());
System.out.println("MIN :"+queue.min());
}
System.out.println(queue);
System.out.println("MAX :"+queue.max());
System.out.println("MIN :"+queue.min());
queue.removeL();
System.out.println(queue);
System.out.println("MAX :"+queue.max());
System.out.println("MIN :"+queue.min());
queue.removeL();
System.out.println(queue);
System.out.println("MAX :"+queue.max());
System.out.println("MIN :"+queue.min());
queue.removeL();
System.out.println(queue);
System.out.println("MAX :"+queue.max());
System.out.println("MIN :"+queue.min());
queue.removeL();
System.out.println(queue);
System.out.println("MAX :"+queue.max());
System.out.println("MIN :"+queue.min());
queue.removeL();
System.out.println(queue);
System.out.println("MAX :"+queue.max());
System.out.println("MIN :"+queue.min());
System.out.println(queue);
System.out.println("MAX :"+queue.max());
System.out.println("MIN :"+queue.min());
}
}
【讨论】：
这并不是真正的队列，但您可以实现 Min-Max Heap。
http://en.wikipedia.org/wiki/Min-max_heap
基本上，它是一个堆，它在偶数级别具有最大堆属性，在奇数级别具有最小堆属性。
它同时具有 O(1) MIN() 和 O(1) MAX() 操作。然而，迭代起来相当棘手，但它可以工作并满足您的要求。
【讨论】：
对于最小/最大操作，您只有 2 种方法来获得 O(1)：
【讨论】：
我将存储两个字段 minIndex 和 maxIndex，它们将分别在您的数据结构中存储索引位置的最小值和最大值。
当新元素添加到队列中时，检查两件事：
这将为您提供当前最小值和最大值的 O(1) 渐近线。
【讨论】：
我怀疑您正在尝试实现 PriorityQueue 的功能。这是一个排序队列，O(log N) 得到最低值。我不知道为什么你会想要最大值，因为队列只有一端。
【讨论】：