用队列实现栈

两个队列实现栈

首先准备两个队列A、B 可以使用ADD方法，先向A队列进入5个数据（也可以是n个这里用5做例子） 调用POP方法弹出最后一次进入数据（在2个队列中的非空的队列上的前n-1个数据移入空队列，最后一个数据出队列并返回）

非空队列：由来插入数据 空队列：用来倒数据，存数据

import java.util.LinkedList;
import java.util.Queue;

/**
 * @author Wang WenLei
 * @date 2024/4/22 11:30
 * @since 1.0
 */

public class Main {

    private static final Queue<Integer> A = new LinkedList<>();
    private static final Queue<Integer> B = new LinkedList<>();

    public static void main(String[] args) {
        add(1);
        add(2);
        add(3);
        add(4);
        add(5);
        System.out.println("前：" + A.toString() + B.toString());
        System.out.println("弹出：" + pop());
        System.out.println("pop后1：" + A.toString() + B.toString());
        add(6);
        System.out.println("add后2：" + A.toString() + B.toString());
        System.out.println(pop());
        System.out.println("add后3：" + A.toString() + B.toString());
    }

    /**
     * 队列模拟栈的压栈操作
     * 在2个队列中的非空的队列上数据
     *
     * @param data 压栈数据
     */
    public static void add(Integer data) {
        // 如果B队列为空，就在A的队列上追加
        if (B.size() == 0) {
            A.add(data);
        }

        // 如果A队列为空，就在B的队列上追加
        if (A.size() == 0) {
            B.add(data);
        }
    }

    /**
     * 队列模拟栈的出栈操作
     * 在2个队列中的非空的队列上的前n-1个数据移入空队列，最后一个数据出队列并返回
     */
    public static Integer pop() {
        // 如果B队列为空，就在A的队列上追加
        if (B.size() == 0) {
            int num = A.size() - 1;
            for (int i = 0; i < num; i++) {
                B.add(A.poll());
            }
            return A.poll();
        }

        // 如果A队列为空，就在B的队列上追加
        if (A.size() == 0) {
            int num = B.size() - 1;
            for (int i = 0; i < num; i++) {
                A.add(B.poll());
            }
            return B.poll();
        }
        return null;
    }

}

一个队列实现栈

压栈时，先把数据放在队列里，再把之前队列的数据重新出队列入队列

import java.util.LinkedList;
import java.util.Queue;

/**
 * @author Wang WenLei
 * @date 2024/4/22 11:30
 * @since 1.0
 */

public class Main {

    private static final Queue<Integer> A = new LinkedList<>();

    public static void main(String[] args) {
        add(1);
        add(2);
        add(3);
        add(4);
        add(5);
        System.out.println("前：" + A.toString());
        System.out.println("弹出：" + pop());
        System.out.println("pop后1：" + A.toString());
        add(6);
        System.out.println("add后2：" + A.toString());
        System.out.println(pop());
        System.out.println("add后3：" + A.toString());
    }

    /**
     * 队列模拟栈的压栈操作
     * 先把数据放在队列里，再把之前队列的数据重新出队列入队列
     *
     * @param data 压栈数据
     */
    public static void add(Integer data) {
        int size = A.size();
        A.add(data);
        for (int i = 0; i < size; i++) {
            A.add(A.poll());
        }
    }

    /**
     * 队列模拟栈的出栈操作
     */
    public static Integer pop() {
        return A.poll();
    }

}

双端队列

Java中有一个接口：Deque，为双端队列

import java.util.Deque;
import java.util.LinkedList;

/**
 * @author Wang WenLei
 * @date 2024/4/22 11:30
 * @since 1.0
 */

public class Main {

    private static final Deque<Integer> A = new LinkedList<>();

    public static void main(String[] args) {
        add(1);
        add(2);
        add(3);
        add(4);
        add(5);
        System.out.println("前：" + A.toString());
        System.out.println("弹出：" + pop());
        System.out.println("pop后1：" + A.toString());
        add(6);
        System.out.println("add后2：" + A.toString());
        System.out.println(pop());
        System.out.println("add后3：" + A.toString());
    }

    /**
     * 队列模拟栈的压栈操作
     * 在双端队里的最后添加元素
     *
     * @param data 压栈数据
     */
    public static void add(Integer data) {
        A.addLast(data);
    }

    /**
     * 队列模拟栈的出栈操作
     * 在双端队列的最后弹出元素
     */
    public static Integer pop() {
        return A.pollLast();
    }

}