java：数据结构复习（三）链表队列

@TOC 和栈一样，队列也是表，但是使用队列的特点是先进先出。

队列模型

队列的基本操作是入队，它是在表的末端插入一个元素，和出队，它是删除在表开头的一个元素

graph LR A[<kbd>入队</kbd>] --> b[队列] b[队列] --> c[<kbd>出队</kbd>]

队列的链表实现

链表队列的实现

import java.util.EmptyStackException;

/**
 * @author 李正阳
 * @param <E> 泛型
 */
public class MyLinkQueue<E> implements queue<E>  {
    /**
     * @param size 表中元素的个数
     * @param front 队头
     * @param rear 队尾
     */
    private int size=0;
    private Node<E> front;
    private Node<E> rear;

    /**
     * 入队方法
     * 在队尾添加节点
     * @param p 添加进表中的元素
     * @return true 添加成功 false 添加失败
     */
    @Override
    public boolean push(E p) {

        Node<E> d=new Node(p);
        /**
         * 空表就将队头队尾设置在同一个节点
         */
        if(isEmpty()){
            front=d;
            rear=d;
        }else{
            rear.setNext(d);
            d.setPre(rear);
            rear=d;
        }
        size++;
        return true;
    }

    /**
     *出队方法如果为空队列就抛出异常
     * 头删节点法
     *
     * @return
     */
    @Override
    public E pop() {
        Node<E> p;
        if(isEmpty()){
            throw new EmptyStackException();
        }else{
            p=front;
            front=front.getNext();
            front.setPre(null);
        }
        return p.getData();
    }

    /**
     * @return 返回表中的元素个数
     */
    @Override
    public int size() {
        return size;
    }

    /**
     * 输出表中元素从表头到表尾
     */
    @Override
    public void travel() {
        Node<E> p=front;
        while (p!=null){
            System.out.print(p.getData()+" ");
            p=p.getNext();
        }
        System.out.println();
    }

    /**
     * 判空方法
     * @return true 表为空 false 表不为空
     */
    @Override
    public boolean isEmpty() {
        if(size==0){
            return true;
        }else{
            return false;
        }
    }

    /**
     * 获得队尾元素
     * @return 队尾元素
     */
    @Override
    public E getRear() {
        return rear.getData();
    }
    /**
     * 获得队头元素
     * @return 队头元素
     */
    @Override
    public E getFront() {
        return front.getData();
    }

    /**
     * 内部内
     * @param <E> 节点类型
     */
    private class Node<E>{
        E data;
        Node<E> next;
        Node<E> pre;
        public Node(E data){
            this.data=data;
        }

        public Node(E data, Node next, Node pre) {
            this.data = data;
            this.next = next;
            this.pre = pre;
        }
        public Node(){
            next=null;
            pre=null;
            data=null;
        }
        public E getData() {
            return data;
        }

        public void setData(E data) {
            this.data = data;
        }

        public Node getNext() {
            return next;
        }

        public void setNext(Node next) {
            this.next = next;
        }

        public Node getPre() {
            return pre;
        }

        public void setPre(Node pre) {
            this.pre = pre;
        }
    }
}

队列的接口实现

/**
 * 队列的接口
 * @param <E> 泛型类型
 */
public interface queue<E> {
     /**
      * 入队方法
      * @param p
      * @return
      */
     boolean push(E p);

     /**
      * 出队方法
      * @return 返回泛型类型的方法
      */
     E pop();

     /**
      * 表中元素的大小
      * @return
      */
     int size();

     /**
      * 输出表中元素
      */
     void travel();

     /**
      * 判断表是否为空的
      * @return true 表是空的 false 表是非空
      */
     boolean isEmpty();

     /**
      * 获取表尾元素
      * @return 表尾的元素
      */
     E getRear();

     /**
      * 获取表头的元素
      * @return 表头的元素
      */
     E getFront();
}