Question

我正在尝试创建一个基于数组的队列，但是我无法获得正确的输出顺序。现在它是有界限的，但是一旦我弄清楚如何正确地运作出口，我可能会使用无界限。

这是我的代码：

public class ArrayBndDequeue<T> implements BoundedDequeueInterface<T>
{
  protected final int DEFCAP = 100; // default capacity
  protected T[] queue;              // array that holds queue elements
  protected int numElements = 0;    // number of elements n the queue
  protected int front = 0;          // index of front of queue
  protected int rear;               // index of rear of queue

  public ArrayBndDequeue() 
  {
    queue = (T[]) new Object[DEFCAP];
     rear = DEFCAP - 1;
  }

  public ArrayBndDequeue(int maxSize) 
  {
    queue = (T[]) new Object[maxSize];
     rear = maxSize - 1;
  }

  public void enqueue(T element)
  // Throws QueueOverflowException if this queue is full;
  // otherwise, adds element to the front of this queue.
  {  
    if (isFull())
      throw new DequeueOverflowException("Enqueue attempted on a full queue.");
    else
    {
      front = (front + 1) % queue.length;
      queue[front] = element;
      numElements = numElements + 1;
    }
  }

  public T dequeue()
  // Throws QueueUnderflowException if this queue is empty;
  // otherwise, removes rear element from this queue and returns it.
  {   
    if (isEmpty())
      throw new DequeueUnderflowException("Dequeue attempted on empty queue.");
    else
    {
      T toReturn = queue[rear];
      queue[rear] = null;
      rear = (rear + 1) % queue.length;
      numElements = numElements - 1;
      return toReturn;
    }
  }

  public boolean isEmpty()
  // Returns true if this queue is empty; otherwise, returns false
  {              
    return (numElements == 0);
  }

  public boolean isFull()
  // Returns true if this queue is full; otherwise, returns false.
  {              
    return (numElements == queue.length);
  }
}

这是我的主要课程：

public class Dequeue
{
    public static void main(String[] args)
    {
        Scanner userInput = new Scanner(System.in);
        String line;

        BoundedDequeueInterface<String> queue;
        queue = new ArrayBndDequeue<String>(3);

        for (int i = 1; i <= 3; i++)
        {
            System.out.print("Enter a line of text > ");
            line = userInput.nextLine();
            queue.enqueue(line);
        }

        System.out.println("\nOrder is:\n");

        while (!queue.isEmpty())
        {
            line = queue.dequeue();
            System.out.println(line);
        }
    }
}

当我运行程序时，我通常输入：

1
2
3

输出结果如下：

2
3
1

有任何帮助吗？如果您需要我的代码，请告诉我！

Answer 1

在排队期间，您首先在前面添加+1，然后设置对象，但您需要以相反的顺序执行此操作。

另一方面，实现你自己的Queue类是一个非常糟糕的主意（当然，除非你是为了学习它），因为Java已经拥有一个高速，可靠且经过良好测试的类。您可以查看Java队列类的源代码，了解如何正确地完成它。

Answer 2

您描述的问题源于插入过程中的以下表达式（同样适用于删除）：

this.front = (this.front + 1) % this.queue.length;

这传达给：

(0 + 1 % 3) = 1
(1 + 1 % 3) = 2
(2 + 1 % 3) = 0

因为存储第三个值时，由于队列的大小为3，所以得到3 % 3为0.因此该值存储在索引0处。

在ArrayDeque of the JDK中查看此算法的定义。他们这样做：

public void addFirst(E e) {
    if (e == null)
        throw new NullPointerException();
    elements[head = (head - 1) & (elements.length - 1)] = e;
    if (head == tail)
        doubleCapacity();
}

创建一个出列队

2 个答案: