队列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();

     }

 }