Question

public static Queue1 mirror(Queue1 s){
    int len = s.getSize();
    Queue1 ret = new Queue1(s.getSize());

    Queue1 tmp = new Queue1(s.getSize());

    while(ret.getSize()!=len){
        while(s.getSize()>1) tmp.insert(s.remove());
        ret.insert(s.remove());
        while(tmp.getSize()>1) s.insert(tmp.remove());
        ret.insert(tmp.remove());
    }

    return ret;
}

我的插入和删除方法的实现：

public void insert(int x){
    if(rear == maxsize-1) rear = -1;
    arr[++rear] =  x;

    count++;
}

public int remove(){
    int tmp = arr[front++];
    if(front==maxsize) front = 0;

    count--;
    return tmp;
}

除非我将Tmp的大小增加到s.getSize()+2，否则代码不起作用，在这种情况下，它会打印零。

有人可以解释一下发生了什么吗？

Answer 1

看起来你的循环缺少几个条件。

你的问题在这里：

while(ret.getSize()!=len){
    while(s.getSize()>1) tmp.insert(s.remove()); // 1
    ret.insert(s.remove()); // 2
    while(tmp.getSize()>1) s.insert(tmp.remove()); // 3
    ret.insert(tmp.remove()); // 4
}

假设您的输入是

s = [1 2 3]

第一次执行1：

之后

s = [3]
tmp = [1 2]
ret = []

2之后：

s = []
tmp = [1 2]
ret = [3]

3之后：

s = [1]
tmp = [2]
ret = [3]

之后4：

s = [1]
tmp = []
ret = [3 2]

然后你重复步骤1，但它没有做任何事情：

s = [1]
tmp []
ret = [3 2]

然后第2步：

s = []
tmp = []
ret = [3 2 1]

现在你已经完成了，但是你仍然可以在终止之前执行3和4。步骤3将不执行任何操作，但步骤4将为您提供错误，因为您尝试从空队列tmp中删除项目。

解决方案是添加几个条件：

while(ret.getSize()!=len){
    while(s.getSize()>1) tmp.insert(s.remove());
    if (s.getSize() > 0) ret.insert(s.remove());
    while(tmp.getSize()>1) s.insert(tmp.remove());
    if (tmp.getSize()>0) ret.insert(tmp.remove());
}

Answer 2

我希望它有所帮助。我想自己找到解决问题的方法：只使用队列来反转队列。以下是我提出的建议：

public class Queue1 {
    private int maxSize, count, front, rear;
    private int[] arr;

    public Queue1(int maxSize) {
        arr = new int[maxSize];
        this.maxSize = maxSize;
        count = 0;
        front = 0;
        rear = 0;
    }

    public boolean insert(int x) {
        if (count == maxSize)
            return false;
        arr[rear] = x;
        rear = (rear + 1) % maxSize;
        count++;
        return true;
    }

    public int remove() throws Exception {
        if (count == 0) {
            throw new Exception("Cannot remove from queue: it's empty!");
        }
        int ret = arr[front];
        front = (front + 1) % maxSize;
        count--;
        return ret;
    }

    public int getSize() {
        return count;
    }

    public static Queue1 mirror(Queue1 q) throws Exception {
        int n = q.getSize();
        Queue1 ret = new Queue1(n);
        Queue1 tmp = new Queue1(n);
        boolean f = true;
        while (ret.getSize() < n) {
            if (f) {
                while (q.getSize() > 1)
                    tmp.insert(q.remove());
                ret.insert(q.remove());
            } else {
                while (tmp.getSize() > 1)
                    q.insert(tmp.remove());
                ret.insert(tmp.remove());
            }
            f = !f;
        }
        return ret;
    }
}

希望它有所帮助！此解决方案有效。它遍历所有队列并到达最后一个元素并将其保存在ret队列中。它为所有元素执行此操作。

仅使用队列来反转队列。获取indexofbound异常

2 个答案: