前言：

        🌈✨前面小怡给大家分享了顺序表和链表，今天小怡给大家分享一下栈和队列。

1.栈 

1.1  概念 

          栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（last in first out）的原则。 

压栈：栈的插入操作叫做 进栈/压栈/入栈。入数据在栈顶。

出栈：栈的删除操作叫做出栈。出数据在栈顶。 

1.2  栈的使用 

方法	功能
Stack()	构造一个空的栈
E push(E e)	将e入栈，并返回e
E pop()	将栈顶元素出栈并返回
E peek()	获取栈顶元素
int size()	获取栈中有效元素个数
boolean empty()	检测栈是否为空

 

1.3  栈的模拟实现 

         Stack继承了Vector，Vector和ArrayList类似，都是动态的顺序表，不同的是Vector是线程安全的。

入栈：

• 如果采用尾插法入栈：入栈时间复杂度为O（n），如果有last，那么是O（1），但是出栈操作一定是O（n）；
• 如果采用头插法入栈：入栈时间复杂度为O（1），同时出战复杂度也是O（1）；

结论：

        如果采用单链表来实现栈，可以采用头插法的形式入栈和出栈。 

import java.util.Arrays;
public class Stack {
    int[] element;
    int usedSize;
    public Stack(){
        this.element=new int[10];
    }
    public int push(int val){
        if(isFull()){
            this.element= Arrays.copyOf(element,2*element.length);
        }
        element[usedSize++]=val;
        return val;
    }
    public int pop(){
        int val=peek();
        usedSize--;
        return val;
    }
    public int peek(){
        if(empty()){
            throw new RuntimeException("栈为空，无法获取栈顶元素");
        }
        return element[usedSize-1];
    }
    public boolean empty(){
        return 0==usedSize;
    }
    public boolean isFull(){
        return usedSize==element.length;
    }
}

 

1.4   栈的应用场景 

    改变元素的序列 

 1.若进栈序列为1，2，3，4，进栈过程中可以出栈，则下列不可能的一个出栈序列是（）；

A.1，4，3，2                 B.2，3，4，1

C.3，1，4，2                 D.3，4，2，1

答案是：C

2.一个栈的初始状态为空。现将1、2、3、4、5、A、B、C、D、E依次入栈，然后再依次出栈，则元素出栈的顺序是（）；

A.12345ABCDE

B.EDCB54321

C.ABCDE12345

D.54321EDCBA

答案是：B 

        采用双向链表来实现栈是完全可以的，入栈不管是头插法还是尾插法，都是可以实现的，时间复杂度都可以达到O（1）。

 

1.5  概念区分 

         栈、虚拟机栈、栈帧有什么区别呢？

1. 栈：一种数据结构；
2. 虚拟机栈：当运行一个函数/方法，给其开辟的一块内存；
3. 栈帧：JVM中的一块内存。 

 2.队列

2.1   概念 

          队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)。从队尾进，队头出。

         入队列：进行插入操作的一端称为队尾（Tail/Rear）。

         出队列：进行删除操作的一端称为队头（Head/Front）。

 

2.2   队列的使用 

          在Java中，Queue是个接口，底层是通过链表实现的。 

方法	功能
boolean offer(E e)	入队列
E poll()	出队列
peek()	获取队头元素
int size()	获取队列中有效元素个数
boolean isEmpty()	检测队列是否为空

注意：Queue是个接口，在实例化时必须实例化LinkedList的对象，因为LinkedList实现了Queue接口。

 

2.3   队列模拟实现 

           队列中既然可以存储元素，那底层肯定是要有能够保存元素的空间，通过前面线性表的学习了解到常见的空间类型有两种：顺序结构 和 链式结构。那么队列的实现用哪个更好呢？

       单链表可以实现：单链表加上一个标记尾节点的引用。入队可以采用尾插法，出队可以删除头节点。

       注意：就算是有尾结点的标记，也不能从头节点入队，因为删除还是需要找最后一个节点的前一个节点。

       双链表可以实现：如果是双向链表，链表的头和尾都是可以进行入队的。 

2.4   循环队列 

           实际中我们有时还会使用一种队列叫循环队列。如操作系统课程讲解生产者消费者模型时可以就会使用循环队列。环形队列通常使用数组实现。

数组下标循环的小技巧 

 1.下标最后再往后（offset小于array.length）：index=（index+offset）%array.length；

2.下标最前再往前（offset小于array.length）：index=（index+array.length-offset）%array.length

如何区分空与满

空：只要front和rear相遇，就是空的；

满：1.通过添加size属性记录；

        2.保留一个位置。判断：rear的下一个是不是front；

        3.使用标记，定义boolean类型元素。

 

3.双端队列 

            双端队列（deque）是指允许两端都可以进行入队和出队操作的队列，deque是“double ended queue”的简称，那就说明元素可以从队头出队和入队，也可以从队尾出队和入队。

           Deque是一个接口，使用时必须创建LinkedList的对象。 

           在实际的工程中，使用Deque接口是比较多的，栈和队列均可以使用该接口。

 

 

4.面试题

1.用队列实现栈 

          用队列实现栈，指的是用普通的队列来实现栈。

1.模拟的入栈操作是：放到了 不为空的队列当中。

2. 模拟的出栈操作是：把不为空的队列中的size-1个元素放到另一个队列当中。最后剩下的                                         这一个就是我们模拟“出栈”的元素。

import java.util.LinkedList;
import java.util.Queue;
public class MyStack {
    public Queue<Integer> qu1;
    public Queue<Integer> qu2;
    public MyStack(){
        qu1=new LinkedList<>();
        qu2=new LinkedList<>();
    }
    public void push(int x){
        if(!qu1.isEmpty()){
            qu1.offer(x);
        }else if(!qu2.isEmpty()){
            qu2.offer(x);
        }else{
            qu1.offer(x);
        }
    }
    public int pop(){
        if(empty()){
            return -1;
        }
        if(!qu1.isEmpty()){
            int size=qu1.size();
            for(int i=0;i<size-1;i++){
                qu2.offer(qu1.poll());
            }
            return qu1.poll();
        }else {
            int size=qu2.size();
            int val=0;
            for(int i=0;i<size-1;i++){
                qu1.offer(qu2.poll());
            }
            return qu2.poll();
        }
    }
    public int top(){
        if(empty()){
            return -1;
        }
        if(!qu1.isEmpty()){
            int size=qu1.size();
            int val=0;
            for(int i=0;i<size;i++){
                val=qu1.poll();
                qu2.offer(val);
            }
            return val;
        }else {
            int size=qu2.size();
            int val=0;
            for(int i=0;i<size;i++){
                val=qu2.poll();
                qu1.offer(val);
            }
            return val;
        }
    }
    public boolean empty(){
        return qu1.isEmpty()&&qu2.isEmpty();
    }
}

2.用栈实现队列 

  模拟队列的入队操作：都是放到第一个栈。

1. 判断第2个栈是不是空的？如果是空的需要把第一个栈当中的所有元素都放到第二个栈里，取出第二个栈当中的栈顶元素；
2. 如果不是空的，直接取出第二个栈当中的栈顶元素。 

import java.util.ArrayDeque;

public class MyQueue {
    public ArrayDeque<Integer> stack1;
    public ArrayDeque<Integer> stack2;
    public MyQueue(){
        stack1=new ArrayDeque<>();
        stack2=new ArrayDeque<>();
    }
    public void push(int x){
        stack1.push(x);
    }
    public int pop(){
        if(empty()){
            return -1;
        }
        if(stack2.isEmpty()){
            //第一个栈里面所有的元素 放到第二个栈当中
            while(stack1.isEmpty()){
                stack2.push(stack1.pop());
            }
        }
        return stack2.pop();
    }
    public int peek(){
        if(empty()){
            return -1;
        }
        if(stack2.isEmpty()){
            //第一个栈里面所有的元素 放到第二个栈当中
            while(stack1.isEmpty()){
                stack2.push(stack1.pop());
            }
        }
        return stack2.peek();
    }
    public boolean empty(){
        return stack1.isEmpty()&&stack2.isEmpty();
    }
}

🌈✨今天的分享到这里结束啦，小怡和大家一起分享一起学习一起进步，“成功路上并不拥挤，因为坚持的人不多”。