【数据结构】10.两个队列实现栈

目录

一、解法思路

二、代码实现（测试+类的具体实现）

三、测试结果

---

一、解法思路

首先要晓得栈是先进先出，队列是先进后出

入队和入栈都是在尾部添加容易实现

出队是头处，入栈是尾出，需要把尾部之前的元素挨个出队到另一个队列中，再把剩下的最后一个元素出队就实现了栈的出栈功能

注意：移动到另外一个队列中的元素不用再返回到原来队列中去，意思就是队列A和B轮流充当实际意义上的栈，和两个栈实现队列不同之处在于此处。两个栈实现队列，需要规定一个为实际意义上的队列，另一个只是临时充当转移元素的打工人

1.需要借助两个队列来实现：

queueA,queueB

2.入栈操作：

当两个队列都为空时，优先入栈到队列A中

两个队列不都为空时，入栈到不为空的队列中

3.出栈操作

把不为空的队列队尾元素留下，其他都依次转移到另一个队列中

最后对只剩一个元素的队列出队操作

二、代码实现（测试+类的具体实现）

1.需要接着继承自己创建的Stack接口，就是对于栈的规范

package p2.线性结构;
import p1.接口.Stack;
import java.util.Iterator;
public class QueueToStack {
    public static void main(String[] args) {
        StackImplByQueue<Integer> stack=new StackImplByQueue<>();
        System.out.println(stack);
        for (int i=1;i<=5;i++){
            stack.push(i);
        }
        System.out.println(stack.toString());
        System.out.println(stack.pop());
        System.out.println(stack);
    }
}
class StackImplByQueue<E> implements Stack<E>{
    private ArrayQueue<E> queueA;
    private ArrayQueue<E> queueB;
    public StackImplByQueue() {
        queueA = new ArrayQueue<>();
        queueB = new ArrayQueue<>();
    }
    @Override
    //返回元素的个数
    public int size() {
        if (queueA.isEmpty()&&queueB.isEmpty()){
            return 0;
        }else if(!queueA.isEmpty()){
            return queueA.size();
        }else{
            return queueB.size();
        }
    }

    @Override
    //判空
    public boolean isEmpty() {
        return queueA.isEmpty()&&queueB.isEmpty();
    }

    @Override
    //入栈
    public void push(E element) {
        if (queueA.isEmpty()&&queueB.isEmpty()){
            queueA.offer(element);
        }else if(!queueA.isEmpty()){
            queueA.offer(element);
        }else{
            queueB.offer(element);
        }
    }

    @Override
    //出栈
    public E pop() {
        if (isEmpty()){
            return null;
        }
        E ret=null;
        if (!queueA.isEmpty()){
            while (queueA.size()!=1){
                queueB.offer(queueA.poll());
            }
            ret=queueA.poll();
        }else{
            while (queueB.size()!=1){
                queueA.offer(queueB.poll());
            }
            ret=queueB.poll();
        }
        return ret;
    }

    @Override
    public E peek() {
        if (isEmpty()){
            return null;
        }
        E ret=null;
        if (!queueA.isEmpty()){
            while (queueA.size()!=1){
                queueB.offer(queueA.poll());
            }
            ret=queueA.poll();
            queueB.offer(ret);
        }else{
            while (queueB.size()!=1){
                queueA.offer(queueB.poll());
            }
            ret=queueB.poll();
            queueA.offer(ret);
        }
        return ret;
    }

    @Override
    public void clear() {
        queueA.clear();
        queueB.clear();
    }

    @Override
    public Iterator<E> iterator() {
        if (isEmpty()) {
            return queueA.iterator();
        } else if (!queueA.isEmpty()) {
            return queueA.iterator();
        } else {
            return queueB.iterator();
        }
    }

    @Override
    public String toString() {
        if (isEmpty()) {
            return "[]";
        } else if (!queueA.isEmpty()) {
            return queueA.toString();
        } else {
            return queueB.toString();
        }
    }
}

三、测试结果