栈和队列

1.栈（Stack）
1）概念
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作，进行数据插入和删除操作的一端称为栈顶，另一端称为栈底，栈中的数据元素遵循后进先出的原则
压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶
出栈：栈的删除操作叫做出栈，出数据在栈顶
2）只支持三个核心操作：后进先出原则
a）入栈
b）出栈
c）取栈顶元素
3）实现
a）利用顺序表实现

package Java0319.Java0322;

public class MyStack {
    //管理一些int元素即可，也不考虑扩容问题
    private int[] array = new int[100];
    private int size = 0;//栈中存在多少个有效元素
    //入栈
    public void push(int x){
        array[size] = x;
        size++;
    }
    //出栈
    public int pop(){
        int ret = array[size-1];
        size--;
        return ret;
    }
    //取栈顶元素（最后进来的那个元素）
    public int peek(){
        return array[size-1];
    }
}

b）利用内置方法来实现

import java.util.Stack;

public class TestStack {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<Integer>();
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        int ret = stack.pop();
        System.out.println(ret);
        ret = stack.pop();
        System.out.println(ret);
        ret = stack.pop();
        System.out.println(ret);
        ret = stack.pop();
        System.out.println(ret);
    }
}

2.队列（Queue）
1）：概念
队列：只允许在一端进行插入数据操作，在另一端进行删除操作的特殊线性表，队列具有先进先出的原则
入队列：进行插入操作一端称为队尾
出队列：进行删除操作的一端称为队头

2）实现：
三个核心操作：
入队列 出队列 取队首元素
队列也可以数组和链表的结构实现，使用链表的结构显得更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低
a）数组实现：

public class MyQueueByArray {
    private int[] array = new int[100];
    //[head,tail)有效元素的范围，注意tail可能在head之前
    private int head = 0;
    private int tail = 0;
    private int size = 0;//元素个数
    public void offer(int val){
        if(size == array.length){
            //队列满了，无法继续插入
            return;
        }
        //得保证这个操作下标不能越界
        array[tail] = val;
        tail++;
        //tail++之后如果超过了数组的有效范围，就从头开始
        if(tail >= array.length){
            tail = 0;
        }
        size++;
    }
    public Integer poll(){
        if(size == 0){
            return null;
        }
        Integer ret = array[head];
        head++;
        if(head >= array.length){
            head = 0;
        }
        size--;
        return ret;
    }
    public Integer peek(){
        if(size == 0){
            return null;
        }
        return array[head];
    }
}

b）链表实现

public class MyQueueByLinkedList {
    //Node这个类叫做内部类，定义在某个类或者方法中的类
    //static效果就是：创建Node的实例不依赖MyQueueByLinkedList这个类的实例
    static class Node{
        public int val;
        Node next = null;
        public Node(int val){
            this.val = val;
        }
    }
    //创建一个链表，就得有头结点，此处head结点不是傀儡结点
    //基于链表来实现队列，可以入队列从尾部插入，出队列从头部删除
    //也可以入队列从头部插入，出队列从尾部删除
    //无论是哪种实现方式，最好都把头和尾都记录下来
    private Node head = null;
    private Node tail = null;
    //此处我按照尾部入队列，头部出队列的方式实现
    //入队列（标准库中的队列，入队列操作就叫offer）
    public void offer(int val){
        Node newNode = new Node(val);
        if(head == null){
            head = newNode;
            tail = newNode;
            return;
        }
        //如果当前不是空链表
        tail.next = newNode;
        tail = tail.next;
    }
    //出队列
    public Integer poll(){
        //如果当前队列就是空队列，再去poll显然不科学
        if(head == null){
            //如果出队列失败，返回一个错误信息
            return null;
        }
        int ret = head.val;
        head = head.next;
        if(head == null){
            //删除当前元素之后，队列变成了空的队列
            tail = null;
        }
        return ret;
    }
    //取队首元素
    public Integer peek(){
        if(head == null){
            return null;
        }
        return head.val;
    }

}