队列的两种实现方式

和栈类似，用数组和链表来实现了了队列
首先是数组实现的；

/*
 * 用数组实现一个队列
 * 未处理边界情况
 */
public class MyQueue<E> {
    int size;
    int i=0;//队列头
    private Object[] queue;
    public MyQueue(){
        queue=new Object[10];
    }

    public boolean isEmpty(){
        return size==0;
    }

    public E put(E data){
        queue[size++]=data;
        return data;
    }

    public E pop(){


        @SuppressWarnings("unchecked")
        E tmp=(E) queue[i++];
        size--;
        return tmp;
    }

    public E peek(){

        return (E) queue[i];
    }
    public static void main(String[] args){
        MyQueue<Integer> s=new MyQueue<>();

        s.put(2);
        s.put(3);
        s.put(4);
        s.put(5);
        s.put(7);
        System.out.println(s.size);
        System.out.println("元素为"+s.pop());// 打印 2
        System.out.println("元素为"+s.pop());//3
        System.out.println("元素为"+s.pop());//4
        System.out.println("元素为"+s.peek());//5
    }
}

接着是用链表实现的队列：

/*
 * 用链表实现一个队列
 */
class Node_1<E>{
    Node_1<E>next=null;
    E data;
    public Node_1(E data){this.data=data;}
}
public class LinkedQueue<E> {

  private Node_1<E>head=null;
  private Node_1<E>tail=null;

    public boolean isEmpty(){
        return tail==head;
    }
    public void push(E data){
        Node_1<E>newNode=new Node_1<>(data);
        if(head==null&&tail==null)//判断队列是否为空 若不判断 则编译不过 空指针异常
            head=tail=newNode;
        else{
        tail.next=newNode;
        tail=newNode;}}

    public E pop(){
        if(this.isEmpty())
            return null;
        E data=head.data;
        head=head.next;
        return data;
    }
    public E peek(){
        return head.data;
    }
    public static void main(String[] args){
        LinkedQueue<Integer>myqueue=new LinkedQueue<>();
        myqueue.push(122);
        myqueue.push(144);
        myqueue.push(155);
        //myqueue.pop();
        System.out.print(myqueue.peek());//122

    }
}