栈实现队列与队列实现栈实战

一、栈是什么？

栈的定义:

栈作为一种数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照后进先出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。栈具有记忆作用，对栈的插入与删除操作中，不需要改变栈底指针。

栈的特点: 先进后出

二、队列是什么?

队列的定义:

队列是一种特殊的线性表，它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。在队列这种数据结构中，最先插入的元素将是最先被删除的元素；反之最后插入的元素将最后被删除的元素，因此队列又称为“先进先出”（FIFO—first in first out）的线性表。

队列的特点: 先进先出

三、栈实现队列

代码如下: 利用栈先进后出的特性

import java.util.Stack;

/**
 * @author ChuYao
 * @version 1.0
 * @date 2021/8/4 10:22
 * @description: TODO 栈实现对队列
 */
public class StackImplQueue {

    /**
     * 定义两个栈来实现队列
     * 利用栈先进后出的特性
     * A栈负责插入元素
     * B栈负责移除元素
     */
    private Stack<Object> stackA = new Stack<>();
    private Stack<Object> stackB = new Stack<>();


    /**
     * 入对操作 stackA负责插入元素
     * @param object
     * @return
     */
    public boolean enQueue(Object object){
        try{
            stackA.push(object);
            return true;
        }catch (Exception e){
            return false;
        }

    }

    /**
     * 出对操作 stackB负责移除元素
     * 注意: B栈为空时可以进行copy,B栈不为空需要插入元素的话要做好扩容处理,可能会发送下标越界.
     * @return
     */
    public Object deQueue(){
        if (stackB.isEmpty()){
            if (stackA.isEmpty()){
                return null;
            }
            stackACopyToStackB();
        }
        return stackB.pop();

    }

    /**
     * 从stackA栈中拿到出栈元素压入stackB
     */
    private boolean stackACopyToStackB() {
        try{
            while(!stackA.isEmpty()){
                stackB.push(stackA.pop());
            }
            return true;
        }catch (Exception e){
            return false;
        }
    }


    /**
     * Test
     */
    public static void main(String[] args) {
        StackImplQueue stackImplQueue = new StackImplQueue();
        stackImplQueue.enQueue(1);
        stackImplQueue.enQueue(2);
        stackImplQueue.enQueue(3);
        stackImplQueue.enQueue(4);

        System.out.println(stackImplQueue.deQueue());
        System.out.println(stackImplQueue.deQueue());

        stackImplQueue.enQueue(5);
        stackImplQueue.enQueue(6);
        stackImplQueue.enQueue(7);
        stackImplQueue.enQueue(8);

        System.out.println(stackImplQueue.deQueue());
        System.out.println(stackImplQueue.deQueue());
        System.out.println(stackImplQueue.deQueue());
        System.out.println(stackImplQueue.deQueue());
        System.out.println(stackImplQueue.deQueue());
        System.out.println(stackImplQueue.deQueue());

    }

}

四、队列实现栈

代码如下: 利用队列先进先出的特性

import java.util.ArrayDeque;
import java.util.Queue;

/**
 * @author ChuYao
 * @version 1.0
 * @date 2021/8/4 11:31
 * @description: TODO 队列实现栈
 */
public class QueueImplStack {

    /**
     * 定义两个队列来实现栈
     * 利用队列特性:先进先出
     * A队列负责插入元素
     * B队列负责元素转存
     */
    private Queue<Object> queueA = new ArrayDeque<>();
    private Queue<Object> queueB = new ArrayDeque<>();


    public boolean push(Object object){
        try {
            if (queueA.isEmpty() && queueB.isEmpty()) {
                queueA.offer(object);
            }

            if (queueA.isEmpty()) {
                queueB.offer(object);
            }

            if(queueB.isEmpty()) {
                queueA.offer(object);
            }

            return true;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     *
     * 队列先进先出,最后一个元素就是最后进的
     * 栈先进后出,反过来的话就是后进先出
     *
     * 那么我们就可以
     * 将A队列元素拷贝给B队列,拷贝到A队列最后一个元素时弹出
     * 在将B队列元素拷贝给A队列,拷贝B队列最后一个元素时弹出
     *
     * 以此类推
     * @return
     */
    public Object pop(){
        if(queueA.isEmpty() && queueB.isEmpty()) {
            return null;
        }

        if (queueA.isEmpty()) {
            while (queueB.size() > 1) {
                queueA.offer(queueB.poll());
            }
            return queueB.poll();
        }

        if (queueB.isEmpty()) {
            while (queueA.size() > 1) {
                queueB.offer(queueA.poll());
            }
            return queueA.poll();
        }

        return null;
    }



    /**
     * Test
     */
    public static void main(String[] args) {
        QueueImplStack queueImplStack = new QueueImplStack();
        queueImplStack.push(1);
        queueImplStack.push(2);
        queueImplStack.push(3);
        queueImplStack.push(4);


        System.out.println(queueImplStack.pop());
        System.out.println(queueImplStack.pop());
        System.out.println(queueImplStack.pop());
        System.out.println(queueImplStack.pop());

        queueImplStack.push(5);
        queueImplStack.push(6);
        System.out.println(queueImplStack.pop());
        System.out.println(queueImplStack.pop());
    }

}

总结:再小的帆,也要起航

只要学不死 就往死里学!