遞歸 function 以反轉 Java 中隊列的數組實現

Question

import java.util.Scanner;

class ed {
    int fr, r;
    int q[];
    int n;

    ed(int x) {
        n = x;
        fr = -1;
        r = -1;
        q = new int[n];
    }

    void enque(int n) {
        int val = n;
        while (r < n-1) {
            if (r==n-1) {
                System.out.println("Overflow");
                break;
            }
            else if (fr==-1 && r==-1) {
                fr=0;
                r=0;
                q[r] = val;
            }
            else {
                r += 1;
                q[r] = val;
            }
        }
    }
    void deque() {
        if (fr==-1 && r==-1) {
            System.out.println("Underflow");
        }
        else if (fr==r) {
            fr=-1;
            r=-1;
        }
        else {
            fr += 1;
        }
    }
    void reverse(int[] q) {
        int a = q[0];
        deque();
        reverse(q);
        enque(a);
    }
    void printq() {
        for (int i = fr; i<=r; i++) {
            System.out.print(q[i] + " ");
        }
    }
}

public class q1 {

    static Scanner f = new Scanner (System.in);
    public static void main(String[] args) {
        
        int n = f.nextInt();
        ed que = new ed(n);
        for (int i=0; i<n; i++) {
            int x = f.nextInt();
            que.enque(x);
        }
        // que.deque();

        // que.printq();
        que.reverse(que.q);

    }
}

我的目標是使用遞歸 function 反轉隊列（數組），但在 VS Code 中，循環運行無限次，我沒有機會看到錯誤。 我想知道我的錯誤，任何改進都非常感謝。 class ed 包含一個構造函數，用於初始化數組和前、后值。 enque 方法在隊列后面添加一個元素，deque 方法刪除前面的元素。 Reverse 方法接受一個數組輸入（隊列），將最前面的元素存儲在變量 a 中，將其從隊列中取出，調用自身，然后在后面將其入隊。 VS Code 在第 48 行顯示錯誤（reverse(q)，當它調用自身時）但它沒有顯示錯誤，因為它到目前為止。

Answer 1

在使用 arrays 的隊列實現中，很多事情都沒有按照正確的方式進行。 就像，在 enque function 中，您可以將值從rear = 0填充到rear = n - 1 ，因為您在q數組中有n位置可用。

你的代碼太長，沒有結構化，而且沒有正確的變量名有點混亂，所以，我沒有進一步閱讀它。

但我可以弄清楚的一件事是，您需要閱讀如何使用數組實現隊列。

現在，使用遞歸部分來進行隊列反轉。 您的方法是正確的，您只是錯過了基本情況。

反轉隊列的步驟：

1. 您的隊列有一些元素，我們從隊列中取出第一個元素。
2. 然后，我們假設我有一個遞歸的 function 反轉隊列的 rest。
3. 在這個反向隊列中，我只需要將第一個元素推到后面。

回到基本情況，每次隊列大小減少 1，所以最后，隊列將變為空，然后我們無需執行任何操作，只需返回即可。 從而停止遞歸（你錯過了）。

如果您需要一些參考，這里是我的實現：

/*package whatever //do not write package name here */

import java.io.*;
import java.util.*;

class Queue {
    private int front, rear, capacity;
    private int queue[];
 
    Queue(int c) {
        front = rear = 0;
        capacity = c;
        queue = new int[capacity];
    }
    
    int size() {
        return rear - front;
    }
 
    void enqueue(int data) { 
        if (capacity == rear) {
            System.out.printf("Queue is full.\n");
            return;
        }
        else {
            queue[rear] = data;
            rear++;
        }
    }
 
    void dequeue() {
        if (front == rear) {
            System.out.printf("Queue is empty.\n");
            return;
        }
        else {
            for (int i = 0; i < rear - 1; i++) {
                queue[i] = queue[i + 1];
            }
            if (rear < capacity)
                queue[rear] = 0;
 
            rear--;
        }
    }
    
    int front() {
        if (front == rear) {
            System.out.printf("\nQueue is Empty.\n");
            return -1;
        }
        return queue[front];
    }
 
    void print() {
        int i;
        if (front == rear) {
            System.out.printf("Queue is Empty.\n");
            return;
        }
 
        for (i = front; i < rear; i++) {
            System.out.printf(" %d, ", queue[i]);
        }
        System.out.println("");
        return;
    }
}


class GFG {
    static Scanner scanner = new Scanner(System.in);
    
    public static void reverseQueue(Queue queue) {
        if (queue.size() == 0) {
            return;
        }
        
        int frontElement = queue.front();
        queue.dequeue();
        reverseQueue(queue);
        queue.enqueue(frontElement);
    }
    
    public static void main (String[] args) {
        int queueSize = scanner.nextInt();
        
        Queue queue = new Queue(queueSize);
        for (int i = 0; i < queueSize; i++) {
            int element = scanner.nextInt();
            queue.enqueue(element);
        }
        
        queue.print();
        reverseQueue(queue);
        queue.print();
    }
}

如果有任何問題或需要更多說明，您可以發表評論。