栈和队列（小结）

近期开始接触栈和队列相关知识，特此根据现有知识对栈和队列做以小结，以下博客仅作为个人学习过程的小结，如能对各位博友有所帮助不胜荣幸。
本篇博客将简单介绍相关知识，以及其注意事项有哪些，只做本人小结，后期随学习深入再做补充修改。

栈（stack）:

概念

栈是一种特殊的线性表，在结点上的操作受到了限制，即上篇博客所提及的受限线性表。只能固定的从一段插入和删除结点，通俗上将允许进行插入删除操作的一端称为栈顶，想应的另一端称为栈底。将结点插入到栈顶中的操作称为入栈，而将栈顶结点删除的操作称为出栈。
他的特点为，后入先出——

队列（Queue）：

概念

队列同之前的栈一样也是一种受限线性表，其被限制表的前端进行删除，在表的后端进行插入，通俗上将删除端称为队头，将插入端称为队尾。
其特点为,先入先出——

双端队列（Deque）

概念：

双端队列是两端允进行插入删除操作的，它可以实现栈的操作同时也可以实现队列的操作

栈和队列的实现

• 仿写(java.util.impl.Queue)的 Queue 接口

package imp;

import java.util.NoSuchElementException;
//仿写(java.util.impl.Queue)的 Queue 接口

public interface Queue {
    //通过返回特殊值来通知错误的一组方法
    //插入(true 成功，false 失败)
    boolean offer(Integer e);
    //查看，返回队首元素，但不删除(返回null为空列表)
    Integer peek();
    //删除，返回并删除并删除首元素(返回null为空列表)
    Integer poll();

    //通过抛出异常来通知错误的一组方法
    //插入(永远返回true)
    default boolean add(Integer e){
        if(!offer(e)){
            throw new IllegalStateException();
        }
        return offer(e);
    }
    //查看，返回队首元素，但不删除
    default Integer element(){
        if(peek() == null){
            throw new NoSuchElementException();
        }
        return peek();
    }
    //删除，返回并删除并删除首元素
    default Integer remove(){
        if(poll() == null){
            throw new NoSuchElementException();
        }
        return poll();
    }
}

• 定义一个 Deque 接口让它继承 Queue 接口

package imp;

import java.util.NoSuchElementException;

public interface Deque extends Queue {
    //通过返回特殊值来通知错误的一组方法
    boolean offerFirst(Integer e);
    Integer peekFirst();
    Integer pollFirst();
    boolean offerLast(Integer e);
    Integer peekLast();
    Integer pollLast();

    //通过抛出异常来通知错误的一组方法
    default boolean addFirst(Integer e){
        if(!offerFirst(e)){
            throw new IllegalStateException();
        }
        return offerFirst(e);
    }

    default boolean addLast(Integer e){
        if(!offerLast(e)){
            throw new IllegalStateException();
        }
        return offerLast(e);
    }

    default Integer getFirst(){
        if(peekFirst() == null){
            throw new NoSuchElementException();
        }
        return peekFirst();
    }

    default Integer getLast(){
        if(peekLast() == null){
            throw new NoSuchElementException();
        }
        return peekLast();
    }

    default Integer removeFirst(){
        if(pollFirst() == null){
            throw new NoSuchElementException();
        }
        return pollFirst();
    }

    default Integer removeLast(){
        if(pollLast() == null){
            throw new NoSuchElementException();
        }
        return pollLast();
    }

    //继承自 Queue 的方法
    default boolean offer(Integer e){
        return offerLast(e);
    }
    //查看，返回队首元素，但不删除(返回null为空列表)
    default Integer peek(){
        return  getFirst();
    }
    //删除，返回并删除并删除首元素(返回null为空列表)
    default Integer poll(){
        return pollFirst();
    }

    //为 stack 准备的方法
    default void push(Integer e){
        addFirst(e);
    }
    default Integer pop(){
        return removeFirst();
    }
}

• 定义一个 LinkedList 类来实现 Deque 接口

package imp;

 public class LinkedList implements Deque{
    private static class Node{
        private Integer v;
        Node previous;
        Node next;
        Node(Integer e){
            v = e;
        }
        @Override
        public String toString() {
            return v + " ";
        }
    }
    private Node head;
    private Node tail;
    private int size;
    @Override
    public boolean offerFirst(Integer e) {
        Node node = new Node(e);
        if (size == 0) {
            head = node;
            tail = node;
        }else {
            head.previous = node;
            node.next = head;
            head = node;
        }
        size++;
        return true;
    }

    @Override
    public Integer peekFirst() {
        if(head == null){
            return null;
        }
        return head.v;
    }

    @Override
    public Integer pollFirst() {
        if(size == 0){
            return null;
        }
        int num = head.v;
        head = head.next;
        if(head != null){
            head.previous = null;
        }else{
            tail = null;
        }
        size--;
        return num;
    }

    @Override
    public boolean offerLast(Integer e) {
        Node node = new Node(e);
        if(size == 0){
            head = node;
        }else{
            node.previous = tail;
            tail.next = node;
        }
        tail = node;
        size++;
        return true;
    }

    @Override
    public Integer peekLast() {
        if(tail == null){
            return null;
        }
        return tail.v;
    }

    @Override
    public Integer pollLast() {
        if(size == 0){
            return null;
        }
        int num = tail.v;
        tail = tail.previous;
        if(tail != null){
            tail.next = null;
        }else{
            head = null;
        }
        size--;
        return num;
    }
 }

• 调试 自行实现的 Stack 和 Queue

package imp;

package imp;

public class MyStack {
    public static void main(String[] args) {
        Deque myStack = new LinkedList();
        myStack.push(1);
        System.out.print(myStack.peek()+" ");
        myStack.push(2);
        System.out.print(myStack.peek()+" ");
        myStack.push(3);
        System.out.print(myStack.peek()+" ");
        myStack.push(4);
        System.out.print(myStack.peek()+" ");
        myStack.push(5);
        System.out.println(myStack.peek()+" ");
        myStack.pop();
        System.out.println(myStack.peek());
    }
}

package imp;

public class MyQueue {
    public static void main(String[] args) {
        Deque myQueue = new LinkedList();
        myQueue.add(1);
        System.out.print(myQueue.element()+" ");
        myQueue.add(2);
        System.out.print(myQueue.element()+" ");
        myQueue.add(3);
        System.out.print(myQueue.element()+" ");
        myQueue.add(4);
        System.out.print(myQueue.element()+" ");
        myQueue.add(5);
        System.out.println(myQueue.remove());
        System.out.print(myQueue.element()+" ");
    }
}

以上即是本博客对 栈和队列 的总结，随着后续学习的深入还会同步的对内容进行补充和修改，如能帮助到各位博友将不胜荣幸，敬请斧正