Question

我尝试使用堆栈来实现队列Description。我的解决方案如下：

class MyQueue {
public:
    /** Initialize your data structure here. */
    stack<int> my_stack;
    MyQueue() {

    }

    /** Push element x to the back of queue. */
    void push(int x) {
        stack<int> my_new_stack;
        my_new_stack.push(x);
        for(int i = 0; i < my_stack.size();i++){
            my_new_stack.push(my_stack.top());
            my_stack.pop();
        }
        for(int i = 0; i< my_new_stack.size();i++){
            my_stack.push(my_new_stack.top());
            my_new_stack.pop();
        }
    }

    /** Removes the element from in front of queue and returns that element. */
    int pop() {  // what about queue is empty
        int temp = my_stack.top(); 
        my_stack.pop();
        return temp;
    }

    /** Get the front element. */
    int peek() {
        return my_stack.top();
    }

    /** Returns whether the queue is empty. */
    bool empty() {
        return my_stack.empty();
;
    }


};

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue obj = new MyQueue();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.peek();
 * bool param_4 = obj.empty();
 */

我的测试用例是

["MyQueue","empty","push","push","push","pop","pop","pop"]
[[],[],[1],[2],[3],[],[],[]]

结果是

[null,true,null,null,null,1,0,80] 真正的结果是 [null,true,null,null,null,1,2,3]

我知道效率很尴尬，但我真的不知道来自0和80的位置。

谢谢你的帮助！

Answer 1

仔细看看：

for(int i = 0; i < my_stack.size();i++){
    my_new_stack.push(my_stack.top());
    my_stack.pop();
}

并自己思考：每次循环时我i < my_stack.size()条件的结果是什么。提示：它并不总是堆栈的原始大小。

只要my_stack没有 空，你就会从my_new_stack转移到my_stack会好得多！

而且，是的，这个词被强调是有原因的，轻轻一推，眨眼眨眼： - ）

我还想指出你可以让这个方案更有效率。您可以将堆栈维持在一直处于启动状态的状态。但想想如果在提取任何项目之前插入一千个项目会发生什么。

堆栈中所有项目的两千次撤消。

更好的方法是存储当前模式（插入或提取），并且只在需要时才反转。

例如，请参阅以下伪代码：

def init(): # Initialise in insert mode. stack = [] mode = mode_insert def reverseStack(): # Transfer all items to get reverse order. newStack = [] while not stack.empty(): newStack.push(stack.top()) stack.pop() # Use reversed stack now. stack = newStack # Change mode. if mode == mode_insert: mode = mode_extract else mode = mode_insert def insert(item): # Put stack in right state and add the item. if mode == mode_extract: reverseStack() stack.push(item) def extract(): # Put stack in right state then get item out. if mode == mode_insert: reverseStack() item = stack.top() stack.pop() return item

如果您进行长时间的类似操作，并且如果您在插入和提取之间交替进行交替，则实际上基本上效率更高。

Answer 2

首先，你的push方法中存在一个逻辑错误，你应该确保在my_stack的底部推送新的int值（在你的交换之后）。

其次，在函数for中，stack.size（）不是一个不变量，它总是会改变，你同时使用i ++，所以你丢失了一些元素。我更喜欢。

我不擅长英语，希望你能帮助我。

当我在LeetCode中练习时，我遇到了一些奇怪的错误

2 个答案: