数据结构java（九）受限制的线性表 ②链式结构实现（双向链表实现队列LinkedQueue）

1.双向链表实现队列LinkedQueue实现

/**
 * 双向链表实现队列
 * @author Administrator
 */
public class LinkedQueue implements Queue {
    /**
     * 链表的结点个数
     */
    private int size;

    /**
     * 首结点
     */
    private Node first = new Node(null,null,null);

    /**
     * 尾结点
     */
    private Node last = new Node(null,null,null);

    /**
     * 初始化双向链表
     */
    public LinkedQueue() {
        this.first.next=last;
        this.last.prev=first;
        this.size = 0;
    }


    /**
     * 返回队列大小
     *
     * @return
     */
    @Override
    public int getSize() {
        return size;
    }

    /**
     * 判断队列是否为空
     *
     * @return
     */
    @Override
    public boolean isEmpty() {
        return size==0;
    }

    /**
     * 数据元素e入队
     *
     * @param e
     */
    @Override
    public void enqueue(Object e) {
        //新创建一个结点
        Node newNode  = new Node(null,e,null);
        Node p = last;
        newNode.prev=p.prev;
        newNode.next=p;
        p.prev.next=newNode;
        p.prev=newNode;
        size++;
    }

    /**
     * 队首元素出队
     *
     * @return
     */
    @Override
    public Object dequeue() {
        if (size==0){
            throw new MyArrayIndexOutOfBoundsException("空栈");
        }
        //删除的前一个结点
        Node prev = first;
        //删除的结点
        Node deleteNode = first.next;
        //删除的后一个结点
        Node next = deleteNode.next;
        //删除操作
        prev.next=next;
        next.prev=prev;
        deleteNode.prev=null;
        deleteNode.next=null;
        //数量-1
        size--;
        return deleteNode;
    }

    /**
     * 所有元素出队
     */
    @Override
    public void dequeueAll() {
        if (size == 0){
            throw new MyArrayIndexOutOfBoundsException("空栈");
        }
        StringBuilder builder = new StringBuilder("[");
        for (int i = size;i>0;i--){
            if (i!=1){
                builder.append(dequeue()+",");
            }else {
                builder.append(dequeue());
            }
        }
        builder.append("]");
        System.out.println(builder);
    }

    /**
     * 取队首元素
     *
     * @return
     */
    @Override
    public Object peek() {
        if (size==0){
            throw new MyArrayIndexOutOfBoundsException("空栈");
        }
        return first.next;
    }



    class Node {
        /**
         * 表示该节点包含的值
         */
        private Object object;
        /**
         * 表达当前节点的下一个节点
         */
        private Node next;
        /**
         * 表示当前节点的上一个节点
         */
        private Node prev;
        /**
         *
         * @param prev 上一个节点
         * @param element 当前节点
         * @param next 下一个节点
         */
        public Node(Node prev, Object object, Node next) {
            this.object = object;
            this.next = next;
            this.prev = prev;
        }

        @Override
        public String toString() {
            return "Node{" +
                    "object=" + object+
                    '}';
        }
    }

    //[0,1,2,3,4,5]
    @Override
    public String toString() {
        if (size == 0){
            return "[]";
        }
        StringBuilder builder = new StringBuilder("[");
        Node p = first.next;
        for (int i = 0;i<size;i++){
            if (i!=size-1){
                builder.append(p.object+",");
            }else {
                builder.append(p.object);
            }
            //移动到下一个结点
            p=p.next;
        }
        builder.append("]");
        return builder.toString() ;
    }
}

2.测试

/**
 * 测试
 * @author Administrator
 */
public class LinkedQueueTest {
    private Queue queue;
    @Before
    public void setUp() throws Exception {
        queue = new LinkedQueue();
        queue.enqueue(1);
        queue.enqueue(2);
        queue.enqueue(3);
        System.out.println("操作前："+queue+"大小："+queue.getSize());
    }

    @After
    public void tearDown() throws Exception {
        System.out.println("操作后："+queue+"大小："+queue.getSize());
    }

    @Test
    public void enqueue() {
        queue.enqueue(4);
        queue.enqueue(5);
        queue.enqueue(6);
    }

    @Test
    public void dequeue() {
        System.out.println(queue.dequeue());
        queue.enqueue(4);
        queue.enqueue(5);
        queue.enqueue(6);
        System.out.println(queue.dequeue());
        queue.dequeueAll();
    }

    @Test
    public void dequeueAll() {
        queue.dequeueAll();
    }

    @Test
    public void peek() {
        System.out.println(queue.peek());
    }
}

下一篇：数据结构java（十）二叉树①链式结构实现（LinkedBinaryTree）