栈和队列(Stack Queue)

1.栈（Stack）

1.1 概念

栈 ：一种特殊的线性表，其 只允许在固定的一端进行插入和删除元素操作 。进行数据插入和删除操作的一端称为栈

顶，另一端称为栈底。

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

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

1.2 栈的使用

代码演示

public static void main(String[] args) {
        Stack<Integer> s = new Stack<>();
        s.push(2);
        s.push(5);
        s.push(8);
        s.push(7);
        s.pop();
        System.out.println(s.peek());
        System.out.println(s.size());
        System.out.println(s);
    }

2. 队列

2.1 概念

队列 ：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出 FIFO

入队列：进行插入操作的一端称为 队尾

出队列：进行删除操作的一端称为队头

 2.2 队列的使用

代码实现

       LinkedList<Integer> list = new LinkedList();
        Queue<Integer> q = new LinkedList<>();
        q.offer(6);
        q.offer(5);
        q.offer(3);
        q.offer(2);
        //队列长度
        System.out.println(q.size());

        System.out.println(q);
        //出队列
        System.out.println(q.poll());

循环队列

 

    //循环队列
class MyCircularQueue {

    public int[] elem;
    public int rear; //尾
    public int front; //头

    public MyCircularQueue(int k) {
        //k + 1  是浪费一个空间
        this.elem = new int[k+1];
    }
        //入队列
    public boolean enQueue(int value) {
        //判断数组是否为满
       if(isFull()){
           return false;
       }
        elem[rear] = value;
       //循环使用rear
        rear = (rear + 1) % elem.length;
       return true;
    }
        //出队列
    public boolean deQueue() {
        if(isEmpty()){
            return false;
        }
        front = (front+1) % elem.length;
        return true;
    }
        //头元素
    public int Front() {
        if(isEmpty()){
            return -1;
        }
        return elem[front];
    }
        //尾元素
    public int Rear() {
        if(isEmpty()){
            return -1;
        }
        //
        int index = rear == 0 ? elem.length -1 : rear -1;
        return elem[index];
    }

    public boolean isEmpty() {
        return front == rear;
    }

    //判断是否满了
    public boolean isFull() {
        if((rear + 1) % elem.length == front){
            return true;
        }
        return false;
    }
}

 

3.双端队列

双端队列（ deque ）是指允许两端都可以进行入队和出队操作的队列， deque 是 “double ended queue” 的简称。

那就说明元素可以从队头出队和入队，也可以从队尾出队和入队      

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