栈和队列基本概念与实现

栈

1、概念
展示一种特殊的线性表，只允许在固定的一端进行插入元素和删除元素的操作。进行数据的插入删除的一端叫做栈顶，另一段叫做栈底，栈中的元素遵守先进后出的原则。
2、LIFO原则
栈遵守LIFO原则，Last In First Out，最后进入的最先出去，即先进后出。
3、生活中常见的栈结构
操作系统中方法的调用过程
浏览器的前进后退
编辑器的撤回操作
代码编辑器的括号匹配
算术运算的符号优先级
4、压栈
压栈就是在栈顶插入元素，也可以叫做进栈/入栈。
5、出栈
出栈就是将栈顶元素删除。
6、画图看一下进栈和出栈的过程

进栈的时候是进到最上面，出栈的时候最上面的元素先出去。
7、用顺序表简单实现栈结构

public class MyStack {
    //利用顺序表实现栈
    private int[] myStack = new int[100];
    //当前栈的长度
    private int size =0;

    /**
     * 压栈操作
     * @param val 传入要插入的元素
     */
    public void push(int val){
        //栈顶元素为val
        myStack[size] = val;
        //栈的长度加一
        size++;
    }

    /**
     * 出栈操作
     * 因为栈规定了出栈一定是出栈顶的元素
     * 所以无需传入参数
     */
    public void pop(){
        size--;
    }

    /**
     * 返回栈顶元素
     * @return
     */
    public int peek(){
        //返回栈最后进入的元素
        return myStack[size-1];
    }

    /**
     * 判空操作
     * @return
     */
    public boolean isEmpty(){
        //如果当前栈的长度为0
        //则表示栈为空
        if(size == 0){
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        MyStack myStack = new MyStack();
        myStack.push(1);
        myStack.push(2);
        myStack.push(3);
        System.out.println("当前的栈顶元素是：" + myStack.peek());
        System.out.println("判断当前栈是否为空：" + myStack.isEmpty());
        myStack.pop();
        System.out.println("当前的栈顶元素是：" + myStack.peek());
        myStack.pop();
        myStack.pop();
        System.out.println("判断当前栈是否为空：" + myStack.isEmpty());

    }
}

输出：

队列

1、概念
只允许在队列的一端进行插入操作，在另一端进行删除操作。进行插入操作的一端称为队尾，进行删除操作的一端称为队头。队列遵守先进后出的原则。
2、FIFO原则
队列遵守FIFO原则，First In First Out，先进先出。
3、画图看队列的出队入队过程

一端进入一端删除。
4、利用链表实现队列
因为队列是在一头插入一头删除，如果利用数组的话要不停的移动相较于链表来说或更复杂，所以我们选择利用链表来实现一个队列。

public class MyQueue {
    //Node类存放每一个元素
    private class Node{
        //存放元素的值
        private  int val;
        //与下一个元素连接
        private Node next;

        public Node(int val) {
            this.val = val;
        }
    }

    //对首元素
    private Node head = null;
    //队尾元素
    private Node tail = null;
    //队列长度
    private int size;

    /**
     * 入队操作
     * 队尾插入
     * @param value
     */
    public void offer(int value){
        //产生一个新的Node类对象存放要插入的元素
        Node node = new Node(value);
        //如果当前队列为空
        if(size == 0)
        {
            //则首元素就是新的插入的元素
            head = node;
        }
        else
        {
            //如果队列不为空
            //原本队尾就要加入新的元素
            tail.next = node;
        }
        //队尾变成新插入的元素
        tail = node;
        //队列长度加一
        size++;
    }

    /**
     * 出队操作
     * 从对首出队
     */
    public void poll(){
        //如果队列为空，则不需要出队
        if(size == 0)
        {
            System.out.println("队列为空！");
            return;
        }
        //如果队列中只有一个元素
        if(head.next == null)
        {
            //那么将唯一的元素出队后
            //队列为空
            head = tail =null;
        }
        else
        {
            //若队列有多个元素
            //对首元素不需要，head向后移动
            Node oldHead = head;
            head = head.next;
            oldHead.next = null;
        }
        //队列长度减一
        size--;
    }

    /**
     * 取出队首元素
     * @return
     */
    public int peek(){
        //如果队列为空，则没有队首元素
        if(size == 0)
        {
            System.out.println("队列为空");
            return -1;
        }
        //队列不为空，返回head的值
        return head.val;
    }

    /**
     * 判断队列是否为空
     * @return
     */
    public boolean isEmpty(){
        //若队列长度为0则为空
        //不为0 则不为空
        return size == 0;
    }

    public static void main(String[] args) {
        MyQueue myQueue = new MyQueue();
        myQueue.poll();
        myQueue.offer(1);
        myQueue.offer(2);
        myQueue.offer(3);
        System.out.println("当前队列对首元素是：" + myQueue.peek());
        myQueue.poll();
        System.out.println("当前队列对首元素是：" + myQueue.peek());
        myQueue.poll();
        myQueue.poll();
        System.out.println("当前队列是否为空：" + myQueue.isEmpty());
        myQueue.poll();
    }
}

输出：