九号球普通 2023年9月2日上午10:22

题目不难，考的是数据结构的掌握

“`java
class MyStack {
private Queue queue;

public MyStack() {
    queue = new LinkedList<>();
}

public void push(int x) {
    int size = queue.size();
    queue.offer(x);
    for (int i = 0; i < size; i++) {
        queue.offer(queue.poll());
    }
}

public int pop() {
    return queue.poll();
}

public int top() {
    return queue.peek();
}

public boolean empty() {
    return queue.isEmpty();
}

}

0 赞同 0 条回复

招舟子普通 2023年8月25日上午1:36

“`java
class MyStack {
Queue q1;
Queue q2;
public MyStack() {
q1 = new LinkedList<>();
q2 = new LinkedList<>();
}

public void push(int x) {
    q2.offer(x);
    while(!q1.isEmpty()){
        q2.offer(q1.poll());
    }
    Queue<Integer> q3 = q1;
    q1 = q2;
    q2 = q3;
}

public int pop() {
        return q1.poll();
    }

public int top() {
     return q1.peek();

}

public boolean empty() {
    return q1.isEmpty();
}

}

/**
* Your MyStack object will be instantiated and called as such:
* MyStack obj = new MyStack();
* obj.push(x);
* int param_2 = obj.pop();
* int param_3 = obj.top();
* boolean param_4 = obj.empty();
*/
使用一个队列作为转换，保证每次入栈都在空队列上

0 赞同 0 条回复

mpweixin用户普通 2023年7月20日下午6:42

class MyStack {

LinkedList<Integer> list1; 
LinkedList<Integer> list2;

public MyStack() {
    list1 = new LinkedList<Integer>();
    list2 = new LinkedList<Integer>();
}

public void push(int x) {
    list1.offer(x);
}

public int pop() {
    if(list1.size() == 0){
        return -1;
    }
    while(list1.size() > 1){
        list2.offer(list1.poll());
    }
    int tmp = list1.poll();

    while(list2.size() != 0){
        list1.offer(list2.poll());
    }

    return tmp;


}

public int top() {
    if(list1.size() == 0){
        return -1;
    }
    while(list1.size() > 1){
        list2.offer(list1.poll());
    }
    int tmp = list1.peek();
    //没删除，所以需要将队列1完全挪到队列2中
    list2.offer(list1.poll());

    while(list2.size() != 0){
        list1.offer(list2.poll());
    }

    return tmp;


}

public boolean empty() {
    return list1.size() == 0;
}

}

0 赞同 0 条回复

ZJS 永久会员 2023年7月15日下午5:59

代码

class MyStack {
    Queue<Integer> q;
    int top;

    public MyStack() {
        q = new LinkedList();
        top = -1;
    }

    public void push(int x) {
        q.offer(x);
        top = x;
    }

    public int pop() {
        int size = q.size();

        while(size > 2){
            q.offer(q.poll());
            size--;
        }
        top = q.peek();
        q.offer(q.poll());


        return q.poll();
    }

    public int top() {
        return top;
    }

    public boolean empty() {
        return q.isEmpty();
    }
}

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

0 赞同 0 条回复

淡色花樱普通 2023年7月14日上午12:21

“`java
使用两个队列，其中一个进行辅助
时间复杂度插入O(n),删除O(1)
空间复杂度 O(n)
class MyList{
int data[100];
int ptr = 0;
int front = 0 ;
public:
MyList(){}
void push_back(int val){
data[ptr++] = val ;
}
int peek(){
if(ptr == front) return-1;
return data[front];
}
void pop_front(){ if(frontpush_back(x);
while(!primary->empty()){
secondary->push_back(primary->peek());
primary->pop_front();
}
std: : swap(primary, secondary);
}
int pop(){
int val = primary ->peek();}
primary ->pop_front();
return val;
}
int pop() { return primary ->peek():}
bool empty() { return primary ->empty(); }
};

0 赞同 0 条回复

BOZ 普通 2023年7月4日下午4:20

使用两个队列，其中一个进行辅助
【时间复杂度】插入O(n)，删除O(1)
【空间复杂度】O(n)

class MyList {
    int data[100];
    int ptr = 0;
    int front = 0;
public:
    MyList() {}

    void push_back(int val) {
        data[ptr++] = val;
    }

    int peek() {
        if (ptr == front) return -1;
        return data[front];
    }

    void pop_front() {if (front < ptr) front++;}

    int size() {return (ptr - front);}
    bool empty() {return !(ptr - front);}
};

class MyStack {
    MyList *primary, *secondary;
public:
    MyStack() {
        primary = new MyList();
        secondary = new MyList();
    }

    void push(int x) {
        secondary->push_back(x);
        while(!primary->empty()) {
            secondary->push_back(primary->peek());
            primary->pop_front();
        }
        std::swap(primary, secondary);
    }

    int pop() {
        int val = primary->peek();
        primary->pop_front();
        return val;
    }

    int top() {return primary->peek();}
    bool empty() {return primary->empty();}
};

0 赞同 0 条回复

mpweixin用户普通 2023年7月4日上午11:23

typedef struct {
    int* data;
    int front;
    int rear;
    int size;
} MyStack;

MyStack* myStackCreate() {
    MyStack* stack = (MyStack*)malloc(sizeof(MyStack));
    stack->data = (int*)malloc(sizeof(int));
    stack->front = 0;
    stack->rear = -1;
    stack->size = 0;
    return stack;
}

void myStackPush(MyStack* obj, int x) {
    obj->rear++;
    obj->data = (int*)realloc(obj->data, (obj->rear + 1) * sizeof(int));
    obj->data[obj->rear] = x;
    obj->size++;
}

int myStackPop(MyStack* obj) {
    int element = obj->data[obj->rear];
    obj->rear--;
    obj->size--;
    return element;
}

int myStackTop(MyStack* obj) {
    return obj->data[obj->rear];
}

bool myStackEmpty(MyStack* obj) {
    return obj->size == 0;
}

void myStackFree(MyStack* obj) {
    free(obj->data);
    free(obj);
}

时间复杂度为O(1)
空间复杂度为O(n)

0 赞同 0 条回复

Sexypig. 普通 2023年7月3日下午11:35

代码：

'''
这是一个用两个队列实现栈的类。主要的思路是，将元素压入非空的队列中，然后将另一个队列中的元素依次出队并入队到非空的队列中，
这样保证了栈的后进先出的特性。具体的实现如下：
- 初始化时，创建两个空的双端队列queue1和queue2。
- push方法：如果queue1非空，则将元素x压入queue1中；如果queue1为空，则将元素x压入queue2中。
- pop方法：如果queue1非空，则将queue1中的元素依次出队并入队到queue2中，直到queue1中只剩下一个元素，然后返回该元素；如果queue1为空，则将queue2中的元素依次出队并入队到queue1中，直到queue2中只剩下一个元素，然后返回该元素。
- top方法：如果queue1非空，则返回queue1的最后一个元素；如果queue1为空，则返回queue2的最后一个元素。
- empty方法：如果queue1和queue2都为空，则返回True；否则返回False。
'''

from collections import deque


class MyStack:

    def __init__(self):
        self.queue1:deque=deque()
        self.queue2:deque=deque()

    def push(self, x: int) -> None:
        if self.queue1:
            self.queue1.append(x)
        else:
            self.queue2.append(x)
    def pop(self) -> int:
        if self.queue1:
            while len(self.queue1)>1:
                self.queue2.append(self.queue1.popleft())
            return self.queue1.popleft()
        else:
            while len(self.queue2)>1:
                self.queue1.append(self.queue2.popleft())
            return self.queue2.popleft()

    def top(self) -> int:
        return self.queue1[-1] if self.queue1 else self.queue2[-1]

    def empty(self) -> bool:
        return not self.queue1 and not self.queue2


# Your MyStack object will be instantiated and called as such:
# obj = MyStack()
# obj.push(x)
# param_2 = obj.pop()
# param_3 = obj.top()
# param_4 = obj.empty()

这个实现中，我们使用两个队列 queue1 和 queue2 来模拟栈的行为。其中一个队列始终保持为空，另一个队列用于存储栈中的元素。在 push 操作中，我们将元素压入非空队列。在 pop 操作中，我们将非空队列中的元素依次转移到另一个队列，直到剩下最后一个元素，然后返回该元素。 top 操作返回非空队列中的最后一个元素。 empty 操作判断两个队列是否都为空。

0 赞同 0 条回复

憨憨永久会员 2023年7月3日上午10:51

将队2作为储存栈的容器，队1作为入栈的辅助容器，当进行入栈时，先将要入栈的元素入队，然后将队2元素对队1入队，此时刚入栈的元素就在队首，再将队1元素全部入队队2，此时完成入栈操作，出栈以及返回顶端，都对队2进行出队等操作即可

class MyStack {

    Queue<Integer> queue1;
    Queue<Integer> queue2;

    public MyStack() {
        queue1=new LinkedList<>();
        queue2=new LinkedList<>();
    }

    public void push(int x) {
        queue1.offer(x);
        while(!queue2.isEmpty()){
            queue1.offer(queue2.poll());
        }
        while(!queue1.isEmpty()){
            queue2.offer(queue1.poll());
        }
    }

    public int pop() {
        return queue2.isEmpty()?-1:queue2.poll();
    }

    public int top() {
        return queue2.isEmpty()?-1:queue2.peek();
    }

    public boolean empty() {
        return queue2.isEmpty();
    }
}

0 赞同 0 条回复

大大普通 2023年7月1日下午4:36

//C++
class MyStack {
public:
//a是基准，b是辅助；
queue<int>a,b;
    MyStack() {

    }

    void push(int x) {
     a.push(x);
    }

    int pop() {
     while(a.size()!=1){
         b.push(a.front());
         a.pop();
     }
     int t=a.front();
     a.pop();
     while(!b.empty()){
         a.push(b.front());
         b.pop();
     }
     return t;
    }

    int top() {
      while(a.size()!=1){
         b.push(a.front());
         a.pop();
     }
     int t=a.front();
     b.push(a.front());
     a.pop();
     while(!b.empty()){
         a.push(b.front());
         b.pop();
     }
     return t;
    }

    bool empty() {
    if(a.empty())
    return true;
    else return false;
    }
};

0 赞同 0 条回复

Tang 普通 2023年7月1日上午11:20

class MyStack {

    private Queue<Integer> inQueue;
    private Queue<Integer> outQueue;

    public MyStack() {
        inQueue = new LinkedList<>();
        outQueue = new LinkedList<>();
    }

    public void push(int x) {
        while (!inQueue.isEmpty()) {
            outQueue.offer(inQueue.poll());
        }
        inQueue.offer(x);
        while (!outQueue.isEmpty()) {
            inQueue.offer(outQueue.poll());
        }
    }

    public int pop() {
        return inQueue.poll();
    }

    public int top() {
        return inQueue.peek();
    }

    public boolean empty() {
        return inQueue.isEmpty();
    }
}

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

时间复杂度：
入栈：O(n)
出栈、获取栈顶元素、判断是否为空：O(1)
空间复杂度：O(n)

0 赞同 0 条回复

GGBond 普通 2023年7月1日上午8:44

//方法一：使用两个队列。
class MyStack {

    //插入时，后添加的元素添加到队头。queue2是辅助队列
    Queue<Integer> queue1;
    Queue<Integer> queue2;

    public MyStack() {
        queue1 = new LinkedList<>();
        queue2 = new LinkedList<>();
    }

    public void push(int x) {

        queue2.offer(x);
        while(!queue1.isEmpty()){
            queue2.offer(queue1.poll());
        }
        //交换
        Queue<Integer> temp = queue1;
        queue1 = queue2;
        queue2 = temp;
    }

    public int pop() {
        return queue1.poll();
    }

    public int top() {
        return queue1.peek();
    }

    public boolean empty() {
        return queue1.isEmpty();
    }
}

//方法二：使用一个队列
class MyStack {

    //插入时，后添加的元素添加到队头。
    Queue<Integer> queue1;

    public MyStack() {
        queue1 = new LinkedList<>();
    }

    public void push(int x) {
        int size = queue1.size();
        queue1.offer(x);
        for(int i = 0;i < size ;i++){
            //队头移动到队尾，这样新插入的元素就成为队头
            queue1.offer(queue1.poll());
        }
    }

    public int pop() {
        return queue1.poll();
    }

    public int top() {
        return queue1.peek();
    }

    public boolean empty() {
        return queue1.isEmpty();
    }
}

0 赞同 0 条回复

mpweixin用户普通 2023年6月30日下午9:40

java
class MyStack {
    private Queue<Integer> a;//輸入隊列
    private Queue<Integer> b;//輸出隊列
    public MyStack() {
        a = new LinkedList<>();
        b = new LinkedList<>();
    }

    public void push(int x) {
        a.offer(x);
        while(!b.isEmpty()) {
            a.offer(b.poll()); //使最开始进入的加入a的后面，实现后进先出
        }
        Queue tmp = a; //交換隊列，使得a为空
        a = b;
        b = tmp;
    }

    public int pop() {

        return b.poll();

    }
    public int top() {
        return b.peek();
    }

    public boolean empty() {
        return b.isEmpty();
    }
}

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

时间复杂度O(N), 空间复杂度O(1)

0 赞同 0 条回复

名字什么的好麻烦普通 2023年6月27日下午8:43

主队列辅助队列

class MyStack {
    Queue<Integer> queue1;
    Queue<Integer> queue2;

    public MyStack() {
        queue1 = new LinkedList<>();
        queue2 = new LinkedList<>();
    }

    public void push(int x) {
        queue2.offer(x);
        while(!queue1.isEmpty())
            queue2.offer(queue1.poll());
        Queue<Integer> temp = queue1;
        queue1=queue2;
        queue2=temp;
    }

    public int pop() {
        return queue1.poll();
    }

    public int top() {
        return queue1.peek();
    }

    public boolean empty() {
        return queue1.isEmpty();
    }
}

0 赞同 0 条回复

Dsjh 普通 2023年6月27日上午9:33

c++ 实现

class MyStack {
public:
    deque<int> q1;
    deque<int> q2;
    MyStack() {

    }

    void push(int x) {
        q2.push_back(x);
        while(!q1.empty()){
            int temp = q1.front();
            q1.pop_front();
            q2.push_back(temp);
        }
        // q1 的队尾是栈底，对头是栈头
        swap(q1,q2);
    }

    int pop() {
        int temp = q1.front();
        q1.pop_front();
        return temp;
    }

    int top() {
        return q1.front();
    }

    bool empty() {
        return q1.empty();
    }
};

0 赞同 0 条回复

mpweixin用户普通 2023年6月25日下午11:16

两个队列实现栈

class MyStack:

    def __init__(self):
        self.q1, self.q2 = [], []

    def push(self, x: int) -> None:
        if not self.q1:
            self.q1.append(x)
        else:
            self.q2.append(x)
            while self.q1:
                self.q2.append(self.q1.pop(0))
            self.q1, self.q2 = self.q2, self.q1

    def pop(self) -> int:
        if not self.q1:
            return -1
        return self.q1.pop(0)

    def top(self) -> int:
        return self.q1[0]

    def empty(self) -> bool:
        return not self.q1


# Your MyStack object will be instantiated and called as such:
# obj = MyStack()
# obj.push(x)
# param_2 = obj.pop()
# param_3 = obj.top()
# param_4 = obj.empty()

0 赞同 0 条回复

拾陆. 普通 2023年6月25日下午10:24

class MyStack {
public:
    MyStack() {


<pre><code>}

void push(int x) {
    que2.push(x);
    while(!que1.empty()){
        que2.push(que1.front());
        que1.pop();
    }
    swap(que1, que2);
}

int pop() {
    int res = que1.front();
    que1.pop();
    return res;
}

int top() {
    return que1.front();
}

bool empty() {
    return que1.empty();
}
</code></pre>

private:
    queue<int> que1;
    queue<int> que2;
};

实现

0 赞同 0 条回复

普通 2023年6月25日下午1:49

class MyStack {

    LinkedList<Integer> leftLinkedList;
    LinkedList<Integer> rightLinkedList;

    public MyStack() {
        leftLinkedList = new LinkedList<>();
        rightLinkedList = new LinkedList<>();
    }

    public void push(int x) {
        rightLinkedList.offer(x);
        while (!leftLinkedList.isEmpty()) {
            rightLinkedList.offer(leftLinkedList.poll());
        }
        LinkedList<Integer> temp = leftLinkedList;
        leftLinkedList = rightLinkedList;
        rightLinkedList = temp;
    }

    public int pop() {
        return leftLinkedList.pop();
    }

    public int top() {
        return leftLinkedList.peek();
    }

    public boolean empty() {
        return leftLinkedList.isEmpty();
    }
}

时间复杂度:O(1)

0 赞同 0 条回复

Tlhey 普通 2023年6月25日上午3:01

“`C++
//q1,q2是两个queue，然后每次top和pop就把一个队列力的全部元素转移到另一个里面。但是觉得时间每次top 和pop都是O(n)的，比较慢
class CQueue {
private:
stack st1;
stack st2;

public:
CQueue() {
}

void appendTail(int value) {
    st1.push(value);
}

int deleteHead() {
    int value=-1;
    if(!st2.empty()){
        value = st2.top();
        st2.pop();
        return value;
    }
    if(st1.empty())return value;
    while(!st1.empty()){
        st2.push(st1.top());
        st1.pop();
    }
    value = st2.top();
    st2.pop();
    return value;

}

};

/**
* Your CQueue object will be instantiated and called as such:
* CQueue* obj = new CQueue();
* obj->appendTail(value);
* int param_2 = obj->deleteHead();
*/
“`

0 赞同 0 条回复

地平线真勇敢普通 2023年6月24日下午10:29

JAVA用队列实现栈
class MyStack {
private Queue queue1;
private Queue queue2;
public MyStack() {
queue1 = new LinkedList<>();
queue2 = new LinkedList<>();
}

public void push(int x) {
    queue1.offer(x);
    while(!queue2.isEmpty()){
        queue1.offer(queue2.poll());
    }
    Queue temp = queue1;
    queue1 = queue2;
    queue2 = temp;
}

public int pop() {
    return queue2.poll();
}

public int top() {
    return queue2.peek();
}

public boolean empty() {
    return queue2.isEmpty();
}

}
时间复杂度：o(1)

0 赞同 0 条回复

Bello~ 普通 2023年6月24日下午9:28

实现

class MyStack {

    Queue<Integer> queue1;


    public MyStack() {
        queue1 = new LinkedList<>();
    }

    public void push(int x) {
        queue1.add(x);
    }

    public int pop() {
        Queue<Integer> queue2 = new LinkedList<>();
        while (queue1.size() > 1) {
            queue2.add(queue1.remove());
        }
        int temp = queue1.remove();
        queue1 = queue2;
        return temp;
    }

    public int top() {
        int temp = pop();
        queue1.add(temp);
        return temp;
    }

    public boolean empty() {
        return queue1.isEmpty();
    }
}

0 赞同 0 条回复

mpweixin用户普通 2023年6月24日下午9:02

C++实现

class MyStack {
public:
    MyStack() {

    }   
    void push(int x) {
        if(d1.empty() && d2.empty()){
            d1.push(x);
        }else if(d1.empty() && !d2.empty()){
            d2.push(x);
        }else if(d2.empty() && !d1.empty()){
            d1.push(x);
        }
    }

    int pop() {
        int k = 0;
        if(d1.empty() && d2.empty()){
            return false;
        }else if(d1.empty() && !d2.empty()){
            while(d2.size() != 1){
                d1.push(d2.front());
                d2.pop();
            }
            k = d2.front();
            d2.pop();
        }else if(d2.empty() && !d1.empty()){
            while(d1.size() != 1){
                d2.push(d1.front());
                d1.pop();
            }
            k = d1.front();
            d1.pop();          
        }
        return k;
    }

    int top() {
        int result = 0;
        if(d1.empty() && d2.empty()){
            return false;
        }else{
            result = this -> pop();
            this -> push(result);
        }
        return result;
    }

    bool empty() {
        if(d1.empty() && d2.empty()) return true;
        return false;
    }
    queue<int> d1;
    queue<int> d2;
};

0 赞同 0 条回复

* 普通 2023年6月24日下午8:58

”’java实现
class MyStack {
Queue myQueue = new LinkedList();
public MyStack() {
}

public void push(int x) {
    int n=myQueue.size();
    Queue<Integer> tempQueue = new LinkedList();
    for(int i=0;i<n;i++){
        tempQueue.add(myQueue.poll());
    }
    myQueue.add(x);
    for(int i=0;i<n;i++){
        myQueue.add(tempQueue.poll());
    }
}

public int pop() {
    return (int)myQueue.poll();
}

public int top() {
    return (int)myQueue.peek();
}

public boolean empty() {
    return myQueue.isEmpty();
}

}

0 赞同 0 条回复

mpweixin用户普通 2023年6月24日下午2:20

C++
永远保证最新入栈的在队列的最前端
TC: O(n)
SC: O(n)

“`c++
class MyStack {
queueque;
public:
MyStack() {

}

void push(int x) {
    que.push(x);
    int sz = que.size();
    for (int i = 0; i < sz - 1; i++) {
        int curr = que.front();
        que.pop();
        que.push(curr);
    }
}

int pop() {
    int curr = que.front();
    que.pop();
    return curr;
}

int top() {
    return que.front();
}

bool empty() {
    return que.empty();
}

};

/**
* Your MyStack object will be instantiated and called as such:
* MyStack* obj = new MyStack();
* obj->push(x);
* int param_2 = obj->pop();
* int param_3 = obj->top();
* bool param_4 = obj->empty();
*/

“`

0 赞同 0 条回复

哈哈哈哈开开心心普通 2023年6月24日上午7:29

注意import deque

from collections import deque
class MyStack:

    def __init__(self):
        self.queueA = deque()
        self.queueB = deque()

    def push(self, x: int) -> None:
        while self.queueA:
            self.queueB.append(self.queueA.popleft())

        self.queueA.append(x)

        while self.queueB:
            self.queueA.append(self.queueB.popleft())


    def pop(self) -> int:
        return self.queueA.popleft()


    def top(self) -> int:
        return self.queueA[0]

    def empty(self) -> bool:
        return not self.queueA



# Your MyStack object will be instantiated and called as such:
# obj = MyStack()
# obj.push(x)
# param_2 = obj.pop()
# param_3 = obj.top()
# param_4 = obj.empty()

0 赞同 0 条回复

彦，，# 普通 2023年6月23日下午11:26

需要注意的是队列只能移除队首的元素，但是可以获取队尾的元素

class MyStack {
private:
    queue<int> queque1; 
    queue<int> queque2; 
public:
    MyStack() {
    }
    //删除队列始终保持一个删除元素
    void in2out(queue<int> &inQueque,queue<int> &outQueque)
    {
        if(outQueque.empty())
        {
            if(inQueque.empty() || inQueque.size() == 1) return;
            while(!inQueque.empty() && inQueque.size() > 1)
            {
                outQueque.push(inQueque.front());
                inQueque.pop();
            }
        }
    }
    void push(int x) {
        if(queque1.empty())
            queque2.push(x);
        else 
            queque1.push(x);
    }

    int pop() {
        int re = -1;
        if(queque1.empty() && queque2.empty()) return re;
        if(queque1.empty())
        {
            in2out(queque2, queque1);
            re = queque2.front();
            queque2.pop();
        }else{
            in2out(queque1, queque2);
            re = queque1.front();
            queque1.pop();    
        }
        return re;
    }

    int top() {
        int re =-1;
        if(queque1.empty() && queque2.empty()) return re;
        if(queque1.empty())
        {
            re = queque2.back();

        }else{
            re = queque1.back();    
        }
        return re;
    }

    bool empty() {
        if(queque1.empty() && queque2.empty())
            return true;
        else 
            return false;
    }
};

0 赞同 0 条回复

哈哈哈普通 2023年6月23日下午9:32

思路：这道题虽然和上一道题的栈很相似，但是不知道为啥自己头脑突然跟短路了一样，一直想不起来怎么进行实现，后面查看评论区coder的解释，差不多能清楚了解。主要思路：使用一个临时队列queue2，用于进行队列的建立，不永久进行数据存储；queue1进行数据存储，temp作为临时转置队列。首先将新插入的数据存放在queue2中再将queue1中的数据存放在queue2中，使得后加入的数据在队头，实现先进后出。
为了保证每次都能进行如此的转置，所以需要一个固定的空链表，因此利用temp将queue1和queue2进行互换。互换成功之后可以直接使用remove、peek、进行栈相关数据的实现。
时间复杂度为O(1)、空间复杂度为O（n/m）

class MyStack {
    Queue<Integer> queue1;
    Queue<Integer> queue2;
    public MyStack() {
        queue1 = new LinkedList<>();
        queue2 = new LinkedList<>();
    }

    public void push(int x) {
        queue2.add(x);
            while(!queue1.isEmpty()){
                queue2.add(queue1.remove());
            }
        Queue temp=queue2;
        queue2 = queue1;
        queue1 = temp;
    }

    public int pop() {
       return queue1.remove();
    }

    public int top() {
        return queue1.peek();
    }

    public boolean empty() {
        return queue1.isEmpty()&&queue2.isEmpty();
    }
}

（小声bibi，我写的思路估计也就自己能看懂，胡言乱语中）

0 赞同 0 条回复

张开怀普通 2023年6月23日下午8:46

将队列头部的元素（除最后一个元素外），重新添加到队列尾部，此时再去弹出元素就是栈的顺序。

class Mystack{
public:
     queue<int> que;

      MyStack(){
      }

      void push(int x){
           que.push(x);
      }

      int pop(){
           int size = que.size();
           size--;
           // 将队列头部的元素（除最后一个元素外）重新添加到队列尾部
           while(size--){
                que.push(que.front());
                que.pop();
           }
           int result = que.front();
           que.pop();
           return result;
      }

      int top(){
           return que.back();
      }

      bool empty(){
            return que.empty();
      }
}

0 赞同 0 条回复

mpweixin用户普通 2023年6月23日下午7:56

两个队列实现栈
class MyStack:

    def __init__(self):
        self.queue1 = []
        self.queue2 = []

    def push(self, x: int) -> None:
        if not self.queue1:
            self.queue1.append(x)
        else:
            self.queue2.append(x)
            while self.queue1:
                self.queue2.append(self.queue1[0])
                self.queue1 = self.queue1[1:]
            self.queue1 = self.queue2
            self.queue2 = []

    def pop(self) -> int:
        tmp = self.queue1[0]
        self.queue1 = self.queue1[1:]
        return tmp

    def top(self) -> int:
        return self.queue1[0]

    def empty(self) -> bool:
        return not self.queue1



# Your MyStack object will be instantiated and called as such:
# obj = MyStack()
# obj.push(x)
# param_2 = obj.pop()
# param_3 = obj.top()
# param_4 = obj.empty()

0 赞同 0 条回复

～普通 2023年6月23日下午6:40

c++解题思路
class MyStack {
queue q1;
queue q2;
public:
MyStack() {
queue qt1;
q1 = qt1;
queue qt2;
q2 = qt2;
}

void push(int x) {
    if(q1.empty()){
        q2.push(x);
    }
    else{
        q1.push(x);
    }
}

int pop() {
    int res;
    if(q1.empty()){
        while(q2.size()>1){
            q1.push(q2.front());
            q2.pop();
        }
        res = q2.front();
        q2.pop();
    }
    else{
        while(q1.size()>1){
            q2.push(q1.front());
            q1.pop();
        }
        res = q1.front();
        q1.pop();
    }
    return res;
}

int top() {
    return q1.empty()? q2.back():q1.back();
}

bool empty() {
    return q1.empty()&&q2.empty();
}

};

0 赞同 0 条回复

mpweixin用户普通 2023年6月23日下午4:14

思路：使用两个队列，一个队列代表是真正的栈，另外一个是辅助栈，即将入栈的元素先存放在辅助栈中，然后将真正栈中队列的元素入辅助栈，然后将元素交换至真正的栈。
”’c++
class MyStack {
public:
queue queue1; // 主栈
queue queue2; // 辅助栈
MyStack() {

}

void push(int x) {
    queue2.push(x);  // 元素先入辅助栈
    while(!queue1.empty()){ // 主栈不为空
        queue2.push(queue1.front());    // front() 获取栈顶元素
        queue1.pop();  // 将元素从栈中删除
    } 
    swap(queue1, queue2);
}
// 出栈，获取栈顶元素，并将其删除
int pop() {
    int r = queue1.front();
    queue1.pop();
    return r;
}
// 获取栈顶元素
int top() {
    int r = queue1.front();
    return r;
}
// 判断是否是空栈   
bool empty() {
    return queue1.empty();
}

};
””

0 赞同 0 条回复

花老爷普通 2023年6月23日下午2:08

使用一个队列模拟栈，当push时，先计算队列元素个数count，然后将元素移入队列尾端，并且将队首元素移到队尾count次，这样push的元素到了队首，保证了后入先出原则。
时间：O(n)
空间：O(n)

class MyStack {
    private Deque<Integer> queue;

    public MyStack() {
        queue = new ArrayDeque<>();
    }

    public void push(int x) {
        int count = queue.size();
        queue.offer(x);
        for (int i = 0; i < count; i++) {
            queue.offer(queue.poll());
        }
    }

    public int pop() {
        return queue.poll();
    }

    public int top() {
        return queue.peek();
    }

    public boolean empty() {
        return queue.isEmpty();
    }
}

0 赞同 0 条回复

张君雅小妹妹普通 2023年6月23日下午2:06

时间复杂度：O(n)
额外空间复杂度：O(1)

class MyStack {
    Queue<Integer> queue1;
    Queue<Integer> queue2;

    public MyStack() {
        queue1 = new LinkedList<>();
        queue2 = new LinkedList<>();
    }

    public void push(int x) {
        if(queue1.isEmpty()){ // 如果队列1为空，就把元素放到队列1
            queue1.offer(x);
            return;
        }
        queue2.offer(x);
        while(!queue1.isEmpty()){
            queue2.offer(queue1.poll());
        }
        Queue<Integer> tmp = queue1;
        queue1 = queue2;
        queue2 = tmp;
    }

    public int pop() {
        return queue1.poll();
    }

    public int top() {
        return queue1.peek();
    }

    public boolean empty() {
        return queue1.isEmpty();
    }
}

0 赞同 0 条回复

Yodl. 普通 2023年6月23日下午1:56

单队列

class MyStack {
public:
    MyStack() {

    }
    queue q;
    void push(int x) {
        // 反转队列，将新元素插到队头
        int size = q.size();
        q.push(x);
        while (size--){
            int temp = q.front();
            q.pop();
            q.push(temp);
        }
    }

    int pop() {
        int popEle = q.front();
        q.pop();
        return popEle;
    }

    int top() {
        return q.front();
    }

    bool empty() {
        return q.empty();
    }
};

双队列

class MyStack {
    queuea,b;
public:
    MyStack() {

    }

    void push(int x) {
        a.push(x);
    }

    int pop() {
        while(a.size()>1){
            b.push(a.front());
            a.pop();
        }
        int t=a.front();
        a.pop();
        while(!b.empty()){
            a.push(b.front());
            b.pop();
        }
        return t;
    }

    int top() {
        while(a.size()>1){
            b.push(a.front());
            a.pop();
        }
        int t=a.front();
        a.pop();
        b.push(t);
        while(!b.empty()){
            a.push(b.front());
            b.pop();
        }
        return t;
    }

    bool empty() {
        return !a.size();
    }
};

0 赞同 0 条回复

　　　　　　　　普通 2023年6月23日下午1:52

class MyStack {
    queue<int>a,b;
public:
    MyStack() {

    }

    void push(int x) {
        a.push(x);
    }

    int pop() {
        while(a.size()>1){
            b.push(a.front());
            a.pop();
        }
        int t=a.front();
        a.pop();
        while(!b.empty()){
            a.push(b.front());
            b.pop();
        }
        return t;
    }

    int top() {
        while(a.size()>1){
            b.push(a.front());
            a.pop();
        }
        int t=a.front();
        a.pop();
        b.push(t);
        while(!b.empty()){
            a.push(b.front());
            b.pop();
        }
        return t;
    }

    bool empty() {
        return !a.size();
    }
};

【时间O(n),空间O(n)】
插入正常
弹出需要倒出全部元素，弹出队尾元素

0 赞同 0 条回复

硬核洋葱普通 2023年6月23日上午11:15

class MyStack {
public:
    queue<int> qu1;
    queue<int> qu2;

    MyStack() {

    }

    void push(int x) {
        qu1.push(x);
    }

    int pop() {
        while(qu1.size() != 1){
            int num = qu1.front();
            qu1.pop();
            qu2.push(num);
        }
        int ans = qu1.front();
        qu1.pop();
        swap(qu1, qu2);
        return ans;
    }

    int top() {
        int num;
        while(!qu1.empty()){
            num = qu1.front();
            qu1.pop();
            qu2.push(num);
        }
        swap(qu1, qu2);
        return num;
    }

    bool empty() {
        if(qu1.empty())
            return true;
        return false;
    }
};

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack* obj = new MyStack();
 * obj->push(x);
 * int param_2 = obj->pop();
 * int param_3 = obj->top();
 * bool param_4 = obj->empty();
 */

1、自己想的方法
保持第一个队列存放所有元素，第二个队列为空
若要压栈，在有元素的队列里进队
若要出栈，把有元素的队列中除了最后一个元素之外的所有元素倒进另一个队列里面，交换队列
若要返回栈顶元素，把有元素的队列中的所有元素倒进另一个队列里面，此队清空，在倒最后一个元素的时候记录一下，这样就能返回栈顶了，交换队列
若两个队列都是空的，则返回 false
这样入栈简单，时间复杂度为O(1), 出栈和返回栈顶元素较难，时间复杂度为O(n)
2、看题解发现还有一种做法
一个队列按照队列前端是后入队数，队列后端是先入队数存储，一个队列为空
在获取栈顶元素和出栈时，操作第一个队列的前端即可
在入栈时，把新元素先放入第二个队列，然后，第一个队列的数依次出队，进入第二个队列，交换第一和第二个队列（这里可以用swap）
若第一个队列为空，则栈为空
这样入栈较难 O(n)，出栈和返回栈顶元素较简单 O(1)

0 赞同 0 条回复

peach 普通 2023年6月23日上午10:47

思路

使用一个队列即可，注意使用双端队列就没意思了，使用单端队列

代码

class MyStack { //使用一个队列即可

    private Deque<Integer> quene;

    public MyStack() {
        quene = new ArrayDeque(); //初始化
    }

    public void push(int x) {
        quene.addLast(x); //加入的时候，直接加入末尾
    }

    public int pop() { //弹出的时候注意，要把除了最后一个，其他的元素依次从对头弹出，加入队尾
        int size = quene.size();
        if(size == 1) return quene.removeFirst();
        while(size-- > 1){
            quene.addLast(quene.removeFirst());
        }
        return quene.removeFirst();
    }

    public int top() { //先pop，保存这个元素，再加入队尾，最后返回
        int res = pop();
        quene.addLast(res);
        return res;
    }

    public boolean empty() { //判断队列是否为空即可
        return quene.isEmpty();
    }
}

0 赞同 0 条回复

断舍离永久会员 2023年6月23日上午9:15

class MyStack {

    Queue<Integer> dequeIn;
    Queue<Integer> dequeOut;

    public MyStack() {
        dequeIn = new LinkedList<>();
        dequeOut = new LinkedList<>();
    }

    public void push(int x) {
        dequeIn.offer(x);
        //将dequeOut队列中元素全部转给dequeIn队列
        while(!dequeOut.isEmpty())
            dequeIn.offer(dequeOut.poll());
        //交换2个队列,使得输入队列没有在push()的时候始终为空队列，最后操作输出队列
        Queue temp = dequeIn;
        dequeIn = dequeOut;
        dequeOut = temp;
    }

    public int pop() {
        return dequeOut.poll();
    }

    public int top() {
        return dequeOut.peek();
    }

    public boolean empty() {
        return dequeOut.isEmpty();
    }

}

0 赞同 0 条回复

残月冷骄阳普通 2023年6月23日上午1:40

Problem: 225. 用队列实现栈

[TOC]

思路

两个队列，保持其中一个队列为空，作为新添加元素的入队队列，然后再添加另外一个队列中的元素就可以保证栈的顺序了。

解题方法

两个队列交替作为入栈的首队列。

复杂度

时间复杂度:

添加时间复杂度, 示例： $O(1)$
空间复杂度:

添加空间复杂度, 示例： $O(1)$

Code

“`Java []

class MyStack {

Queue<Integer> queue1;
Queue<Integer> queue2;

public MyStack() {
    this.queue1 = new LinkedList<>();
    this.queue2 = new LinkedList<>();
}

public void push(int x) {
    if (queue1.isEmpty()) {
        queue1.add(x);
        while (!queue2.isEmpty()) {
            queue1.addAll(queue2);
            queue2.clear();
        }
    } else {
        queue2.add(x);
        queue2.addAll(queue1);
        queue1.clear();
    }
}

public int pop() {
    return queue1.isEmpty() ? queue2.poll() : queue1.poll();
}

public int top() {
    return queue1.isEmpty() ? queue2.peek() : queue1.peek();
}

public boolean empty() {
    return queue1.isEmpty() && queue2.isEmpty();
}

}

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

“`

0 赞同 0 条回复

大鑫啊普通 2023年6月23日上午12:52

时空复杂度：O(n)
1、创建两个队列s1、s2，队列由LinkedList实现
2、当模拟入栈时，判断s1是否为空，若不为空则循环将s1的数据poll出到s2中，再s1 offer新的数据，再将s2中的依次入队列s1
3、其他操作可用队列自带方法，poll出队列第一个元素并删除原队列中该元素，peek取出队尾第一个元素不删除原队列

class MyStack {
    Queue<Integer> s1;
    Queue<Integer> s2;
    public MyStack() {
        s1 = new LinkedList<>();
        s2 = new LinkedList<>();
    }

    public void push(int x) {
        while(!s1.isEmpty()) s2.offer(s1.poll());
        s1.offer(x);
        while(!s2.isEmpty()) s1.offer(s2.poll());
    }

    public int pop() {
        return s1.poll();
    }

    public int top() {
        return s1.peek();
    }

    public boolean empty() {
        return s1.isEmpty();
    }
}

0 赞同 0 条回复

怀瑾永久会员 2023年6月22日下午11:48

C++实现

#include <queue>
using namespace std;

class MyStack {
public:
    MyStack() {

    }

    void push(int x) {
        q1.push(x);
        // 将 q1 中除了最后一个元素外的其他元素都移到 q2 中
        while (q1.size() > 1) {
            q2.push(q1.front());
            q1.pop();
        }
    }

    int pop() {
        int res = q1.front();
        q1.pop();
        // 将 q2 中的元素都插入到 q1 中，类似于出栈操作
        while (!q2.empty()) {
            q1.push(q2.front());
            q2.pop();
        }
        return res;
    }

    int top() {
        return q1.front();
    }

    bool empty() {
        return q1.empty() && q2.empty();
    }

private:
    queue<int> q1, q2;
};

0 赞同 0 条回复

江畅普通 2023年6月22日下午10:15

#include <iostream>
#include <queue>
using namespace std;

// 两个队列实现栈
// 时间复杂度：入栈操作 O(N), 其他操作 O(1)
// 空间复杂度：O(N)
class MyStack {
private:
    queue<int> q1; // 栈的操作基于该队列
    queue<int> q2; // 获取栈顶元素时, 用于存储 q1 队尾前面出队元素

public:
    MyStack() {}

    void push(int x) { q1.push(x); }

    int pop() {

        // q1 队尾前面元素出队, 存于 q2
        int size = q1.size();
        while (size > 1) {
            q2.push(q1.front());
            q1.pop();
            --size;
        }

        // 栈顶元素: q1 队尾元素
        int res = q1.front();
        q1.pop();

        // q2 元素再存回 q1
        q1 = q2;

        // 清空 q2
        while (!q2.empty()) {
            q2.pop();
        }
        return res;
    }

    int top() { return q1.back(); }

    bool empty() { return q1.empty(); }
};

int main() {
    /**
     * Your MyStack object will be instantiated and called as such:
     * MyStack* obj = new MyStack();
     * obj->push(x);
     * int param_2 = obj->pop();
     * int param_3 = obj->top();
     * bool param_4 = obj->empty();
     */

    MyStack* obj = new MyStack();
    obj->push(1);
    obj->push(2);
    cout << obj->top() << endl;
    cout << obj->pop() << endl;
    cout << obj->empty() << endl;

    return 0;
}

0 赞同 0 条回复

局外人普通 2023年6月22日下午9:01

思路：创建两个队列q1和q2。保持队列1为栈顶位置所在队列，当有入栈操作，将元素入队q2，再将q1中元素，全部入队q2，此时再交换q1和q2即可。剩下的操作就简单了，pop和top操作只需要取得q1队头即可，empty操作也只需要对q1判空即可

class MyStack {
public:
    queue<int> q1, q2;
    MyStack() {

    }

    void push(int x) {
        q2.push(x);
        while(!q1.empty()){
            int temp=q1.front(); q1.pop();
            q2.push(temp);
        }
        swap(q1, q2);
    }

    int pop() {
        int res = q1.front();
        q1.pop();
        return res;
    }

    int top() {
        return q1.front();
    }

    bool empty() {
        return q1.empty();
    }
};

0 赞同 0 条回复

行动派小彩笔普通 2023年6月22日下午8:44

// 两个队列，时间复杂度，需要遍历传元素O(n)
// 空间复杂度，最坏情况，队列满了O(n)
class MyStack {
public:
    MyStack() {

    }

    void push(int x) {

        q1.push(x);
    }

    int pop() {
        int n = q1.size()-1;
        while(n--)
        {
            q2.push(q1.front());
            q1.pop();
        }
        int ret = q1.front();
        q1.pop();
        //q1 = q2;
        swap(q1,q2);
        return ret;

    }

    int top() {
        return q1.back();
    }

    bool empty() {
        return q1.empty();
    }
private:
queue<int> q1;
queue<int> q2;
};

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack* obj = new MyStack();
 * obj->push(x);
 * int param_2 = obj->pop();
 * int param_3 = obj->top();
 * bool param_4 = obj->empty();
 */
// 一个队列实现
class MyStack {
public:
queue<int> q;
    MyStack() {

    }

    void push(int x) {
        int n = q.size();
        q.push(x);
        for(int i=0;i<n;++i)
        {
            q.push(q.front());
            q.pop();
        }
    }

    int pop() {
        int ret = q.front();
        q.pop();
        return ret;
    }

    int top() {
        return q.front();
    }

    bool empty() {
        return q.empty();
    }
};

1 赞同 0 条回复

Ming 普通 2023年6月22日下午8:34

这里是Ming的打卡：
利用一个队列模拟栈思路：每放入一个数就将这个数放入第一位，所以其他元素往后移动

class MyStack {
    Queue<Integer> q;
    public MyStack() {
        q = new LinkedList<Integer>();
    }

    public void push(int x) {
        q.offer(x);
        int size = q.size();
        //将x放入第一位
        while(size-- > 1) {
            q.offer(q.poll());
        }
    }

    public int pop() {
        return q.poll();
    }

    public int top() {
        return q.peek();
    }

    public boolean empty() {
        return q.isEmpty();
    }
}

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

0 赞同 0 条回复

yxy 普通 2023年6月22日下午8:19

不顺畅

class MyStack {
public:
    queue<int> q;
    MyStack() {

    }

    void push(int x) {
        q.push(x);
    }

    int pop() {
        int sz = q.size();
        while(sz>1)
        {
            sz--;
            int tmp=q.front();
            q.pop();
            q.push(tmp);
        }
        int tmp=q.front();
        q.pop();
        return tmp;
    }

    int top() {
        int sz = q.size();
        while(sz>1)
        {
            sz--;
            int tmp=q.front();
            q.pop();
            q.push(tmp);
        }
        int tmp=q.front();
        q.pop();
        q.push(tmp);
        return tmp;
    }

    bool empty() {
        return q.empty();
    }
};

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack* obj = new MyStack();
 * obj->push(x);
 * int param_2 = obj->pop();
 * int param_3 = obj->top();
 * bool param_4 = obj->empty();
 */

0 赞同 0 条回复

mpweixin用户永久会员 2023年6月22日下午7:10

//用一个空队列来接收新元素，使新元素始终在头部，保证“后进先出”，也就是栈
class MyStack {

    Queue<Integer> queueA;
    Queue<Integer> queueB;

    public MyStack() {
        queueA = new LinkedList();
        queueB = new LinkedList();
    }

    public void push(int x) {
        queueA.offer(x);
        while(!queueB.isEmpty()){
            queueA.offer(queueB.poll());
        }
        Queue<Integer> temp = queueA;
        queueA = queueB;
        queueB = temp;
    }

    public int pop() {   
        return queueB.poll();
    }

    public int top() { 
        return queueB.peek();
    }

    public boolean empty() {
        return queueB.isEmpty();
    }
}

0 赞同 0 条回复

伏月三十普通 2023年6月22日下午4:31

class MyStack {
LinkedList queue;
public MyStack() {
queue=new LinkedList<>();
}

public void push(int x) {
    queue.offer(x);
    //把前面都循环到队尾(从对头拿到队尾)
    for(int i=0;i<queue.size()-1;i++){
        queue.offer(queue.poll());  
    }
}

public int pop() {
    return queue.poll();
}

public int top() {
    return queue.peek();
}

public boolean empty() {
    if(!queue.isEmpty()){
        return false;
    }
    return true;
}

}

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

0 赞同 0 条回复

WhyBeBubble 普通 2023年6月22日下午4:27

class MyStack {


public:
    MyStack() {
    }

<pre><code>void push(int x) {
    q1.push_back(x);
    for(int i = 0; i < q1.size()-1; i++){
        auto top = q1.front();
        q1.pop_front();
        q1.push_back(top);
    }
}

int pop() {
    int res = q1.front();
    q1.pop_front();
    return res;
}

int top() {
    return q1.front();
}

bool empty() {
    return q1.empty();
}
</code></pre>

private:
    deque<int> q1;
};

0 赞同 0 条回复

小吕普通 2023年6月22日下午3:40

c++实现
private:
queueque1;
queueque2;
public:
MyStack() {

}

void push(int x) {
    que1.push(x);
}

int pop() {
    int len = que1.size();
    len--;
    int temp;
    while(len--)
    {
        temp = que1.front();
        que2.push(temp);que1.pop();
    }
    int result;
    result = que1.front();
    que1.pop();
    len = que2.size();
    while(len--)
    {
        temp = que2.front();
        que1.push(temp);
        que2.pop();
    }
    return result;
}

int top() {
    return que1.back();
}

bool empty() {
    return que1.empty();
}

0 赞同 0 条回复

désire. 普通 2023年6月22日下午3:09

“`c++
class CQueue {
public:
stack stIn;
stack stOut;
CQueue() {
}
//在队列尾部插入整数
void appendTail(int value) {
stIn.push(value);
}
//在队列头部删除整数
int deleteHead()
{
if(stIn.empty() && stOut.empty())
{
return -1;
}
//stOut为空
if(stOut.empty())
{
while(!stIn.empty())
{
stOut.push(stIn.top());
stIn.pop();
}
}
int result = stOut.top();
stOut.pop();
return result;
}
};

0 赞同 0 条回复

jhfuture 普通 2023年6月22日下午2:46

java实现

class MyStack {

    // 使用两个队列进行反复横跳
//当poll时，如果队列B为空，则将队列A中的size-1存放到B中，然后返回A的值
//反之则反过来。
//如果A、B都为空则-1.
    Queue<Integer> queueA;
    Queue<Integer> queueB;
    public MyStack() {
        queueA=new LinkedList<Integer>();
        queueB=new LinkedList<Integer>();

    }

    public void push(int x) {
        queueA.add(x);
    }

    public int poll() {
        if(queueB.isEmpty()&&queueA.isEmpty()) {return -1;};
        if (queueA.size()==1) {return  queueA.poll();}
        if (queueB.size()==1){return queueB.poll();}
        if(queueB.isEmpty()){
            int length=queueA.size();
            for(int i=0;i<length-1;i++){
                Integer value= queueA.poll();
                queueB.add(value);
            }
            return queueA.poll();
        }
        if(queueA.isEmpty()){
            int length=queueB.size();
            for(int i=0;i<length-1;i++){
                Integer value= queueB.poll();
                queueA.add(value);
            }
            return queueB.poll();
        }
        return -1;

    }

    public int top() {
        if(queueB.isEmpty()&&queueA.isEmpty()) {return -1;}
        if(queueB.isEmpty()){
            int length=queueA.size();
            for(int i=0;i<length-1;i++){
                Integer value= queueA.poll();
                queueB.add(value);
            }
            return queueA.peek();
        }
        if(queueA.isEmpty()){
            int length=queueB.size();
            for(int i=0;i<length-1;i++){
                Integer value= queueB.poll();
                queueA.add(value);
            }
            return queueB.peek();
        }
        return -1;
    }

    public boolean empty() {
        if(queueB.isEmpty()&&queueA.isEmpty()){ return true;}
        return false;
    }
}

idea中正常运行，不知道为什么LeetCode报错。

  public static void main(String[] args) {
        MyStack myStack = new MyStack();
        myStack.push(1);
        myStack.push(2);
        myStack.push(3);
        System.out.println("头部"+myStack.top());
        System.out.println("是否为空"+myStack.empty());
        System.out.println(myStack.poll());
        System.out.println(myStack.poll());
        System.out.println(myStack.poll());
        System.out.println("是否为空"+myStack.empty());

    }

头部3
是否为空false
3
2
1

是否为空true

0 赞同 0 条回复

【基本数据结构】LeetCode 225. 用队列实现栈

共以下 52 个回答

思路

代码

思路

解题方法

复杂度

Code

是否为空true

# 回答此问题取消回复

【基本数据结构】LeetCode 225. 用队列实现栈

共以下 52 个回答

思路

代码

思路

解题方法

复杂度

Code

是否为空true

# 回答此问题 取消回复

# 回答此问题取消回复