【数据结构与算法（Java描述）】双向链表，实现双端队列Deque

来源于书籍《数据结构与算法（Java描述）》邓俊辉 著 机械工业出版社

双向链表

* @Description: 双向链表
 */
public class DLNode implements Position{
    
    
    private Object element;//数据对象
    private DLNode prev;//前驱
    private DLNode next;//后继

    //构造函数
    public DLNode() {
    
    
        this(null,null,null);
    }

    public DLNode(Object element, DLNode prev, DLNode next) {
    
    
        this.element = element;
        this.prev = prev;
        this.next = next;
    }

    //Position接口方法
    @Override
    public Object getElem() {
    
    
        return element;
    }

    @Override
    public Object setElem(Object e) {
    
    
        Object old=element;
        element=e;
        return old;
    }

    //双向链表方法
    public DLNode getNext() {
    
    
        return next;
    }

    public DLNode getPrev() {
    
    
        return prev;
    }

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

    public void setPrev(DLNode prev) {
    
    
        this.prev = prev;
    }
}

实现双端队列Deque

public interface Deque {
    
    
    int getSize();
    boolean isEmpty();
    Object first() throws QueueEmptyException;//取首元素，但不删除
    Object last() throws QueueEmptyException;//取末元素，但不删除
    void insertFirst(Object o);
    void insertLast(Object o);
    Object removeFirst() throws QueueEmptyException;
    Object removeLast() throws QueueEmptyException;
    void Traversal();//遍历
}

public class DequeByDLNode implements Deque{
    
    
    private DLNode header;//指向头节点（哨兵）
    private DLNode trailer;//指向尾节点（哨兵）
    private int size;

    public DequeByDLNode() {
    
    
        header=new DLNode();
        trailer=new DLNode();
        header.setNext(trailer);
        trailer.setNext(header);
        size=0;
    }

    @Override
    public int getSize() {
    
    
        return size;
    }

    @Override
    public boolean isEmpty() {
    
    
        return (0==size)?true:false;
    }

    @Override
    public Object first() throws QueueEmptyException {
    
    
        if(isEmpty()){
    
    
            throw new QueueEmptyException("Queue is empty!");
        }
        return header.getElem();
    }

    @Override
    public Object last() throws QueueEmptyException {
    
    
        if(isEmpty()){
    
    
            throw new QueueEmptyException("Queue is empty!");
        }
        return trailer.getElem();
    }

    @Override
    public void insertFirst(Object o) {
    
    
        DLNode second=header.getNext();
        DLNode first=new DLNode(o,header,second);
        second.setPrev(first);
        first.setNext(second);
        size++;
    }

    @Override
    public void insertLast(Object o) {
    
    
        DLNode second=trailer.getPrev();
        DLNode first=new DLNode(o,second,trailer);
        second.setNext(first);
        trailer.setPrev(first);
        size++;
    }

    @Override
    public Object removeFirst() throws QueueEmptyException {
    
    
        if(isEmpty()){
    
    
            throw new QueueEmptyException("Queue is empty!");
        }
        DLNode first=header.getNext();
        DLNode second=first.getNext();
        Object elem = first.getElem();
        header.setNext(second);
        second.setPrev(header);
        size--;
        return elem;
    }

    @Override
    public Object removeLast() throws QueueEmptyException {
    
    
        if(isEmpty()){
    
    
            throw new QueueEmptyException("Queue is empty!");
        }
        DLNode first=trailer.getPrev();
        DLNode second=first.getPrev();
        Object elem=first.getElem();
        trailer.setPrev(second);
        second.setNext(trailer);
        return elem;
    }

    @Override
    public void Traversal() {
    
    
        DLNode p=header.getNext();
        while (null!=p){
    
    
            System.out.println(p.getElem()+" ");
            p=p.getNext();
        }
        System.out.println();
    }
}