用队列实现栈,用栈实现队列,听起来有点绕,都搞懂了就掌握了精髓!

目录
  • 一、背景
  • 二、概念
    • 2.1 栈
    • 2.2 队列
  • 三、栈和队列的相互实现
    • 3.1 用队列实现栈
    • 3.2 用栈实现队列
  • 四、总结

一、背景

清风中文网 https://m.198200.com

栈和队列是数据结构中最常用到的两种结构,有非常广泛的运用,该篇文章将通过动画的手段,展示栈和队列相互实现的底层原理,让我们真正搞懂栈和队列的特性。

二、概念

2.1 栈

栈[Stack]:是一种限定仅在表尾进行插入和删除操作的线性表;即后进先出(LIFO-last in first out),最后插入的元素最先出来

  • 入栈(push)
    在这里插入图片描述
  • 出栈 (pop)
    在这里插入图片描述
2.2 队列

 队列[Queue]:是一种限定仅在表头进行删除操作,仅在表尾进行插入操作的线性表;即先进先出(FIFO-first in first out):最先插入的元素最先出来。

  • 入队(enqueue)
  • 在这里插入图片描述
  • 出队(dequeue)
    在这里插入图片描述

三、栈和队列的相互实现

3.1 用队列实现栈
  • 模拟入栈的实现原理
    -- 栈的特性是新加入的元素出现在栈顶,保证后进先出。
    -- 队列的特性为新加入的元素出现在队尾,队列的队尾元素最后出队。
    -- 按以上两个前提,我们可以让队头至队尾前的其它所有元素依次出队再入队,直至在队尾新加入的元素被移到队头,也即实现了让新压入的元素保留在栈顶
    在这里插入图片描述

  • 模拟出栈的实现原理
    -- 由于在入栈时保证队列中新加入队尾的元素被移到了队头,出栈只需弹出队头元素即可。

  • 完整代码实现

/**
 * 用队列模拟实现栈
 *
 * @author zhuhuix
 * @date 2020-06-09
 */
public class QueueImplStack {

    // 定义队列
    private Queue<Integer> queue;

    public QueueImplStack() {
        queue = new LinkedList();
    }

    // 入栈--在队尾加入元素后,让其他元素按顺序出队再入队,保持新加入的元素永远在队头
    public void push(Integer e) {
        queue.offer(e);
        int size = queue.size();
        int i = 0;
        while (i < size - 1) {
            queue.offer(queue.poll());
            i++;
        }
    }

    // 出栈--将队尾前的其它所有元素出队再入队,直至队尾元素移到队头
    public Integer pop() {
        return queue.poll();
    }

    // 查看栈顶元素--即队头元素
    public Integer peek() {
        return queue.peek();
    }

    // 是否为空
    public boolean isEmpty() {
        return queue.isEmpty();
    }

    public static void main(String[] args) {
        QueueImplStack stack = new QueueImplStack();
        stack.push(1);
        System.out.println(stack.peek());
        stack.push(2);
        System.out.println(stack.peek());
        stack.push(3);
        System.out.println(stack.peek());
        System.out.println("=============");
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.isEmpty());

    }
}

3.2 用栈实现队列
  • 模拟入队的实现原理
    -- 队列的特性最新入队的元素需排在队尾,最先入队的元素排在队头,按队头到队尾的顺序依次出队。
    -- 对应到栈的数据结构上,也即需将新加入的元素保留在栈顶,保证先进先出。
    -- 按以上两个前提,需在存放数据的栈的基础上再增加一个辅助栈,在每次入队时,先将存放数据的栈弹入辅助栈,再把需加入的新元素压入数据栈底,最后把辅助栈中的元素弹出依次压入数据栈,这样保证了新加入的元素,沉在栈底。
    在这里插入图片描述
    - 模拟出队的实现原理
    -- 由于在入队时,通过数据栈与辅助栈的交换,实现了后加入的元素沉在栈底,先进入的元素保留在栈顶,直接通过出栈弹出即可。
    • 完整代码实现
/**
 * 用栈模拟实现队列
 *
 * @author zhuhuix
 * @date 2020-06-09
 */
public class StackImplQueue {
    // 数据栈
    private Stack<Integer> stack;
    // 辅助栈
    private Stack<Integer> aux;

    StackImplQueue() {
        stack = new Stack<>();
        aux = new Stack<>();
    }

    // 入队--通过数据栈与辅助栈相互交换,保证新加入的元素沉在数据栈底
    public void enqueue(Integer e) {
        while (!stack.isEmpty()) {
            aux.push(stack.pop());
        }
        stack.push(e);
        while(!aux.isEmpty()){
            stack.push(aux.pop());
        }

    }

    // 出队--弹出数据栈元素
    public Integer dequeue(){
        return stack.pop();
    }

    // 查看队头元素
    public Integer peek(){
        return stack.peek();
    }

    // 是否为空
    public boolean isEmpty(){
        return stack.isEmpty();
    }

    public static void main(String[] args) {
        StackImplQueue queue = new StackImplQueue();
        queue.enqueue(1);
        System.out.println(queue.peek());
        queue.enqueue(2);
        System.out.println(queue.peek());
        queue.enqueue(3);
        System.out.println(queue.peek());
        System.out.println("=============");
        System.out.println(queue.dequeue());
        System.out.println(queue.dequeue());
        System.out.println(queue.dequeue());

    }
}

四、总结

通过以上栈和队列相互交叉的实践,我们对栈和队列的重大特性有了深入了解:

  • 栈和队列都是线性连续结构,增加和删除元素不会影响破此连续性
  • 栈通过栈顶的操作实现元素的增加与删除,也即只能在一端进行操作
  • 队列通过队尾增加元素,队头删除元素,也即可以在两端操作
©️2020 CSDN 皮肤主题: 大白 设计师: CSDN官方博客 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值