代码随想录算法训练营第十天| 232 用栈实现队列 225 用队列实现栈

目录

 232 用栈实现队列

225 用队列实现栈

用两个queue实现

方法一

方法二

用一个queue实现

方法一

方法二

用两个deque实现

方法一

用一个deque实现

方法一

---

 232 用栈实现队列

栈的特性：先进后出

队列的特性：先进先出

创建两个栈stackIn与stackOut。

push操作：将元素添加到stackIn中。

pop操作：判断stackOut中是否有值，若有则输出stackOut中的值，若无则将stackIn中的值全部加入到stackOut中，再输出stackOut中的值。

peek操作：判断stackOut中是否有值，若有则输出stackOut中的值，若无则将stackIn中的值全部加入到stackOut中，再返回stackOut的peek方法。

                stack的peek方法（返回栈顶的元素但不移出它）

empty操作：判断stackIn与stackOut是否都为空

class MyQueue {
    Stack<Integer> stackIn;
    Stack<Integer> stackOut;
    public MyQueue() {
        stackIn = new Stack<>();
        stackOut = new Stack<>();
    }
    
    public void push(int x) {
        stackIn.push(x);
    }
    
    public int pop() {
        dumpStackIn();
        return stackOut.pop();
    }
    
    public int peek() {
        dumpStackIn();
        return stackOut.peek();
    }
    
    public boolean empty() {
        return stackIn.isEmpty() && stackOut.isEmpty();
    }
    private void dumpStackIn(){
        if(!stackOut.empty())return;
        while(!stackIn.isEmpty()){
            stackOut.push(stackIn.pop());
        }
    }
}

时间复杂度:push,empty为O(1),peek与pop为O(n)

空间复杂度O(n) 

225 用队列实现栈

用两个queue实现

方法一

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());//poll删除队列头部元素
            //offer向队列尾部添加元素
        }
        Queue<Integer> queueTemp;
        queueTemp = queue1;
        queue1 = queue2;
        queue2 = queueTemp;
    }
    
    public int pop() {
        return queue1.poll();
    }
    
    public int top() {
        return queue1.peek();
    }
    
    public boolean empty() {
        return queue1.isEmpty();
    }
}

时间复杂度：push为O(n) 其余为O(1)

空间复杂度O(n)

方法二

class MyStack {
    Queue<Integer>queue1;
    Queue<Integer>queue2;
    public MyStack() {
        queue1 = new LinkedList<>();
        queue2 = new LinkedList<>();
    }
    
    public void push(int x) {
        while(queue1.size() > 0){
            queue2.add(queue1.poll());//获取并删除queue1的队头元素，将其加入到queue2中
        }
        queue1.add(x);
        while(queue2.size() > 0){
            queue1.add(queue2.poll());//获取并删除queue2的队头元素，将其加入到queue1中
        } 
    }
    
    public int pop() {
        return queue1.poll();
    }
    
    public int top() {
        return queue1.peek();
    }
    
    public boolean empty() {
        return queue1.isEmpty();
    }
}

时间复杂度push为O(n) 其余为O(1)

空间复杂度O(n)

用一个queue实现

方法一

class MyStack {
    Queue<Integer> queue;
    public MyStack() {
        queue = new LinkedList<>();
    }
    
    public void push(int x) {
        queue.offer(x);//向queue的尾部添加x
        int size = queue.size();
        size--;
        while(size-- > 0){
            queue.offer(queue.poll());
        }
    }
    
    public int pop() {
        return queue.poll();
    }
    
    public int top() {
        return queue.peek();
    }
    
    public boolean empty() {
        return queue.isEmpty();
    }
}

时间复杂度push为O(n) 其余为O(1)

空间复杂度O(n)

方法二

class MyStack {
    Queue<Integer>queue;
    public MyStack() {
        queue = new LinkedList<>();
    }
    
    public void push(int x) {
        queue.add(x);
    }
    
    public int pop() {
        rePosition();
        return queue.poll();
    }
    
    public int top() {
        rePosition();
        int res = queue.poll();
        queue.add(res);
        return res;
    }
    
    public boolean empty() {
        return queue.isEmpty();
    }
    public void rePosition(){
        int size = queue.size();
        size--;
        while(size-- > 0){
            queue.add(queue.poll());
        }
    }
}

时间复杂度push,empty为O(1) 其余为O(n)

空间复杂度O(n)

用两个deque实现

方法一

class MyStack {
    Deque<Integer>deque1;
    Deque<Integer>deque2;
    public MyStack() {
        deque1 = new ArrayDeque<>();
        deque2 = new ArrayDeque<>();
    }
    
    public void push(int x) {
        deque1.addLast(x);
    }
    
    public int pop() {
        int size = deque1.size();
        size--;
        while(size-- > 0){
            deque2.addLast(deque1.peekFirst());
            deque1.pollFirst();
        }
        int res = deque1.pollFirst();
        deque1 = deque2;
        deque2 = new ArrayDeque<>();
        return res;
    }
    
    public int top() {
        return deque1.peekLast();
    }
    
    public boolean empty() {
        return deque1.isEmpty();
    }
}

 时间复杂度 pop为O(n),其余为O(1)

空间复杂度 O(1)

用一个deque实现

方法一

class MyStack {
    Deque<Integer>deque;
    public MyStack() {
        deque = new ArrayDeque<>();
    }
    
    public void push(int x) {
        deque.addLast(x);
    }
    
    public int pop() {
        int size = deque.size();
        size--;
        while(size-- > 0){
            deque.addLast(deque.pollFirst());
        }
        int res = deque.pollFirst();
        return res;
    }
    
    public int top() {
        return deque.peekLast();
    }
    
    public boolean empty() {
        return deque.isEmpty();
    }
}

 时间复杂度 pop为O(n),其余为O(1)

空间复杂度 O(1)