使用栈实现队列 使用队列实现栈

使用栈实现队列

package com.grow.up.learn.algorithm;

import java.util.Stack;

/**
 * @ClassName: StackChangeQueue
 * @Description: 使用两个栈实现队列
 * @Author: wgl
 * @Date: 2022/11/29 16:59
 */
public class StackChangeQueue {


    /**
     * 实现思路
     * 栈  先进后出
     * 队列 先进先出   java规定  从头部进入  从尾部取出
     */

    private Stack stack1 = new Stack<Integer>();
    private Stack stack2 = new Stack<Integer>();


    //将元素先入栈    栈底6 5 4 3 2 1栈顶
    public void add(Integer item) {
        stack1.push(item);
    }


    /**
     * 栈先进后出，将stack1中的元素依次取出存入stack2   从栈底取
     * 此时stack2中   栈底1 2 3 4 5 6栈顶
     *
     * @return
     */
    public Object poll() {
        if (stack1.empty() && stack2.empty()) {
            System.out.println("空队列");
            return null;
        }

        if (stack2.empty()) {
            while (!stack1.empty()) {
                stack2.push(stack1.pop());
            }
        }
        return stack2.pop();
    }


    public static void main(String[] args) {
        Integer[] nums = {1, 2, 3, 4, 5, 6};
        StackChangeQueue stackChangeQueue = new StackChangeQueue();
        for (int num : nums) {
            stackChangeQueue.add(num);
        }
        for (int num : nums) {
            System.out.println(stackChangeQueue.poll());
        }
    }
}

使用队列实现栈

package com.grow.up.learn.algorithm;

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.concurrent.LinkedBlockingQueue;

/**
 * @ClassName: QueueChangeStack
 * @Description: 用队列实现栈
 * @Author: wgl
 * @Date: 2022/11/29 17:33
 */
public class QueueChangeStack {

    private Queue queue1 = new PriorityQueue();
    private Queue queue2 = new LinkedBlockingQueue();

    /**
     * 第一种方式
     * 将 1放入queue2   将queue2赋值给queue1   queue2置为空     queue1  queue2  1->>>   queue1   1       queue2
     * 将 2 放入queue2     将queue1的值又放入queue2    将queue2赋值给queue1   queue2置为空       queue1        1     queue2  2->>>  queue1        1       queue2        2 1->>> queue1        2 1       queue2
     * 将 3 放入queue2     将queue1的值又放入queue2    将queue2赋值给queue1   queue2置为空       queue1      2 1     queue2  3->>>  queue1      2 1       queue2      3 2 1->>> queue1      3 2 1       queue2
     * 将 4 放入queue2     将queue1的值又放入queue2    将queue2赋值给queue1   queue2置为空       queue1     3 2 1     queue2  4->>>  queue1    3 2 1       queue2    4 3 2 1->>> queue1    4 3 2 1       queue2
     * 将 5 放入queue2     将queue1的值又放入queue2    将queue2赋值给queue1   queue2置为空       queue1   4 3 2 1     queue2  5->>>  queue1  4 3 2 1       queue2  5 4 3 2 1->>> queue1  5 4 3 2 1       queue2
     *
     * @param item
     */
    private void push1(Object item) {
        queue2.offer(item);
        while (!queue1.isEmpty()) {
            queue2.offer(queue1.poll());
        }
        Queue temp = queue1;
        queue1 = queue2;
        queue2 = temp;

    }


    private Object poll1() {
        return queue1.poll();
    }


    /**
     * 第二种方式  使用一个队列实现栈
     * <p>
     * 队头---队尾
     * 1                  1
     * 1 2              2 1   2入队列之后，将1先移除在移入
     * 2 1 3          3 2 1   3入队列后，将2先移除在移入   再将1先移除再移入
     * 3 2 1 4      4 3 2 1   4入队列后，将3先移出再移入   将2先移除在移入   再将1先移除再移入
     */
    public void push2(Object item) {
        int count = queue1.size();
        queue1.offer(item);
        for (int i = 0; i < count; i++) {
            queue1.offer(queue1.poll());
        }
    }

    private Object poll2() {
        return queue1.poll();
    }


    /**
     * 第三种实现方式
     * 双端队列
     * 可以从队尾出或者进   也可以从队头出或者进
     */

    ArrayDeque arrayDeque = new ArrayDeque();


    public void push3(Object item) {
        arrayDeque.offer(item);
    }

    private Object poll3() {
        return arrayDeque.pollLast();
    }


    public static void main(String[] args) {
//        Integer []nums ={1,2,3,4,5,6};
//        QueueChangeStack queueChangeStack=new QueueChangeStack();
//        for (int num:nums) {
//            queueChangeStack.push1(num);
//        }
//        for (int num:nums) {
//            System.out.println(queueChangeStack.poll1());
//        }
//
//        Integer []nums ={1,2,3,4,5,6};
//        QueueChangeStack queueChangeStack=new QueueChangeStack();
//        for (int num:nums) {
//            queueChangeStack.push2(num);
//        }
//        for (int num:nums) {
//            System.out.println(queueChangeStack.poll2());
//        }


        Integer[] nums = {1, 2, 3, 4, 5, 6};
        QueueChangeStack queueChangeStack = new QueueChangeStack();
        for (int num : nums) {
            queueChangeStack.push3(num);
        }
        for (int num : nums) {
            System.out.println(queueChangeStack.poll3());
        }
    }

}