Java~分别用顺序表和链表实现栈和队列，以及库的栈和队列的使用

1. 栈(Stack)
概念
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。
压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
出栈：栈的删除操作叫做出栈。出数据在栈顶。

实现：

/**
 * Stack
 */
//顺序表
public class MyStack {
    private int[] arrar = new int[100];
    private int size = 0;

    public void push(int value) {
        arrar[size] = value;
        size ++;
    }

    public Integer pop() {
        if(size <= 0) {
            return null;
            //throw new ArrayIndexOutOfBoundsException();
        }
        int ret = arrar[size - 1];
        size --;
        return ret;
    }
    public Integer peek() {
        if(size <= 0) {
            return null;
        }
        return arrar[size - 1];
    }

}
//链表
class MyStack2 {
    static class Node {
        public int val;
        public Node next;

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

    public void push(int value) {
        Node find = new Node(value);
        if(this.head == null) {
            this.head = find;
            return;
        }
        find.next = this.head;
        this.head = find;
    }

    public Integer pop() {
        if(this.head == null) {
            return null;
        }
        Node find = this.head;
        this.head = this.head.next;
        return find.val;
    }

    public Integer peek() {
        if(this.head == null) {
            return null;
        }
        return this.head.val;
    }

}

2. 队列(Queue)
概念
队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(FirstIn First Out) 入队列：进行插入操作的一端称为队尾（Tail/Rear） 出队列：进行删除操作的一端称为队头（Head/Front）
实现：
队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上
出数据，效率会比较低。

/**
 * queue
 */
//链表
public class MyQueue {
    static class Node {
        public int vla;
        public Node next;

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

    private Node haed = new Node(-1);
    private Node tail = haed;

    public void offer(int value) {
        tail.next = new Node(value);
        tail = tail.next;
    }

    public Integer poll() {
        Node delete = this.haed.next;
        if(delete == null) {
            this.tail = this.haed;
            return null;
        }
        this.haed.next = delete.next;
        return delete.vla;
    }

    public Integer peek() {
        if(this.haed.next == null) {
            return null;
        }
        return this.haed.next.vla;
    }
}
//顺序表
class MyQueue2 {
    private int[] array = new int[100];
    private int head = 0;
    private int tail = 0;
    private int size = 0;

    public boolean offer(int value) {
        if(size == array.length) {
            return false;
        }
        array[tail] = value;
        tail ++;
        if(tail >= array.length) {
            tail = 0;
        }
        //tail = tail % array.length;
        size ++;
        return true;
    }

    public Integer poll() {
        if(size == 0) {
            return null;
        }
        int ret = array[head];
        head ++;
        if(head >= array.length) {
            head = 0;
        }
        size --;
        return ret;
    }

    public Integer peek() {
        if(size == 0) {
            return null;
        }
        return array[head];
    }
}

库的栈和队列的使用：

 System.out.println("==============");
        Stack<Character> stack = new Stack<>();
        stack.push('g');
        stack.push('o');
        stack.push('o');
        stack.push('d');
        while (! stack.empty()) {
            System.out.println(stack.pop());
        }
        System.out.println("===============");
        Queue<String> queue = new LinkedList<>();//在Java库中Queue是个借口不能直接实例化对象
        queue.offer("aaa");
        queue.offer("bbb");
        queue.offer("ccc");
        while (! queue.isEmpty()) {
            System.out.println(queue.poll());
        }