队列java实现

队列是一种线性数据结构，是一种运算受限的线性表，只允许在队尾插入，在队头删除。运算规则是先进先出。恰好和栈相反。栈是先进后出。因为栈只在栈顶做删除和插入。

队列按照存储结构可以分为顺序队列和链式队列。顺序队列采用数组实现，链式队列采用节点的方式实现。

//顺序队列

package queue;
//1.队列是一种运算受限的线性表，运算规则是先进先出。只能在队头和队尾进行操作
//2.队列由数据域，队头，队尾组成
//3.队列在队尾进行插入操作，在队头进行删除操作
public class Queue<E> {
    private Object[] data = null; //数据域
    private int front = 0;           //队头，允许删除
    private int rear = 0;           //队尾，允许插入
    private int maxSize = 0;       //队列容量
    
    //初始化队列
    public Queue(){
        this(10);
    }

    public Queue(int initialSize) {
        if(initialSize >= 0){
            this.data = new Object[initialSize]; //初始化数据域
            this.maxSize = initialSize;
        }else {
            throw new RuntimeException("初始化大小不能小于0:" + initialSize);
        }
    }
    
    //判断队列是否为空
    public boolean isEmpty(){
        return this.front == this.rear; //如果队头队尾相等说明为空
    }
    
    //判断队列是否已满
    public boolean isMaxSize(){
        return this.rear == this.maxSize ? true : false; //如果队尾指针大于最大容量，说明队列已经满了
    }
    
    //入队，从队尾插入，从队头删除
    public boolean push(E e){
        //判断队列是否已满
        if(this.isMaxSize()){
            System.err.println("队列已满，无法插入");
            return false;
        }
        data[rear] = e; //将元素插入到队尾 data[0] = 插入值
        rear++ ; //更新队尾指针
        return true;
    }
    
    //弹出队列
    @SuppressWarnings("unchecked")
    public E pop(){
        //判断是否为空，为空将无法出队
        if(isEmpty()){
            System.err.println("队列为空，无法插入");
            return null;
        }
        //在队头弹出
        E e = (E) data[front]; //对头引用
        data[front] = null; //将弹出的对头内存销毁
        front ++; //更新队头指针为后面的一位元素
        return e;
    }
    
    //返回队首元素，但不删除
    @SuppressWarnings("unchecked")
    public E peek(){
        if(isEmpty()){
            System.err.println("队列为空");
            return null;
        }
        
        return (E) this.data[front];
    }
    
    //遍历队列
    public void display(){
        while(front < rear){
            System.out.println(data[front]);
            front ++;
        }
    }
    
    //返回队列实际长度
    public int getSize(){
        return this.data.length;
    }
    
    public static void main(String args[]){
        Queue<Integer> queue = new Queue<Integer>();
        int i = 0;
        while(i < 10){
            queue.push(i);
            i ++;
        }
//        queue.pop();
        queue.display();
    }

}

//链式队列

package queue;

//链式队列，由队头和队尾节点组成，节点中包含数据域和指针域
public class LinkedQueue<E> {
    //1.定义队列结构
    //节点类
    @SuppressWarnings("hiding")
    private class Node<E>{
        public E data = null; //数据域
        public Node<E> next = null; //指针域
        
        //构造方法
        @SuppressWarnings("unused")
        public Node(){}
        
        public Node(E data, Node<E> next){
            this.data = data;
            this.next = next;
        }
        
    }/*Node*/
    
    private Node<E> front = null; //队头
    private Node<E> rear  = null; //队尾
    private int size = 0;         //队列长度
    
    //2.判断队列是否为空
    public boolean isEmpty(){
        return size == 0;
    }
    
    //3.入队
    public boolean push(E e){
        Node<E> node = new Node<E>(e, null);
        //队列为空的情况下
        if(isEmpty()){
            this.rear = node; //尾节点赋值为新插入的节点
            this.front = this.rear; //在只有一个节点的情况下，头尾节点相等
            size++;
            return true;
        }
        //不为空的情况下
        this.rear.next = node; //尾节点指向新节点
        this.rear = node; //更新尾节点
        size ++; //队列节点数+1
        return true;
    }
    
    //4.出队
    public E pop(){
        //判断队列是否为空
        if(isEmpty()){
            System.err.println("队列为空");
            return null;
        }
        //弹出队头，更新队头指针
        Node<E> temp = this.front; //获取队头引用
        this.front = this.front.next; //更新队头指针
        temp.next = null; //释放原队头节点引用
        return temp.data;
        
    }
    
    //5.返回队头但不删除
    public E peek(){
        //判断是否为空
        if(isEmpty()){
            System.err.println("为空，不能返回");
            return null;
        }
        return this.front.data;
    }
    
    //6.求长
    public int getSize(){
        return this.size;
    }
    
    //7.打印队列
    public void display(){    
        for (int i = 0; i < this.size; i++) {
            if(this.front == null){
                return;
            }
            System.out.println(this.front.data);
            this.front = this.front.next;
        }
    }
    
    public static void main(String args[]){
        LinkedQueue<Integer> queue = new LinkedQueue<Integer>();
        //1.入队
        int i = 0;
        while(i < 10){
            queue.push(i);
            i++;
        }
        
        //出队
        int j = 0;
        while(j < 8){
            System.out.println(queue.pop());
            j ++;
        }
        
        
//        queue.display();
        
    }
    

}