03.手写队列源码-queue

队列

队列（queue）是一种线性数据结构，队列中的元素只能先入先出（First In First Out，简称 FIFO）。
队列的出口端叫作队头（front），队列的入口端叫作队尾（rear）。

储存原理

队列这种数据结构既可以用数组来实现，也可以用链表来实现。

• 数组实现
  
  用数组实现时，为了入队操作的方便，把队尾位置规定为最后入队元素的下一个位置用数组实现的队列叫做顺序队列。

操作

• 入队
  入队（enqueue）就是把新元素放入队列中，只允许在队尾的位置放入元素，新元素的下一个位置将会成为新的队尾。
  

• 出队
  出队操作（dequeue）就是把元素移除队列，只允许在队头一侧移出元素，出队元素的后一个元素将会成为新的队头。
  

• 总结：队尾入队，队头出队。

数组实现

package dataStruct.queue;

import java.net.BindException;

public class QueueByArrary<E> implements Queue<E>{
    E [] arr = null;
    int head = 0; //队头
    int tail = 0; //队尾
    public QueueByArrary(int n){
        arr = (E[]) new Object[n];
    }

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

    @Override
    public boolean isEmpty() {
        return tail == 0;
    }

    @Override
    public void clear() {
       arr = null;
    }

    /**
     * 入队操作
     * @param element
     */
    @Override
    public void enQueue(E element)  {
        try {
            if (tail == arr.length) throw new IndexOutOfBoundsException("数组容量不够 :"+ tail +"数组长度为:"+ arr.length);
            arr[tail] = element;
            tail++;
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    @Override
    public E deQueue() {
        if (head == tail ) return  null;
        E num = arr[head];
        head++;
        return num;
    }

    public static void main(String[] args) {
        QueueByArrary arrQueue = new QueueByArrary(5);
        arrQueue.enQueue(1);
        arrQueue.enQueue(2);
        arrQueue.enQueue(3);
        arrQueue.enQueue(4);
        arrQueue.enQueue(5);

        for (int i = arrQueue.head ; i < arrQueue.tail; i++){
            System.out.print(arrQueue.arr[i]+" ");
        }
        System.out.println();
        System.out.println("出队："+arrQueue.deQueue());
        //剩余队列
        for (int i = arrQueue.head ; i < arrQueue.tail; i++){
            System.out.print(arrQueue.arr[i]+" ");
        }
    }
}

数组实现测试结果

链表实现

package dataStruct.queue;

import dataStruct.link.singleList.LinkedList;

/**
 * 链表实现队列
 */
public class ArrayByLinked<E> implements Queue<E>{
    int size = 0;
    Node<E> head = null;
    //定义内部类
    public static class Node<E>{
        E element;
        Node<E> next;
        public Node(E element, Node<E> node){
            this.element = element;
            this.next = node;
        }
    }

    /**
     * 求链表长度
     * @return
     */
    @Override
    public int size() {
        return size;
    }

    /**
     * 判断链表是否为空
     * @return
     */
    @Override
    public boolean isEmpty() {
        return head == null;
    }

    @Override
    public void clear() {
        head = null;
    }

    /**
     * 入队
     * @param element
     */
    @Override
    public void enQueue(E element) {
        Node<E> node = new Node<E>(element,head);
        head = node;
        size++;
    }

    @Override
    public E deQueue() {
        Node<E> node = node(size-1);
        //指定队头
        if(size == 0){
            head = head.next;
        }else{
            Node<E> node2 = node(size - 2);
            node2.next = node2.next.next;
        }
        size--;
        return node.element;
    }

    public Node<E> node(int index){
        Node<E> node = head;
        for (int i = 0; i < index; i++ ){
            node = node.next;
        }
        return node;
    }

    /**
     * 打印链表
     * @return
     */
    public String toString(){
        StringBuilder str = new StringBuilder();
        Node<E> node = head;
        str.append("size: " + size +" [");
        for (int i = 0 ; i < size ; i++){
            str.append(node.element);
            if(node.next != null){
                str.append("--->");
            }
            node = node.next;
        }
        str.append("]");
        return str.toString();
    }

    public static void main(String[] args) {
        ArrayByLinked link = new ArrayByLinked();
        link.enQueue(1);
        link.enQueue(2);
        link.enQueue(3);
        link.enQueue(4);
        link.enQueue(5);
        System.out.println("队列元素:"+link);
        link.deQueue();
        link.deQueue();
        System.out.println("队列元素："+link);

    }

}

链表实现测试结果