Day10--数据结构与算法（Java) 栈与队列的实现

目录

一、232.用栈实现队列

二、225. 用队列实现栈 

对于Queue 

对于Deque

1、用一个队列来实现，把前n-1个数再次入队(同时n要--），这样先进去的元素就最后出来。

用Queue来实现

 用双端队列Deque来实现

2、用两个队列来实现

---

一、232.用栈实现队列

力扣题目链接

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();
    }
// 如果stackOut为空，那么将stackIn中的元素全部放到stackOut中
    private void dumpStackIn()
    {
        if(!stackOut.empty()) return;
        while(!stackIn.empty())
        {
            stackOut.push(stackIn.pop());
        }
    }
}

/**
 * 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();
 * boolean param_4 = obj.empty();
 */

重难点：

// 如果stackOut为空，那么将stackIn中的元素全部放到stackOut中

二、225. 用队列实现栈 

力扣题目链接

对于Queue 

 

对于Deque

 

addFirst(): 向队头插入元素，如果元素为空，则发生NPE(空指针异常)
addLast(): 向队尾插入元素，如果为空，则发生NPE
offerFirst(): 向队头插入元素，如果插入成功返回true，否则返回false
offerLast(): 向队尾插入元素，如果插入成功返回true，否则返回false
removeFirst(): 返回并移除队头元素，如果该元素是null，则发生NoSuchElementException
removeLast(): 返回并移除队尾元素，如果该元素是null，则发生NoSuchElementException
pollFirst(): 返回并移除队头元素，如果队列无元素，则返回null
pollLast(): 返回并移除队尾元素，如果队列无元素，则返回null
getFirst(): 获取队头元素但不移除，如果队列无元素，则发生NoSuchElementException
getLast(): 获取队尾元素但不移除，如果队列无元素，则发生NoSuchElementException
peekFirst(): 获取队头元素但不移除，如果队列无元素，则返回null
peekLast(): 获取队尾元素但不移除，如果队列无元素，则返回null
pop(): 弹出栈中元素，也就是返回并移除队头元素，等价于removeFirst()，如果队列无元素，则发生NoSuchElementException
push(): 向栈中压入元素，也就是向队头增加元素，等价于addFirst()，如果元素为null，则发生NPE，如果栈空间受到限制，则发生IllegalStateException

1、用一个队列来实现，把前n-1个数再次入队(同时n要--），这样先进去的元素就最后出来。

用Queue来实现

class MyStack {
    Queue<Integer> queue1;
    public MyStack() {
    queue1=new LinkedList<>();
    }
    
    public void push(int x) {
     queue1.offer(x);
     int size=queue1.size();
     while(size-->1)
     {
         queue1.offer(queue1.poll());//把前size-1个重新入队,同时size--
     }
    }
    
    public int pop() {
    return queue1.poll();
    }
    
    public int top() {
   return  queue1.peek();
    }
    
    public boolean empty() {
    return queue1.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();
 */

 可以改用下面的方法，结果是一样的

class MyStack {
    Queue<Integer> queue1;
    public MyStack() {
    queue1=new LinkedList<>();
    }
    
    public void push(int x) {
     queue1.add(x);
     int size=queue1.size();
     while(size-->1)
     {
         queue1.add(queue1.remove());//把前size-1个重新入队,同时size--
     }
    }
    
    public int pop() {
    return queue1.remove();
    }
    
    public int top() {
   return  queue1.element();
    }
    
    public boolean empty() {
    return queue1.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();
 */

 用双端队列Deque来实现

class MyStack {
     Deque<Integer>deque1;
    public MyStack() {
   deque1=new ArrayDeque<>();
    }
    
    public void push(int x) {
    deque1.offerLast(x);
    }
    
    public int pop() {
    int size=deque1.size();
    size--;
    while(size-->0)
    {
        deque1.addLast(deque1.peekFirst());
        deque1.pollFirst();
    }
    int result=deque1.pollFirst();
    return result;
    }
    
    public int top() {
     return deque1.peekLast();
    }
    
    public boolean empty() {
   return deque1.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();
 */

2、用两个队列来实现

如下面动画所示，用两个队列que1和que2实现队列的功能，que2其实完全就是一个备份的作用，把que1最后面的元素以外的元素都备份到que2，然后弹出最后面的元素，再把其他元素从que2导回que1。

 

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>tempQueue;
    tempQueue=queue1;
    queue1=queue2;
    queue2=tempQueue;
    }

    
    public int pop() {
    return queue1.poll();
    }
    
    public int top() {
    return queue1.peek();
    }
    
    public boolean empty() {
    return  queue1.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();
 */