使用数组java反转队列

Question

您好，我试图弄清楚如何使用数组来反转队列。我附加了队列类和创建队列并在其中添加元素的运行器类。我创建了一个数组的反向方法，我的想法是检查元素删除并将其添加到创建的数组中。我是新来排队的，有点迷路。感谢您的帮助。

    public class Queue{
    private int QUEUE_SIZE = 5;
    private Object[] items;
    private int front, back, count;

    public Queue() { 
        items = new Object[QUEUE_SIZE];
        front = 0;
        back = QUEUE_SIZE -1;
        count =0;
    }

    public boolean isEmpty(){
        return count==0;
    }

    public boolean isFull(){
        return count == QUEUE_SIZE;
    }

    public void enqueue(Object newItem){
        if (!isFull()){
            back = (back+1) % QUEUE_SIZE;
            items[back] = newItem;
            count++;        
      return;
        } else 
        System.out.println(
                "Trying to enqueue into a full queue");
    }       

    public Object dequeue(){
        if (!isEmpty()){
            Object queueFront = items[front];
            front = (front+1) % QUEUE_SIZE;
            count--;
      return queueFront;
        }else
      System.out.println(
              "Trying to dequeue from an empty queue");
    return null;
    }

       public void dequeueAll(){
        items = new Object[QUEUE_SIZE];
        front = 0;
        back = QUEUE_SIZE -1;
        count =0;
    }

     public Object peek(){
        if (!isEmpty()) {
            return items[front];
        }
        else
      System.out.println(
              "Trying to peek with empty queue");
    return null;       
    }
       
     public int size(){
       return count;       
     }       
              
    }

     // queue created with reverse method

      public class RunnerQueue {
     public static void main(String args[]){
      Queue q = new Queue();
      q.enqueue(10);
      q.enqueue(20);
      q.enqueue(30);
      q.enqueue(40);
      q.enqueue(50);

    public static void reverseQueue(Queue Q){
         int[] revQue = new int(Q.size);
        While(!Q.isEmpty()){
         
        }
    }
  
  }

Answer 1

到目前为止，我认为您的想法是正确的。假设您的所有队列方法都有效，例如size、enqueue、dequeue 等，那么您所要做的就是在将元素从队列中逐一出列时，从末尾插入这些元素阵列朝向开始。您可以有一个计数器来跟踪您要在数组中插入元素的位置。该计数器将从Q.size() - 1 开始，因为队列遵循先进先出原则。然后，在辅助方法的帮助下，您可以将队列中的items 变量设置为revQue，然后将原始队列的项目以相反的顺序填充到数组的元素中。例如，您可以修改您的 reverseQueue 方法，使其看起来像这样，

public static void reverseQueue(Queue Q){
    int[] revQue = new int[Q.size()];
    int i = Q.size() - 1;
    while(!Q.isEmpty()){
        revQue[i] = Q.dequeue();
        i--;
    }
    Q.setItems(revQue);
}

这就是 setItems 方法的样子，添加到您的 Queue 类中，

public void setItems(Object[] items) {
    this.items = items;
    this.QUEUE_SIZE = items.length;
    this.front = 0;
    this.back = items.length - 1;
    this.count = items.length;
}

请注意，这里的setItems 方法假定了完美的情况，这意味着传入的items 参数在数组中的每个位置都有一个有效元素。对于reverseQueue 方法，假设您的其他队列方法按预期工作，这应该可以工作。但请记住，setItems 方法可能会导致问题，如果您传入一个包含间隙的数组；例如，某些索引处的 null 元素。

Answer 2

这是更新类：

public class Queue
{
    private int QUEUE_SIZE = 5;
    private Object[] items;
    private int front, back, count;

    public Queue() {
        items = new Object[QUEUE_SIZE];
        front = 0;
        back = QUEUE_SIZE -1;
        count =0;
    }

    public boolean isEmpty(){
        return count==0;
    }

    public boolean isFull(){
        return count == QUEUE_SIZE;
    }

    public void enqueue(Object newItem){
        if (!isFull()){
            back = (back+1) % QUEUE_SIZE;
            items[back] = newItem;
            count++;
            return;
        } else
            System.out.println(
                    "Trying to enqueue into a full queue");
    }

    public Object dequeue(){
        if (!isEmpty()){
            Object queueFront = items[front];
            front = (front+1) % QUEUE_SIZE;
            count--;
            return queueFront;
        }else
            System.out.println(
                    "Trying to dequeue from an empty queue");
        return null;
    }

    public void dequeueAll(){
        items = new Object[QUEUE_SIZE];
        front = 0;
        back = QUEUE_SIZE -1;
        count =0;
    }

    public Object peek(){
        if (!isEmpty()) {
            return items[front];
        }
        else
            System.out.println(
                    "Trying to peek with empty queue");
        return null;
    }

    public int size(){
        return count;
    }

    public static void reverseQueue(Queue q)
    {
        if(q.isEmpty())
        {
            return;
        }

        Object data = q.peek();
        q.dequeue();
        reverseQueue(q);
        q.enqueue(data);
    }

    public static void printQueue(Queue q)
    {
        while(!q.isEmpty())
        {
            System.out.println(q.dequeue());
        }
    }

    public static void main(String[] args)
    {
        Queue q = new Queue();
        q.enqueue(10);
        q.enqueue(20);
        q.enqueue(30);
        q.enqueue(40);
        q.enqueue(50);

        reverseQueue(q);
        printQueue(q);
    }
}

所以想法是从队列中弹出元素，如果它有元素。为队列中的剩余值调用 reverseQueue 方法，然后将从队列中删除的值放回队列中。按相反的顺序制作。