本文主要向大家介绍了java语言实现队列顺序结构与链式结构，通过具体的内容向大家展示，希望对大家学习java语言有所帮助。

队列的顺序存储结构实现

public class Queue{

    private Object[] data=null;

    private int maxSize; //队列容量

    private int front;  //队列头，允许删除

    private int rear;   //队列尾，允许插入

    //构造函数

    public Queue(){

        this(10);

    }

    public Queue(int initialSize){

        if(initialSize >=0){

            this.maxSize = initialSize;

            data = new Object[initialSize];

            front = rear =0;

        }else{

            throw new RuntimeException("初始化大小不能小于0：" + initialSize);

        }

    }

    //判空

    public boolean empty(){

        return rear==front?true:false;

    }

    //插入

    public boolean add(E e){

        if(rear== maxSize){

            throw new RuntimeException("队列已满，无法插入新的元素！");

        }else{

            data[rear++]=e;

            return true;

        }

    }

    //返回队首元素，但不删除

    public E peek(){

        if(empty()){

            throw new RuntimeException("空队列异常！");

        }else{

            return (E) data[front];

        }   

    }

    //出队

    public E poll(){

        if(empty()){

            throw new RuntimeException("空队列异常！");

        }else{

            E value = (E) data[front];  //保留队列的front端的元素的值

            data[front++] = null;     //释放队列的front端的元素               

            return value;

        }           

    }

    //队列长度

    public int length(){

        return rear-front;

    }

}

循环队列的顺序存储结构实现

import java.util.Arrays;

public class LoopQueue{

    public Object[] data = null;

    private int maxSize; // 队列容量

    private int rear;// 队列尾，允许插入

    private int front;// 队列头，允许删除

    private int size=0; //队列当前长度

    public LoopQueue() {

        this(10);

    }

    public LoopQueue(int initialSize) {

        if (initialSize >= 0) {

            this.maxSize = initialSize;

            data = new Object[initialSize];

            front = rear = 0;

        } else {

            throw new RuntimeException("初始化大小不能小于0：" + initialSize);

        }

    }

    // 判空

    public boolean empty() {

        return size == 0;

    }

    // 插入

    public boolean add(E e) {

        if (size == maxSize) {

            throw new RuntimeException("队列已满，无法插入新的元素！");

        } else {

            data[rear] = e;

            rear = (rear + 1)%maxSize;

            size ++;

            return true;

        }

    }

    // 返回队首元素，但不删除

    public E peek() {

        if (empty()) {

            throw new RuntimeException("空队列异常！");

        } else {

            return (E) data[front];

        }

    }

    // 出队

    public E poll() {

        if (empty()) {

            throw new RuntimeException("空队列异常！");

        } else {

            E value = (E) data[front]; // 保留队列的front端的元素的值

            data[front] = null; // 释放队列的front端的元素

            front = (front+1)%maxSize;  //队首指针加1

            size--;

            return value;

        }

    }

    // 队列长度

    public int length() {

        return size;

    }

    //清空循环队列

    public void clear(){

        Arrays.fill(data, null);

        size = 0;

        front = 0;

        rear = 0;

    }

}

队列的链式存储结构实现

public class LinkQueue{

    // 链栈的节点

    private class Node{

        E e;

        Nodenext;

        public Node() {

        }

        public Node(E e, Node next) {

            this.e = e;

            this.next = next;

        }

    }

    private Node front;// 队列头，允许删除 

    private Node rear;// 队列尾，允许插入 

    private int size; //队列当前长度

    public LinkQueue() {

        front = null;

        rear = null;

    }

    //判空

      public boolean empty(){

          return size==0;

      }

      //插入

      public boolean add(E e){

          if(empty()){    //如果队列为空

              front = new Node(e,null);//只有一个节点，front、rear都指向该节点

              rear = front;

          }else{

              NodenewNode = new Node(e, null);

              rear.next = newNode; //让尾节点的next指向新增的节点

              rear = newNode; //以新节点作为新的尾节点

          }

          size ++;

          return true;

      }

      //返回队首元素，但不删除

      public Nodepeek(){

          if(empty()){

              throw new RuntimeException("空队列异常！");

          }else{

              return front;

          }

      }

      //出队

      public Nodepoll(){

          if(empty()){

              throw new RuntimeException("空队列异常！");

          }else{

              Nodevalue = front; //得到队列头元素

              front = front.next;//让front引用指向原队列头元素的下一个元素

              value.next = null; //释放原队列头元素的next引用

              size --;

              return value;

          }       

      }

      //队列长度

      public int length(){

          return size;

      }

}

本文由职坐标整理并发布，希望对同学们有所帮助。了解更多详情请关注职坐标编程语言JAVA频道！