用java数组反转队列

您好，我想知道如何使用数组反转队列。我附加了queue类和runner类，后者创建了队列并在其中添加了元素。我创建一个数组的反向方法是检查元素是否移除并将其添加到创建的数组中。我刚开始排队，有点迷路了。谢谢你对我的帮助

    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()){
         
        }
    }
  
  }

---

到目前为止，我认为你的想法是正确的。假设所有队列方法都有效，例如

size

、

enqueue

、

dequeue

等，那么您所要做的就是在将元素逐个从队列中取出时，从数组的末尾向开始插入这些元素。您可以使用一个计数器跟踪要在数组中插入元素的位置。此计数器将从

Q.size（）-1开始，因为队列遵循先进先出原则。然后，在helper方法的帮助下，可以将队列中的
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
方法的外观

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
方法如果传入一个有间隙的数组，可能会导致问题；例如，某些索引处的空元素。
以下是更新类：

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方法，然后将从队列中删除的值放回队列中。按相反的顺序排队。
你说的倒队是什么意思？比如颠倒插入顺序？或者在值进入数组后将其反转？@beastlyCoder噢，对不起，我的意思是在数组中反转队列的值。因此，与队列一样，队列将是10,20,30,40，在数组或方法之后，它将是40,30,20,10Gotcha，alrightCollection.reverse（revQue）@ShivanshPotdar这是行不通的，因为它不是集合，而是他自己的队列类